wizards 0.4.0 → 0.4.2

package/modules/calls/src/plugin.ts

@@ -1,407 +0,0 @@
-import { AsyncResource } from "node:async_hooks";
-import { definePlugin, type PluginRequest } from "@engenty-wizards/plugin-sdk";
-import { z } from "zod";
-import {
-  acceptCall,
-  hangUp,
-  incomingCall,
-  openSocket,
-  rejectCall,
-  sipUri,
-  webhookOk,
-} from "./openai";
-import { ASKS, CALL_TOOLS, instructions, RUNNER, VOICES } from "./rules";
-import { CallSession, type Offered } from "./session";
-import { callByToken, dropAccount, getAccount, newCall, putAccount, updateCall } from "./store";
-import { dialTwiml, e164, emptyTwiml, sendText, signatureOk } from "./twilio";
-
-/**
- * Calls as a door. A WhatsApp call reaches the tenant's business number, Meta sends it as SIP
- * to the tenant's Twilio SIP domain; a phone call reaches the tenant's Twilio number. Either
- * way Twilio asks this plugin for TwiML, which hands the call to the tenant's OpenAI project
- * over SIP with a token in a header. OpenAI posts the incoming call here; the plugin picks it
- * up with the wizard's rules and tools and drives the run over a WebSocket while the person
- * and the model talk. The studio half is ui/plugin.tsx.
- */
-
-const fail = (status: number, code: string, message: string): never => {
-  throw Object.assign(new Error(message), { status, code });
-};
-
-const accountInput = z.object({
-  twilioSid: z.string().trim().min(1).max(60),
-  twilioToken: z.string().trim().max(200).optional(),
-  smsFrom: z.string().trim().max(20).nullable().optional(),
-  openaiProject: z.string().trim().min(1).max(80),
-  openaiWebhookSecret: z.string().trim().max(200).optional(),
-  region: z.enum(["eu", "us"]),
-});
-
-/** A form field by its name, whatever the case Twilio and Meta used. */
-function field(form: URLSearchParams, name: string): string | null {
-  const lower = name.toLowerCase();
-  for (const [key, value] of form) {
-    if (key.toLowerCase() === lower) {
-      return value;
-    }
-  }
-  return null;
-}
-
-export default definePlugin((wizards) => {
-  const { server, log } = wizards;
-  const db = () => server.getTenantDb();
-
-  server.registerMigrations("migrations");
-
-  interface Live {
-    session: CallSession;
-    socket: WebSocket;
-  }
-  const live = new Map<string, Live>();
-  const watching = new Map<string, () => void>();
-  const timers = new Map<string, ReturnType<typeof setTimeout>>();
-
-  const offered = () => server.runs.wizards(RUNNER) as Promise<Offered[]>;
-
-  function watch(runId: string) {
-    if (watching.has(runId)) {
-      return;
-    }
-    const stop = server.runs.subscribe(runId, (signal) => {
-      if (signal.event && signal.event.type !== "step_done" && signal.event.type !== "error") {
-        return;
-      }
-      clearTimeout(timers.get(runId));
-      timers.set(
-        runId,
-        setTimeout(() => {
-          timers.delete(runId);
-          for (const { session } of live.values()) {
-            if (session.runId === runId) {
-              void session.changed().catch((err) => log.error("after a change of the run:", err));
-            }
-          }
-        }, 300),
-      );
-    });
-    watching.set(runId, stop);
-  }
-
-  function unwatch(runId: string) {
-    watching.get(runId)?.();
-    watching.delete(runId);
-    clearTimeout(timers.get(runId));
-    timers.delete(runId);
-  }
-
-  server.onUnload(() => {
-    for (const { socket } of live.values()) {
-      socket.close();
-    }
-    live.clear();
-    for (const stop of watching.values()) {
-      stop();
-    }
-    watching.clear();
-    for (const timer of timers.values()) {
-      clearTimeout(timer);
-    }
-  });
-
-  // ── The door ───────────────────────────────────────────────────────────────
-
-  server.registerRunner({
-    id: RUNNER,
-    label: { de: "Anruf", en: "Call" },
-    kind: "channel",
-    capabilities: {
-      input: ASKS,
-      output: { shows: ["text", "data"], pictures: [] },
-      asks: ["confirm"],
-      review: ["accept", "regenerate"],
-      waits: true,
-      handoff: ["sms"],
-    },
-    problem: async () => {
-      if (!(await getAccount(db()))) {
-        return "Keine Nummer verbunden (Einstellungen → Anrufe)";
-      }
-      try {
-        await server.speech.conversation();
-        return null;
-      } catch (err) {
-        return (err as Error).message;
-      }
-    },
-  });
-
-  // Twilio: a call came in on the SIP domain (WhatsApp) or on the number (phone). The TwiML
-  // hands it to OpenAI's SIP endpoint with a token that names the call to us.
-  server.registerPublicRoute({
-    method: "POST",
-    path: "/voice",
-    handler: async ({ request }) => {
-      const account = await getAccount(db());
-      if (!account) {
-        return emptyTwiml();
-      }
-      const form = new URLSearchParams(await request.text());
-      const urls = [await server.publicUrl("/voice"), request.url];
-      if (
-        !signatureOk(account.twilioToken, urls, form, request.headers.get("x-twilio-signature"))
-      ) {
-        return fail(403, "bad_signature", "The signature does not match.");
-      }
-      const caller = e164(form.get("From") ?? "");
-      if (caller.length < 6) {
-        return fail(400, "no_caller", "No caller.");
-      }
-      const wacid = field(form, "SipHeader_x-wa-meta-wacid");
-      const payload =
-        field(form, "SipHeader_x-wa-meta-cta-payload") ??
-        field(form, "SipHeader_x-wa-meta-deeplink-payload");
-      const row = await newCall(db(), {
-        caller,
-        channel: wacid ? "whatsapp" : "phone",
-        payload,
-        twilioCallSid: form.get("CallSid"),
-      });
-      return new Response(dialTwiml(sipUri(account.openaiProject, account.region), row.token), {
-        headers: { "content-type": "text/xml" },
-      });
-    },
-  });
-
-  // OpenAI: the call reached the project. Picked up with the wizard's rules; from here on the
-  // model speaks and this plugin answers its tool calls over the WebSocket.
-  server.registerPublicRoute({
-    method: "POST",
-    path: "/openai",
-    handler: async ({ request }) => {
-      const account = await getAccount(db());
-      if (!account) {
-        return fail(404, "not_connected", "No account.");
-      }
-      const raw = await request.text();
-      const h = (name: string) => request.headers.get(name);
-      if (
-        !webhookOk(
-          account.openaiWebhookSecret,
-          {
-            id: h("webhook-id"),
-            timestamp: h("webhook-timestamp"),
-            signature: h("webhook-signature"),
-          },
-          raw,
-        )
-      ) {
-        return fail(401, "bad_signature", "The signature does not match.");
-      }
-      let body: unknown;
-      try {
-        body = JSON.parse(raw);
-      } catch {
-        return fail(400, "bad_body", "Not JSON.");
-      }
-      const incoming = incomingCall(body);
-      if (!incoming) {
-        return { ok: true };
-      }
-      const { apiKey, model } = await server.speech.conversation();
-      const token = incoming.headers.get("x-engenty-call");
-      const row = token ? await callByToken(db(), token) : null;
-      if (row?.status !== "ringing") {
-        // Not a call of ours, or one answered already.
-        await rejectCall(apiKey, incoming.callId).catch((err) => log.warn("reject:", err));
-        return { ok: true };
-      }
-      const on = await offered();
-      const byPayload = row.payload
-        ? on.find((w) => w.token === row.payload || w.wizardId === row.payload)
-        : undefined;
-      const first = byPayload ?? (on.length === 1 ? on[0] : null);
-      const lang = first?.lang ?? on[0]?.lang ?? "de";
-      let socket: WebSocket | null = null;
-      const session = new CallSession(
-        {
-          runs: server.runs,
-          send: (event) => {
-            if (socket?.readyState === WebSocket.OPEN) {
-              socket.send(JSON.stringify(event));
-            }
-          },
-          text: async (body) => {
-            if (!account.smsFrom) {
-              throw new Error("No number to text from (Settings → Calls).");
-            }
-            await sendText(
-              { sid: account.twilioSid, token: account.twilioToken },
-              account.smsFrom,
-              row.caller,
-              body,
-            );
-          },
-          hangUp: async () => {
-            await hangUp(apiKey, incoming.callId).catch((err) => log.warn("hangup:", err));
-            // The tool's answer still goes out; the socket closes once it did.
-            setTimeout(() => socket?.close(), 1000);
-          },
-          watch,
-          unwatch,
-          log,
-        },
-        row.caller,
-        row.channel,
-        first ? [] : on,
-        lang,
-      );
-      if (first) {
-        await session.start(first);
-      }
-      await acceptCall(apiKey, incoming.callId, {
-        model,
-        instructions: instructions(
-          lang,
-          first ? { title: first.title } : null,
-          first ? [] : on.map((w) => w.title),
-        ),
-        tools: [...CALL_TOOLS],
-        voice: VOICES[lang],
-      });
-      await updateCall(db(), row.token, {
-        openaiCallId: incoming.callId,
-        runId: session.runId,
-        status: "live",
-      });
-      // The socket's events arrive outside any request: bound to this call's tenant here.
-      const bound = <A extends unknown[]>(fn: (...args: A) => void) => AsyncResource.bind(fn);
-      socket = openSocket(apiKey, incoming.callId);
-      live.set(row.token, { session, socket });
-      socket.addEventListener(
-        "open",
-        bound(() => {
-          void session.hello().catch((err) => log.error("hello:", err));
-        }),
-      );
-      socket.addEventListener(
-        "message",
-        bound((event: MessageEvent) => {
-          void onMessage(session, String(event.data)).catch((err) => log.error("event:", err));
-        }),
-      );
-      socket.addEventListener(
-        "close",
-        bound(() => {
-          session.stop();
-          live.delete(row.token);
-          void updateCall(db(), row.token, { status: "done" }).catch(() => undefined);
-        }),
-      );
-      socket.addEventListener(
-        "error",
-        bound(() => log.warn(`call ${row.token}: the socket to the model failed`)),
-      );
-      return { ok: true };
-    },
-  });
-
-  /** What the model sent: a tool call is run and answered; the rest is noise here. */
-  async function onMessage(session: CallSession, data: string): Promise<void> {
-    let event: {
-      type?: string;
-      name?: string;
-      arguments?: string;
-      call_id?: string;
-      error?: unknown;
-    };
-    try {
-      event = JSON.parse(data);
-    } catch {
-      return;
-    }
-    if (event.type === "response.function_call_arguments.done" && event.name) {
-      let args: Record<string, unknown> = {};
-      try {
-        args = event.arguments ? (JSON.parse(event.arguments) as Record<string, unknown>) : {};
-      } catch {
-        args = {};
-      }
-      const output = await session
-        .call(event.name, args)
-        .catch((err) => `Failed: ${(err as Error).message}`);
-      const found = [...live.values()].find((l) => l.session === session);
-      if (found?.socket.readyState === WebSocket.OPEN) {
-        found.socket.send(
-          JSON.stringify({
-            type: "conversation.item.create",
-            item: { type: "function_call_output", call_id: event.call_id, output },
-          }),
-        );
-        found.socket.send(JSON.stringify({ type: "response.create" }));
-      }
-    } else if (event.type === "error") {
-      log.warn("the model reported:", JSON.stringify(event.error));
-    }
-  }
-
-  // ── The studio's side ──────────────────────────────────────────────────────
-
-  const admin = (request: PluginRequest) => {
-    if (request.user.role === "member") {
-      fail(403, "forbidden", "Owners and admins only.");
-    }
-  };
-
-  async function accountView() {
-    const account = await getAccount(db());
-    return {
-      connected: Boolean(account),
-      twilioSid: account?.twilioSid ?? "",
-      hasToken: Boolean(account?.twilioToken),
-      smsFrom: account?.smsFrom ?? "",
-      openaiProject: account?.openaiProject ?? "",
-      hasSecret: Boolean(account?.openaiWebhookSecret),
-      region: account?.region ?? "eu",
-      voiceWebhook: await server.publicUrl("/voice"),
-      openaiWebhook: await server.publicUrl("/openai"),
-      sipUri: account ? sipUri(account.openaiProject, account.region) : null,
-    };
-  }
-
-  server.registerHttpRoute({
-    method: "GET",
-    path: "/account",
-    role: "admin",
-    handler: accountView,
-  });
-
-  server.registerHttpRoute({
-    method: "PUT",
-    path: "/account",
-    role: "admin",
-    handler: async (request) => {
-      admin(request);
-      const parsed = accountInput.safeParse(await request.json());
-      if (!parsed.success) {
-        return fail(400, "invalid", parsed.error.issues[0]?.message ?? "invalid");
-      }
-      await putAccount(db(), {
-        ...parsed.data,
-        smsFrom: parsed.data.smsFrom ? e164(parsed.data.smsFrom) : null,
-      });
-      return accountView();
-    },
-  });
-
-  server.registerHttpRoute({
-    method: "DELETE",
-    path: "/account",
-    role: "admin",
-    handler: async (request) => {
-      admin(request);
-      await dropAccount(db());
-      return accountView();
-    },
-  });
-});

package/modules/calls/src/rules.ts

@@ -1,226 +0,0 @@
-import type { PluginRunReport } from "@engenty-wizards/plugin-sdk";
-import { clipText, type ThreadLang } from "@engenty-wizards/plugin-sdk/thread";
-
-/**
- * What the model works with on a call: its tools (one per command of the run), its rules in
- * the wizard's language, and the state of the run as text, which it reads after every change.
- */
-
-export const RUNNER = "call";
-
-/** The field kinds a voice can answer; the rest is texted as a link to the run page. */
-export const ASKS = [
-  "text",
-  "textarea",
-  "number",
-  "select",
-  "multiselect",
-  "date",
-  "email",
-  "url",
-  "toggle",
-  "location",
-];
-
-export const VOICES: Record<ThreadLang, string> = { de: "marin", en: "marin" };
-
-const object = (properties: Record<string, unknown>, required: string[] = []) => ({
-  type: "object",
-  properties,
-  required,
-  additionalProperties: false,
-});
-
-export const CALL_TOOLS = [
-  {
-    type: "function",
-    name: "get_state",
-    description:
-      "What the run waits for right now: the page with its fields (which are answered, which are still open, which need the screen), the review, or what the wizard is working on. Call it when unsure, and after the state changed.",
-    parameters: object({}),
-  },
-  {
-    type: "function",
-    name: "set_field",
-    description:
-      "Keeps the person's answer to one field of the current page. Call it once per field as soon as the person answered; for a choice give one of the options exactly.",
-    parameters: object(
-      {
-        field: { type: "string", description: "The field's id from the state." },
-        value: {
-          description:
-            "The answer: a string, a number, true/false for a toggle, or an array of options for a multiple choice.",
-        },
-      },
-      ["field", "value"],
-    ),
-  },
-  {
-    type: "function",
-    name: "submit_page",
-    description:
-      "Sends the current page once every required field that can be answered by voice has a value.",
-    parameters: object({}),
-  },
-  {
-    type: "function",
-    name: "accept_review",
-    description: "Accepts what the wizard made, when the person is happy with it.",
-    parameters: object({}),
-  },
-  {
-    type: "function",
-    name: "regenerate",
-    description: "Asks the wizard to make one of the shown outputs again, with what should change.",
-    parameters: object(
-      {
-        target: { type: "string", description: "The step id of the output, from the state." },
-        note: { type: "string", description: "What should change, in the person's words." },
-      },
-      ["target", "note"],
-    ),
-  },
-  {
-    type: "function",
-    name: "answer_ask",
-    description:
-      "Answers the question a running step asks before it changes something in a connected account: allow it, or skip it.",
-    parameters: object({ allow: { type: "boolean" } }, ["allow"]),
-  },
-  {
-    type: "function",
-    name: "send_link",
-    description:
-      "Texts the person a link to the run on their phone: for a page that needs the screen (a photo, a file, a signature), and for the result at the end. Say that a text is on its way.",
-    parameters: object({}),
-  },
-  {
-    type: "function",
-    name: "go_back",
-    description: "Goes back to the page before, when the person wants to change an earlier answer.",
-    parameters: object({}),
-  },
-  {
-    type: "function",
-    name: "choose_wizard",
-    description:
-      "Starts one of the wizards offered on this number, by its name, once the person said which.",
-    parameters: object({ name: { type: "string" } }, ["name"]),
-  },
-  {
-    type: "function",
-    name: "hang_up",
-    description: "Ends the call, after saying goodbye.",
-    parameters: object({}),
-  },
-] as const;
-
-export interface About {
-  title: string;
-  description?: string;
-}
-
-/** The rules the model speaks by. `lobby`: the wizards to choose from, when more than one is on. */
-export function instructions(lang: ThreadLang, about: About | null, lobby: string[]): string {
-  const de = lang === "de";
-  const who = about
-    ? [`${de ? "Du bist" : "You are"} ${about.title}.`, about.description].filter(Boolean).join(" ")
-    : de
-      ? "Du bist der Assistent dieser Nummer."
-      : "You are the assistant on this number.";
-  const choose = lobby.length
-    ? de
-      ? `Auf dieser Nummer gibt es mehrere Wizards: ${lobby.join(", ")}. Frag zuerst, welcher es sein soll, und rufe dann choose_wizard auf.`
-      : `This number offers several wizards: ${lobby.join(", ")}. Ask first which one it should be, then call choose_wizard.`
-    : "";
-  const none =
-    !about && !lobby.length
-      ? de
-        ? "Hier ist noch kein Wizard eingerichtet: sag das in einem Satz und beende das Gespräch mit hang_up."
-        : "No wizard is set up here yet: say so in one sentence and end the call with hang_up."
-      : "";
-  const rules = de
-    ? [
-        "Du führst ein Telefongespräch, das einen Wizard Schritt für Schritt ausfüllt. Die Person hat keinen Bildschirm vor sich: nur deine Stimme.",
-        "Sprich Deutsch, kurz und freundlich. Ein Satz, dann die nächste Frage. Begrüße die Person mit einem Satz und sag, worum es geht.",
-        "Frag ein Feld nach dem anderen, in der Reihenfolge des Zustands. Nach jeder Antwort rufst du set_field auf. Sind alle Felder beantwortet, die du per Sprache füllen kannst, rufst du submit_page auf.",
-        "Bei einer Auswahl nennst du die Möglichkeiten (höchstens vier auf einmal) und gibst genau eine davon weiter.",
-        "E-Mail-Adressen, Links und Zahlen wiederholst du zur Bestätigung, bevor du sie weitergibst.",
-        "Ein Feld, das den Bildschirm braucht (ein Foto, eine Datei, eine Unterschrift), kann die Person nur über einen Link ausfüllen: sag das, rufe send_link auf, und warte, bis der Zustand sich ändert.",
-        "Während der Wizard arbeitet, sagst du in einem Satz, was er gerade tut, und wartest. Erfinde nichts.",
-        "Bei einer Prüfung liest du den Text kurz zusammengefasst vor und fragst, ob er passt. Dann accept_review, oder regenerate mit dem Wunsch der Person.",
-        "Am Ende sagst du, was entstanden ist, rufst send_link auf, damit die Person alles als Link bekommt, verabschiedest dich und rufst hang_up auf.",
-      ]
-    : [
-        "You hold a phone conversation that fills in a wizard step by step. The person has no screen: only your voice.",
-        "Speak English, short and friendly. One sentence, then the next question. Greet the person in one sentence and say what this is about.",
-        "Ask one field at a time, in the order of the state. After each answer call set_field. When every field you can fill by voice is answered, call submit_page.",
-        "For a choice, name the options (at most four at a time) and pass exactly one of them on.",
-        "Read e-mail addresses, links and numbers back before passing them on.",
-        "A field that needs the screen (a photo, a file, a signature) can only be filled through a link: say so, call send_link, and wait until the state changes.",
-        "While the wizard works, say in one sentence what it is doing and wait. Never make anything up.",
-        "At a review, sum the text up in a few words and ask whether it fits. Then accept_review, or regenerate with what the person wants changed.",
-        "At the end, say what was made, call send_link so the person has it all as a link, say goodbye and call hang_up.",
-      ];
-  return [who, choose, none, "", ...rules].filter((line) => line !== undefined).join("\n");
-}
-
-/** The run as text for the model: the page with every field and what it knows, or what else it waits for. */
-export function stateText(
-  report: PluginRunReport | null,
-  draft: Record<string, unknown>,
-  lobby: string[],
-  asks: Set<string>,
-): string {
-  if (!report) {
-    return lobby.length
-      ? `[state]\nNo wizard chosen yet. Offered: ${lobby.join(", ")}. Ask which, then choose_wizard.`
-      : "[state]\nNo wizard is set up on this number.";
-  }
-  const lines = [`[state]`, `Status: ${report.status}.`];
-  const w = report.waitingFor;
-  if (report.status === "done") {
-    lines.push("The wizard is done. Say what was made, send_link, say goodbye, hang_up.");
-  } else if (report.status === "failed") {
-    lines.push(`The wizard stopped: ${report.error ?? "an error"}. Say so, send_link, hang_up.`);
-  } else if (!w) {
-    lines.push(
-      `The wizard is working on "${report.step?.title ?? "…"}". Say so in a sentence and wait; the state comes again when it is done.`,
-    );
-  } else if ("page" in w) {
-    lines.push(`Page "${w.title}" (id ${w.page}). Fields, in order:`);
-    for (const f of w.fields) {
-      if (f.shown === false) {
-        continue;
-      }
-      const value = f.id in draft ? draft[f.id] : f.value;
-      const has = value !== undefined && value !== null && value !== "";
-      const kind = f.options?.length ? `${f.kind}: ${f.options.join(" | ")}` : f.kind;
-      const how = asks.has(f.kind) ? "" : " — needs the screen: send_link";
-      lines.push(
-        `- ${f.id} "${f.label}" (${kind}${f.required ? ", required" : ""}${how}): ${has ? `answered: ${JSON.stringify(value)}` : "open"}${f.help ? ` — ${f.help}` : ""}`,
-      );
-    }
-  } else if ("review" in w) {
-    lines.push(`Review "${w.title}" (id ${w.review}) of: ${w.show.join(", ")}.`);
-    for (const output of report.outputs.filter((o) => w.show.includes(o.stepId))) {
-      lines.push(
-        `Output ${output.stepId} "${output.title}": ${output.text ? clipText(output.text, 1200) : output.json ? clipText(output.json, 600) : "(not text: a file)"}`,
-      );
-    }
-    lines.push("Ask whether it fits: accept_review, or regenerate with target and note.");
-  } else if (w.kind === "confirm") {
-    lines.push(
-      `Question (id ${w.ask}): ${w.reason} — ${w.action}. answer_ask with allow true or false.`,
-    );
-  } else {
-    lines.push("A sign-in is needed on the screen: send_link and wait.");
-  }
-  const made = report.outputs.filter((o) => o.text && (!w || !("review" in w)));
-  if (made.length && report.status === "done") {
-    for (const output of made.slice(-2)) {
-      lines.push(`Made "${output.title}": ${clipText(output.text ?? "", 600)}`);
-    }
-  }
-  return lines.join("\n");
-}

package/modules/calls/src/schema.ts

@@ -1,39 +0,0 @@
-import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
-
-/** The tables of migrations/, for Drizzle. Kept in step with the SQL by hand. */
-
-export const account = sqliteTable("calls_account", {
-  id: integer("id").primaryKey(),
-  twilioSid: text("twilio_sid").notNull(),
-  twilioToken: text("twilio_token").notNull(),
-  /** The OpenAI project the calls are handed to over SIP: proj_… */
-  openaiProject: text("openai_project").notNull(),
-  /** Signs what OpenAI posts about incoming calls: whsec_… */
-  openaiWebhookSecret: text("openai_webhook_secret").notNull(),
-  /** Where OpenAI takes the call: `eu` or `us`. */
-  region: text("region", { enum: ["eu", "us"] })
-    .notNull()
-    .default("eu"),
-  /** The Twilio number the links are texted from; none: no texts. */
-  smsFrom: text("sms_from"),
-  updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull(),
-});
-
-export const call = sqliteTable("calls_call", {
-  /** Travels with the call as a SIP header; names it to OpenAI's webhook. */
-  token: text("token").primaryKey(),
-  /** The caller's number, E.164. */
-  caller: text("caller").notNull(),
-  /** `whatsapp`: a WhatsApp call over Meta's SIP; `phone`: a call to the Twilio number. */
-  channel: text("channel", { enum: ["whatsapp", "phone"] }).notNull(),
-  /** What a WhatsApp call button or deep link carried: a wizard's share token. */
-  payload: text("payload"),
-  twilioCallSid: text("twilio_call_sid"),
-  openaiCallId: text("openai_call_id"),
-  runId: text("run_id"),
-  status: text("status", { enum: ["ringing", "live", "done"] })
-    .notNull()
-    .default("ringing"),
-  createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull(),
-  updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull(),
-});