Build a restaurant reservation phone agent

const joinGrant = {
  roomUrl: "https://livekit.example.test",
  participantToken: "<short-lived room token>",
  expiresAt: "2026-07-19T02:00:00.000Z",
};

import { Eyeball } from "@eyeball/sdk";

const eyeball = new Eyeball({
  apiKey: process.env.EYEBALL_API_KEY!,
  baseUrl: process.env.EYEBALL_EXECUTOR_URL!,
});
const executorUrl = process.env.EYEBALL_EXECUTOR_URL!.replace(/\/$/u, "");
const userId = "diner_restaurant_demo";
const object = (value: unknown): Record<string, unknown> => {
  if (typeof value !== "object" || value === null || Array.isArray(value)) {
    throw new Error("Expected an object");
  }
  return value as Record<string, unknown>;
};

const created = object(
  await eyeball.tools.run(
    "voice-agents.create_voice_agent",
    {
      agent: {
        name: "Table Host",
        systemPrompt:
          "Confirm date, time, party size, name, and email before booking.",
        llm: { model: "model:fixture:restaurant-concierge" },
        voice: {
          tts: { provider: "elevenlabs", voiceId: "voice_fixture_warm_host" },
          stt: { provider: "deepgram", model: "nova-3", language: "en" },
        },
        transport: "pstn:twilio",
        tools: ["google-calendar.create_event", "gmail.send_email"],
        guardrails: {
          maxDurationSeconds: 600,
          handoffToHuman: { enabled: false },
        },
        webhooks: {
          endpointIds: [],
          transcript: true,
          events: ["session.lifecycle", "turn.transcript", "tool_call", "tool_result"],
        },
        recordingPolicy: {
          mode: "disabled",
          consent: "external",
          retentionDays: 0,
          redactDtmf: true,
        },
      },
    },
    { userId, idempotencyKey: "restaurant:create-agent" },
  ),
);
const agent = object(created.agent);

const pending = await eyeball.tools.execute("voice-agents.start_agent_call", {
  userId,
  mode: "async",
  idempotencyKey: "restaurant:start-call:1",
  input: {
    agentId: String(agent.id),
    revision: Number(agent.revision),
    to: "+966500000111",
    from: "+966500000222",
    transportConnectionId: "conn_twilio_restaurant_demo",
    script: [
      { caller: "Tomorrow at 7, a table for four under Sam." },
      {
        expect_tool_call: "google-calendar.create_event",
        input: {
          calendarId: "primary",
          title: "Table for four — Sam",
          startTime: "2026-07-18T16:00:00.000Z",
          endTime: "2026-07-18T17:30:00.000Z",
          timeZone: "Asia/Riyadh",
        },
      },
      { caller: "Email sam@example.com with the confirmation." },
      {
        expect_tool_call: "gmail.send_email",
        input: {
          to: ["sam@example.com"],
          subject: "Your table is confirmed",
          body: "Tomorrow at 7 PM for four guests.",
        },
      },
    ],
  },
});
const started = await eyeball.executions.wait(pending.executionId);
if (started.status !== "succeeded") throw new Error("Call failed to start");
const sessionId = String(object(object(started.output).session).id);

let afterSequence = 0;
let state = "created";
while (!["completed", "failed", "abandoned"].includes(state)) {
  const advanced = await fetch(
    `${executorUrl}/v1/dev/voice-sessions/${sessionId}/advance`,
    {
      method: "POST",
      headers: {
        authorization: `Bearer ${process.env.EYEBALL_API_KEY!}`,
        "content-type": "application/json",
      },
      body: JSON.stringify({ userId, milliseconds: 1_000 }),
    },
  );
  if (!advanced.ok) throw new Error(`Voice worker returned ${advanced.status}`);
  const page = object(
    await eyeball.tools.run(
      "voice-agents.get_agent_session",
      { sessionId, afterSequence, eventLimit: 100 },
      { userId },
    ),
  );
  const session = object(page.session);
  state = String(session.state);
  afterSequence = Number(page.nextSequence);
  console.log(page.events);
}

const transcript = object(
  await eyeball.tools.run(
    "voice-agents.get_session_transcript",
    { sessionId },
    { userId },
  ),
);
const artifact = object(transcript.artifact);
const turns = Array.isArray(artifact.turns) ? artifact.turns.map(object) : [];
const toolTurns = turns.filter((turn) => turn.speaker === "tool");
if (
  toolTurns.length !== 2 ||
  toolTurns.some((turn) => typeof turn.executionId !== "string")
) {
  throw new Error("Expected two child execution IDs in the transcript");
}
console.log(toolTurns.map((turn) => turn.executionId));