A workflow that delegates a turn to an agent

import { z } from 'zod';
import { callDeepAgent } from '@stackbone/sdk/workflow';

export const inputSchema = z.object({
  email: z.email(),
  company: z.string(),
  note: z.string(),
});
export const outputSchema = z.object({
  email: z.string(),
  score: z.number(),
  rationale: z.string(),
});

const verdictSchema = z.object({
  score: z.number().min(0).max(100),
  rationale: z.string(),
});

export async function triageLeadWorkflow(input: z.infer<typeof inputSchema>) {
  'use workflow';

  const clean = await validate(input); // deterministic gate
  const verdict = await scoreWithAgent(clean.company, clean.note); // agent judgment

  return { email: clean.email, score: verdict.score, rationale: verdict.rationale };
}

async function validate(input: z.infer<typeof inputSchema>) {
  'use step';
  if (!input.company.trim()) throw new Error('Missing company');
  return input;
}

async function scoreWithAgent(company: string, note: string) {
  'use step';
  const { text } = await callDeepAgent(
    'lead-qualifier',
    `Company: ${company}\nNote: ${note}\n` +
      'Score this lead from 0 to 100 and explain why. ' +
      'Reply with JSON only: {"score": number, "rationale": string}.',
  );
  // A malformed reply throws here, which fails the step and applies the
  // run's retry policy: a retry re-runs the whole turn.
  return verdictSchema.parse(JSON.parse(text));
}