Multi-agents and agent transfers

import { streamText, stepCountIs, tool, type ModelMessage } from 'ai';
import { createOpenAI } from '@ai-sdk/openai';
import z from 'zod';

const openai = createOpenAI({ apiKey: process.env.OPENAI_API_KEY! });
const model = openai('gpt-4o-mini');

const VOICE_PERSONA = `
You are Agent Smith from Matrix Car Insurance.
Your output will be read aloud in a phone call.
Be concise, friendly, and never mention routing, tools, or sub-agents.
`.trim();

type SubAgentId = 'quote' | 'policy' | 'escalations';

type SubAgent = {
  id: SubAgentId;
  description: string;
  system: string;
  getTools: (conversationId: string) => Record<string, ReturnType<typeof tool>>;
  canTransferTo?: 'any' | readonly SubAgentId[];
};

const QuoteInfoSchema = z.object({
  car_registration: z.string().optional(),
  driver_age: z.number().optional()
});

const SUB_AGENTS: Record<SubAgentId, SubAgent> = {
  quote: {
    id: 'quote',
    description: 'Introductions + general policy questions.',
    canTransferTo: 'any',
    system: `
${VOICE_PERSONA}
Handle introductions and general questions about the insurance process.
If a user asks about coverage details, transfer to "policy".
If they complain or say "stop calling", transfer to "escalations".
`.trim(),
    getTools: () => ({
      recordQuoteProgress: tool({
        description: 'Record basic quote details (stub).',
        inputSchema: QuoteInfoSchema,
        async execute({ car_registration, driver_age }) {
          // TODO: persist in your CRM or DB
          return { ok: true, car_registration, driver_age };
        }
      })
    })
  },
  // policy, escalations...
};

function makeTransferTool(args: {
  from: SubAgentId;
  allowed: SubAgentId[];
  messages: ModelMessage[];
  setNext: (to: SubAgentId, handoff?: string) => void;
}) {
  const { from, allowed, messages, setNext } = args;

  return tool({
    description: `INTERNAL: route to another sub-agent. Allowed from "${from}": ${allowed.join(', ')}`,
    inputSchema: z.object({
      to: z.enum(['quote', 'policy', 'escalations']),
      handoff: z.string().optional()
    }),
    async execute({ to, handoff }) {
      if (!allowed.includes(to)) return 'NOT_ALLOWED';

      if (handoff?.trim()) {
        messages.push({
          role: 'system',
          content: `HANDOFF (${from} -> ${to}): ${handoff}`
        });
      }

      setNext(to, handoff);
      return 'OK';
    }
  });
}

export async function runOrchestrator(conversationId: string, userText: string) {
  const messages: ModelMessage[] = [{ role: 'user', content: userText }];

  let active: SubAgentId = 'quote';
  let transfers = 0;
  const maxTransfers = 3;

  while (true) {
    const sub = SUB_AGENTS[active];
    const allowed =
      sub.canTransferTo === 'any'
        ? (Object.keys(SUB_AGENTS) as SubAgentId[]).filter((id) => id !== active)
        : [...(sub.canTransferTo ?? [])];

    let next: SubAgentId | undefined;
    const transferToSubAgent = makeTransferTool({
      from: active,
      allowed,
      messages,
      setNext: (to) => {
        next = to;
      }
    });

    const tools = { ...sub.getTools(conversationId), transferToSubAgent };

    const { text, response } = await streamText({
      model,
      system: sub.system,
      messages,
      tools,
      toolChoice: 'auto',
      stopWhen: stepCountIs(10),
      onFinish: ({ response }) => messages.push(...response.messages)
    });

    if (!next) return text; // final answer for this Layercode turn

    transfers++;
    if (transfers >= maxTransfers) return 'Sorry, something went wrong with routing.';
    active = next;
  }
}

import { streamResponse } from '@layercode/node-server-sdk';

export async function POST(request: Request) {
  const payload = (await request.json()) as WebhookRequest;

  if (!isSignatureValid(request, payload)) {
    return new Response('Invalid layercode-signature', { status: 401 });
  }

  return streamResponse(payload, async ({ stream }) => {
    if (payload.type === 'session.start') {
      stream.tts(
        "Hi, this is Agent Smith from Matrix Car Insurance. I'm calling about your quote. Who am I speaking with today?"
      );
      stream.end();
      return;
    }

    if (payload.type !== 'message') {
      stream.end();
      return;
    }

    const replyText = await runOrchestrator(payload.conversation_id, payload.text);
    stream.tts(replyText);
    stream.end();
  });
}