@absolutejs/voice 0.0.22-beta.1 → 0.0.22-beta.11

package/dist/index.js

@@ -5150,6 +5150,17 @@ var createVoiceAgent = (options) => {
       if (output.assistantText?.trim()) {
         messages.push({
           content: output.assistantText,
+          metadata: output.toolCalls?.length ? {
+            toolCalls: output.toolCalls
+          } : undefined,
+          role: "assistant"
+        });
+      } else if (output.toolCalls?.length) {
+        messages.push({
+          content: "",
+          metadata: {
+            toolCalls: output.toolCalls
+          },
           role: "assistant"
         });
       }
@@ -5364,8 +5375,730 @@ var createVoiceAgentSquad = (options) => {
   };
   return {
     id: options.id,
-    onTurn: async (input) => run(input),
-    run
+    onTurn: async (input) => run(input),
+    run
+  };
+};
+
+// src/outcomeRecipes.ts
+var RECIPE_DEFAULTS = {
+  "appointment-booking": {
+    completedAction: "Verify appointment details, confirm calendar state, and send any required confirmation.",
+    completedDescription: "The call completed an appointment-booking flow and should be checked against the scheduling system.",
+    completedKind: "appointment-booking",
+    completedTitle: "Confirm booked appointment",
+    defaultCompletedCreatesTask: true,
+    defaultDueInMs: 30 * 60000,
+    defaultPriority: "normal",
+    defaultQueue: "appointments",
+    description: "Creates appointment confirmation work for completed calls and callback/retry work for missed booking attempts.",
+    escalationQueue: "appointments-escalations"
+  },
+  "lead-qualification": {
+    completedAction: "Review qualification signals, update CRM fields, and route the lead to the right owner.",
+    completedDescription: "The call completed a lead-qualification flow and should be reviewed for sales follow-up.",
+    completedKind: "lead-qualification",
+    completedTitle: "Review qualified lead",
+    defaultCompletedCreatesTask: true,
+    defaultDueInMs: 15 * 60000,
+    defaultPriority: "high",
+    defaultQueue: "sales-leads",
+    description: "Creates sales follow-up work for completed qualification calls and fast callbacks for missed leads.",
+    escalationQueue: "sales-escalations"
+  },
+  "support-triage": {
+    completedAction: "Review the triage result, confirm the support category, and route any unresolved issue.",
+    completedDescription: "The call completed support triage and may need queue routing or human follow-up.",
+    completedKind: "support-triage",
+    completedTitle: "Review support triage",
+    defaultCompletedCreatesTask: true,
+    defaultDueInMs: 20 * 60000,
+    defaultPriority: "normal",
+    defaultQueue: "support-triage",
+    description: "Creates support triage work for completed calls and urgent escalation/callback work for unresolved callers.",
+    escalationQueue: "support-escalations"
+  },
+  "voicemail-callback": {
+    completedAction: "No callback is required for completed calls.",
+    completedDescription: "The call completed without requiring voicemail follow-up.",
+    completedKind: "callback",
+    completedTitle: "Completed call",
+    defaultCompletedCreatesTask: false,
+    defaultDueInMs: 15 * 60000,
+    defaultPriority: "high",
+    defaultQueue: "callbacks",
+    description: "Creates callback work for voicemail, no-answer, failed, or escalated calls while ignoring completed calls.",
+    escalationQueue: "callback-escalations"
+  },
+  "warm-transfer": {
+    completedAction: "Confirm the handoff target received the caller context and close the transfer loop.",
+    completedDescription: "The call is part of a warm-transfer flow and should be verified downstream.",
+    completedKind: "transfer-check",
+    completedTitle: "Verify warm transfer",
+    defaultCompletedCreatesTask: false,
+    defaultDueInMs: 10 * 60000,
+    defaultPriority: "normal",
+    defaultQueue: "transfer-verification",
+    description: "Creates transfer verification work for transferred calls and escalation work when the handoff fails.",
+    escalationQueue: "transfer-escalations"
+  }
+};
+var buildRecipeTask = (input) => {
+  const createdAt = input.review.generatedAt ?? Date.now();
+  const queue = input.options.queue ?? input.defaults.defaultQueue;
+  const target = input.options.target ?? input.review.postCall?.target;
+  const common = {
+    assignee: input.options.assignee,
+    createdAt,
+    history: [
+      {
+        actor: "system",
+        at: createdAt,
+        detail: input.review.postCall?.summary,
+        type: "created"
+      }
+    ],
+    id: `${input.review.id}:${input.defaults.completedKind}`,
+    intakeId: input.review.id,
+    outcome: input.review.summary.outcome,
+    priority: input.options.priority ?? input.defaults.defaultPriority,
+    queue,
+    reviewId: input.review.id,
+    status: "open",
+    target,
+    updatedAt: createdAt
+  };
+  switch (input.disposition) {
+    case "completed":
+      if (!(input.options.completedCreatesTask ?? input.defaults.defaultCompletedCreatesTask)) {
+        return null;
+      }
+      return {
+        ...common,
+        description: input.defaults.completedDescription,
+        kind: input.defaults.completedKind,
+        recommendedAction: input.defaults.completedAction,
+        title: target ? `${input.defaults.completedTitle}: ${target}` : input.defaults.completedTitle
+      };
+    case "voicemail":
+      return {
+        ...common,
+        description: input.review.postCall?.summary ?? "The caller reached voicemail and needs a callback.",
+        id: `${input.review.id}:callback`,
+        kind: "callback",
+        recommendedAction: input.review.postCall?.recommendedAction ?? "Call the customer back and continue the original flow.",
+        title: target ? `Call back ${target}` : "Call back voicemail lead"
+      };
+    case "no-answer":
+      return {
+        ...common,
+        description: input.review.postCall?.summary ?? "The call did not reach a live respondent and should be retried.",
+        id: `${input.review.id}:retry`,
+        kind: "callback",
+        recommendedAction: input.review.postCall?.recommendedAction ?? "Retry the call or schedule a callback.",
+        title: "Retry no-answer call"
+      };
+    case "transferred":
+      return {
+        ...common,
+        description: input.review.postCall?.summary ?? "The call was transferred and should be verified downstream.",
+        id: `${input.review.id}:transfer-check`,
+        kind: "transfer-check",
+        recommendedAction: input.review.postCall?.recommendedAction ?? "Confirm the receiving team got the caller context.",
+        title: target ? `Verify transfer to ${target}` : "Verify call transfer"
+      };
+    case "escalated":
+      return {
+        ...common,
+        description: input.review.postCall?.summary ?? "The call escalated and needs human review.",
+        id: `${input.review.id}:escalation`,
+        kind: "escalation",
+        priority: "urgent",
+        queue: input.options.escalationQueue ?? input.defaults.escalationQueue,
+        assignee: input.options.escalationAssignee ?? input.options.assignee,
+        recommendedAction: input.review.postCall?.recommendedAction ?? "Review the escalated call and respond immediately.",
+        title: "Review escalated call"
+      };
+    case "failed":
+    case "closed":
+      return {
+        ...common,
+        description: input.review.postCall?.summary ?? "The call ended before successful completion and needs review.",
+        id: `${input.review.id}:retry-review`,
+        kind: "retry-review",
+        priority: "high",
+        recommendedAction: input.review.postCall?.recommendedAction ?? "Inspect the call and decide whether to retry, escalate, or close.",
+        title: "Inspect incomplete call"
+      };
+    default:
+      return null;
+  }
+};
+var resolveVoiceOutcomeRecipe = (name, options = {}) => {
+  const defaults = RECIPE_DEFAULTS[name];
+  const taskPolicies = {
+    completed: {
+      assignee: options.assignee,
+      dueInMs: options.dueInMs ?? defaults.defaultDueInMs,
+      name: `${name}-completed`,
+      priority: options.priority ?? defaults.defaultPriority,
+      queue: options.queue ?? defaults.defaultQueue
+    },
+    escalated: {
+      assignee: options.escalationAssignee ?? options.assignee,
+      dueInMs: Math.min(options.dueInMs ?? defaults.defaultDueInMs, 10 * 60000),
+      name: `${name}-escalation`,
+      priority: "urgent",
+      queue: options.escalationQueue ?? defaults.escalationQueue
+    },
+    failed: {
+      assignee: options.assignee,
+      dueInMs: options.dueInMs ?? defaults.defaultDueInMs,
+      name: `${name}-failed-review`,
+      priority: "high",
+      queue: options.queue ?? defaults.defaultQueue
+    },
+    "no-answer": {
+      assignee: options.assignee,
+      dueInMs: options.dueInMs ?? defaults.defaultDueInMs,
+      name: `${name}-no-answer`,
+      priority: options.priority ?? defaults.defaultPriority,
+      queue: options.queue ?? defaults.defaultQueue
+    },
+    transferred: {
+      assignee: options.assignee,
+      dueInMs: Math.min(options.dueInMs ?? defaults.defaultDueInMs, 20 * 60000),
+      name: `${name}-transfer-check`,
+      priority: options.priority ?? defaults.defaultPriority,
+      queue: name === "warm-transfer" ? options.queue ?? defaults.defaultQueue : "transfer-verification"
+    },
+    voicemail: {
+      assignee: options.assignee,
+      dueInMs: options.dueInMs ?? defaults.defaultDueInMs,
+      name: `${name}-voicemail`,
+      priority: options.priority ?? defaults.defaultPriority,
+      queue: options.queue ?? defaults.defaultQueue
+    }
+  };
+  const taskAssignmentRules = [
+    {
+      assign: options.escalationAssignee ?? options.assignee,
+      description: `Route urgent ${name} work to the escalation lane.`,
+      name: `${name}-urgent-routing`,
+      queue: options.escalationQueue ?? defaults.escalationQueue,
+      when: {
+        priority: "urgent"
+      }
+    }
+  ].filter((rule) => rule.assign || rule.queue);
+  return {
+    createTaskFromReview: ({ disposition, review }) => buildRecipeTask({
+      defaults,
+      disposition,
+      options,
+      review
+    }),
+    description: defaults.description,
+    name,
+    taskAssignmentRules,
+    taskPolicies
+  };
+};
+
+// src/assistantMemory.ts
+var createMemoryId = (input) => `${input.assistantId}:${input.namespace}:${input.key}`;
+var createVoiceAssistantMemoryRecord = (input) => {
+  const now = Date.now();
+  return {
+    ...input,
+    createdAt: input.createdAt ?? input.updatedAt ?? now,
+    updatedAt: input.updatedAt ?? now
+  };
+};
+var createVoiceMemoryAssistantMemoryStore = () => {
+  const records = new Map;
+  return {
+    delete: async (input) => {
+      records.delete(createMemoryId(input));
+    },
+    get: async (input) => records.get(createMemoryId(input)),
+    list: async (input) => [...records.values()].filter((record) => record.assistantId === input.assistantId && (input.namespace === undefined || record.namespace === input.namespace)).sort((left, right) => right.updatedAt - left.updatedAt),
+    set: async (input) => {
+      const id = createMemoryId(input);
+      const existing = records.get(id);
+      const record = createVoiceAssistantMemoryRecord({
+        ...input,
+        createdAt: input.createdAt ?? existing?.createdAt,
+        updatedAt: input.updatedAt
+      });
+      records.set(id, record);
+      return record;
+    }
+  };
+};
+var resolveVoiceAssistantMemoryNamespace = async (input) => typeof input.memory.namespace === "function" ? await input.memory.namespace(input) : input.memory.namespace;
+var createVoiceAssistantMemoryHandle = async (input) => {
+  const namespace = await resolveVoiceAssistantMemoryNamespace({
+    assistantId: input.assistantId,
+    context: input.context,
+    memory: input.memory,
+    session: input.session
+  });
+  const trace = async (event) => {
+    await input.trace?.append({
+      at: Date.now(),
+      payload: {
+        assistantId: input.assistantId,
+        namespace,
+        ...event
+      },
+      scenarioId: input.session.scenarioId,
+      sessionId: input.session.id,
+      type: "assistant.memory"
+    });
+  };
+  return {
+    delete: async (key) => {
+      await input.memory.store.delete({
+        assistantId: input.assistantId,
+        key,
+        namespace
+      });
+      await trace({
+        action: "delete",
+        key
+      });
+    },
+    get: async (key) => {
+      const record = await input.memory.store.get({
+        assistantId: input.assistantId,
+        key,
+        namespace
+      });
+      await trace({
+        action: "get",
+        found: Boolean(record),
+        key
+      });
+      return record?.value;
+    },
+    list: async () => {
+      const records = await input.memory.store.list({
+        assistantId: input.assistantId,
+        namespace
+      });
+      await trace({
+        action: "list",
+        count: records.length
+      });
+      return records;
+    },
+    namespace,
+    set: async (key, value, metadata) => {
+      const record = await input.memory.store.set({
+        assistantId: input.assistantId,
+        key,
+        metadata,
+        namespace,
+        value
+      });
+      await trace({
+        action: "set",
+        key
+      });
+      return record;
+    }
+  };
+};
+
+// src/assistant.ts
+var hashString = (value) => {
+  let hash = 2166136261;
+  for (let index = 0;index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+};
+var increment = (record, key) => {
+  record[key] = (record[key] ?? 0) + 1;
+};
+var resolveOutcome = (result) => {
+  if (result.transfer) {
+    return "transferred";
+  }
+  if (result.escalate) {
+    return "escalated";
+  }
+  if (result.voicemail) {
+    return "voicemail";
+  }
+  if (result.noAnswer) {
+    return "no-answer";
+  }
+  if (result.complete) {
+    return "completed";
+  }
+  return "continued";
+};
+var resolveArtifactPlanName = (artifactPlan) => {
+  const preset = artifactPlan?.preset;
+  if (!preset) {
+    return artifactPlan?.ops ? "custom" : undefined;
+  }
+  return typeof preset === "string" ? preset : preset.name;
+};
+var appendAssistantTrace = async (input) => {
+  await input.trace?.append({
+    at: Date.now(),
+    payload: {
+      assistantId: input.assistantId,
+      ...input.event
+    },
+    scenarioId: input.session.scenarioId,
+    sessionId: input.session.id,
+    turnId: input.turnId,
+    type: input.type
+  });
+};
+var resolvePresetOps = (artifactPlan) => {
+  const preset = artifactPlan?.preset;
+  if (!preset) {
+    return artifactPlan?.ops;
+  }
+  const recipe = typeof preset === "string" ? resolveVoiceOutcomeRecipe(preset) : resolveVoiceOutcomeRecipe(preset.name, preset.options);
+  return {
+    ...recipe,
+    ...artifactPlan?.ops
+  };
+};
+var mergeOps = (base, override) => {
+  if (!base && !override) {
+    return;
+  }
+  return {
+    ...base,
+    ...override,
+    taskAssignmentRules: base?.taskAssignmentRules || override?.taskAssignmentRules ? [
+      ...base?.taskAssignmentRules ?? [],
+      ...override?.taskAssignmentRules ?? []
+    ] : undefined,
+    taskPolicies: base?.taskPolicies || override?.taskPolicies ? {
+      ...base?.taskPolicies ?? {},
+      ...override?.taskPolicies ?? {}
+    } : undefined
+  };
+};
+var createVoiceExperiment = (options) => {
+  if (!options.variants.length) {
+    throw new Error("createVoiceExperiment requires at least one variant.");
+  }
+  const firstVariant = options.variants[0];
+  return {
+    id: options.id,
+    resolve: (input) => {
+      const selected = options.selectVariant?.({
+        ...input,
+        variants: options.variants
+      });
+      if (selected && typeof selected !== "object") {
+        const variant = options.variants.find((item) => item.id === selected);
+        if (variant) {
+          return variant;
+        }
+      }
+      if (selected && typeof selected === "object" && "id" in selected) {
+        return selected;
+      }
+      const totalWeight = options.variants.reduce((total, variant) => total + Math.max(0, variant.weight ?? 1), 0);
+      if (totalWeight <= 0) {
+        return firstVariant;
+      }
+      const bucket = hashString(`${options.id}:${input.assistantId}:${input.session.id}`) % totalWeight;
+      let cursor = 0;
+      for (const variant of options.variants) {
+        cursor += Math.max(0, variant.weight ?? 1);
+        if (bucket < cursor) {
+          return variant;
+        }
+      }
+      return firstVariant;
+    },
+    variants: options.variants
+  };
+};
+var createVoiceAssistant = (options) => {
+  const ops = mergeOps(resolvePresetOps(options.artifactPlan), options.ops);
+  const artifactPlanName = resolveArtifactPlanName(options.artifactPlan);
+  let agent;
+  const baseModelOptions = "model" in options && options.model ? {
+    maxToolRounds: options.maxToolRounds,
+    model: options.model,
+    system: options.system,
+    tools: options.tools
+  } : undefined;
+  if ("agent" in options && options.agent) {
+    agent = options.agent;
+  } else if ("agents" in options && options.agents) {
+    agent = createVoiceAgentSquad({
+      agents: options.agents,
+      defaultAgentId: options.defaultAgentId,
+      id: options.id,
+      maxHandoffsPerTurn: options.maxHandoffsPerTurn,
+      selectAgent: options.selectAgent,
+      trace: options.trace
+    });
+  } else {
+    agent = createVoiceAgent({
+      id: options.id,
+      maxToolRounds: options.maxToolRounds,
+      model: options.model,
+      system: options.system,
+      trace: options.trace,
+      tools: options.tools
+    });
+  }
+  const onTurn = async (input) => {
+    const memory = options.memory ? await createVoiceAssistantMemoryHandle({
+      assistantId: options.id,
+      context: input.context,
+      memory: options.memory,
+      session: input.session,
+      trace: options.trace
+    }) : undefined;
+    const guardrailInput = {
+      ...input,
+      assistantId: options.id,
+      memory
+    };
+    if (memory) {
+      await options.memoryLifecycle?.beforeTurn?.({
+        ...input,
+        assistantId: options.id,
+        memory
+      });
+    }
+    const blocked = await options.guardrails?.beforeTurn?.(guardrailInput);
+    if (blocked) {
+      if (memory) {
+        await options.memoryLifecycle?.afterTurn?.({
+          ...input,
+          assistantId: options.id,
+          memory,
+          result: blocked
+        });
+      }
+      await appendAssistantTrace({
+        assistantId: options.id,
+        event: {
+          action: "blocked",
+          artifactPlan: artifactPlanName,
+          outcome: resolveOutcome(blocked)
+        },
+        session: input.session,
+        trace: options.trace,
+        turnId: input.turn.id,
+        type: "assistant.guardrail"
+      });
+      await appendAssistantTrace({
+        assistantId: options.id,
+        event: {
+          artifactPlan: artifactPlanName,
+          blocked: true,
+          experimentId: options.experiment?.id,
+          outcome: resolveOutcome(blocked)
+        },
+        session: input.session,
+        trace: options.trace,
+        turnId: input.turn.id,
+        type: "assistant.run"
+      });
+      return blocked;
+    }
+    const startedAt = Date.now();
+    const variant = options.experiment?.resolve({
+      assistantId: options.id,
+      context: input.context,
+      session: input.session,
+      turnId: input.turn.id
+    });
+    const runner = variant && baseModelOptions ? createVoiceAgent({
+      id: `${options.id}:${variant.id}`,
+      maxToolRounds: variant.maxToolRounds ?? baseModelOptions.maxToolRounds,
+      model: variant.model ?? baseModelOptions.model,
+      system: variant.system ?? baseModelOptions.system,
+      trace: options.trace,
+      tools: variant.tools ?? baseModelOptions.tools
+    }) : agent;
+    const runResult = await runner.run(input) ?? {};
+    const result = runResult;
+    const guarded = await options.guardrails?.afterTurn?.({
+      ...guardrailInput,
+      result
+    });
+    const finalResult = guarded ?? result;
+    if (memory) {
+      await options.memoryLifecycle?.afterTurn?.({
+        ...input,
+        assistantId: options.id,
+        memory,
+        result: finalResult
+      });
+    }
+    if (guarded) {
+      await appendAssistantTrace({
+        assistantId: options.id,
+        event: {
+          action: "rewritten",
+          artifactPlan: artifactPlanName,
+          experimentId: options.experiment?.id,
+          outcome: resolveOutcome(finalResult),
+          variantId: variant?.id
+        },
+        session: input.session,
+        trace: options.trace,
+        turnId: input.turn.id,
+        type: "assistant.guardrail"
+      });
+    }
+    await appendAssistantTrace({
+      assistantId: options.id,
+      event: {
+        artifactPlan: artifactPlanName,
+        blocked: false,
+        elapsedMs: Date.now() - startedAt,
+        escalated: Boolean(finalResult.escalate),
+        experimentId: options.experiment?.id,
+        outcome: resolveOutcome(finalResult),
+        toolNames: result.toolResults?.map((tool) => tool.toolName) ?? [],
+        transferred: Boolean(finalResult.transfer),
+        variantId: variant?.id
+      },
+      session: input.session,
+      trace: options.trace,
+      turnId: input.turn.id,
+      type: "assistant.run"
+    });
+    return finalResult;
+  };
+  return {
+    agent,
+    id: options.id,
+    onTurn,
+    ops,
+    route: (overrides) => ({
+      ...overrides,
+      onComplete: overrides.onComplete ?? (() => {
+        return;
+      }),
+      onTurn
+    })
+  };
+};
+var summarizeVoiceAssistantRuns = async (input) => {
+  const events = Array.isArray(input) ? input : input.events ?? await input.store?.list() ?? [];
+  const assistantRuns = events.filter((event) => event.type === "assistant.run");
+  const guardrails = events.filter((event) => event.type === "assistant.guardrail");
+  const byAssistant = new Map;
+  const getSummary = (assistantId) => {
+    let summary = byAssistant.get(assistantId);
+    if (!summary) {
+      summary = {
+        assistantId,
+        artifactPlans: {},
+        blockedGuardrailCount: 0,
+        elapsedCount: 0,
+        elapsedTotal: 0,
+        escalationCount: 0,
+        experiments: {},
+        guardrailCount: 0,
+        memory: {
+          deletes: 0,
+          gets: 0,
+          lists: 0,
+          sets: 0
+        },
+        outcomes: {},
+        runCount: 0,
+        sessionIds: new Set,
+        sessions: 0,
+        toolCalls: {},
+        transferCount: 0,
+        variants: {}
+      };
+      byAssistant.set(assistantId, summary);
+    }
+    return summary;
+  };
+  for (const event of assistantRuns) {
+    const assistantId = typeof event.payload.assistantId === "string" ? event.payload.assistantId : "unknown";
+    const summary = getSummary(assistantId);
+    summary.runCount += 1;
+    summary.sessionIds.add(event.sessionId);
+    if (typeof event.payload.artifactPlan === "string") {
+      increment(summary.artifactPlans, event.payload.artifactPlan);
+    }
+    if (typeof event.payload.experimentId === "string") {
+      increment(summary.experiments, event.payload.experimentId);
+    }
+    if (typeof event.payload.variantId === "string") {
+      increment(summary.variants, event.payload.variantId);
+    }
+    if (typeof event.payload.outcome === "string") {
+      increment(summary.outcomes, event.payload.outcome);
+    }
+    if (event.payload.escalated === true) {
+      summary.escalationCount += 1;
+    }
+    if (event.payload.transferred === true) {
+      summary.transferCount += 1;
+    }
+    if (event.payload.blocked === true) {
+      summary.blockedGuardrailCount += 1;
+    }
+    if (typeof event.payload.elapsedMs === "number") {
+      summary.elapsedCount += 1;
+      summary.elapsedTotal += event.payload.elapsedMs;
+    }
+    if (Array.isArray(event.payload.toolNames)) {
+      for (const toolName of event.payload.toolNames) {
+        if (typeof toolName === "string") {
+          increment(summary.toolCalls, toolName);
+        }
+      }
+    }
+  }
+  for (const event of guardrails) {
+    const assistantId = typeof event.payload.assistantId === "string" ? event.payload.assistantId : "unknown";
+    const summary = getSummary(assistantId);
+    summary.guardrailCount += 1;
+  }
+  for (const event of events.filter((event2) => event2.type === "assistant.memory")) {
+    const assistantId = typeof event.payload.assistantId === "string" ? event.payload.assistantId : "unknown";
+    const summary = getSummary(assistantId);
+    switch (event.payload.action) {
+      case "delete":
+        summary.memory.deletes += 1;
+        break;
+      case "get":
+        summary.memory.gets += 1;
+        break;
+      case "list":
+        summary.memory.lists += 1;
+        break;
+      case "set":
+        summary.memory.sets += 1;
+        break;
+    }
+  }
+  const assistants = [...byAssistant.values()].map(({ elapsedCount, elapsedTotal, sessionIds, ...summary }) => ({
+    ...summary,
+    averageElapsedMs: elapsedCount > 0 ? Math.round(elapsedTotal / elapsedCount) : undefined,
+    sessions: sessionIds.size
+  }));
+  return {
+    assistants: assistants.sort((left, right) => left.assistantId.localeCompare(right.assistantId)),
+    totalRuns: assistantRuns.length
   };
 };
 // src/fileStore.ts
@@ -6052,6 +6785,7 @@ var listJsonFiles = async (directory) => {
 };
 var encodeStoreId = (id) => `${encodeURIComponent(id)}.json`;
 var resolveFilePath = (directory, id) => join(directory, encodeStoreId(id));
+var createMemoryStoreId = (input) => `${input.assistantId}:${input.namespace}:${input.key}`;
 var readJsonFile = async (path) => JSON.parse(await readFile(path, "utf8"));
 var writeJsonFile = async (path, value, options) => {
   await mkdir(options.directory, {
@@ -6271,6 +7005,40 @@ var createVoiceFileTraceSinkDeliveryStore = (options) => {
   };
   return { get, list, remove, set };
 };
+var createVoiceFileAssistantMemoryStore = (options) => {
+  const get = async (input) => {
+    const path = resolveFilePath(options.directory, createMemoryStoreId(input));
+    try {
+      return await readJsonFile(path);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return;
+      }
+      throw error;
+    }
+  };
+  const list = async (input) => {
+    const files = await listJsonFiles(options.directory);
+    const records = await Promise.all(files.map((file) => readJsonFile(file)));
+    return records.filter((record) => record.assistantId === input.assistantId && (input.namespace === undefined || record.namespace === input.namespace)).sort((left, right) => right.updatedAt - left.updatedAt);
+  };
+  const set = async (input) => {
+    const existing = await get(input);
+    const record = createVoiceAssistantMemoryRecord({
+      ...input,
+      createdAt: input.createdAt ?? existing?.createdAt,
+      updatedAt: input.updatedAt
+    });
+    await writeJsonFile(resolveFilePath(options.directory, createMemoryStoreId(record)), record, options);
+    return record;
+  };
+  const remove = async (input) => {
+    await rm(resolveFilePath(options.directory, createMemoryStoreId(input)), {
+      force: true
+    });
+  };
+  return { delete: remove, get, list, set };
+};
 var createVoiceFileRuntimeStorage = (options) => ({
   events: createVoiceFileIntegrationEventStore({
     ...options,
@@ -6280,6 +7048,10 @@ var createVoiceFileRuntimeStorage = (options) => ({
     ...options,
     directory: join(options.directory, "external-objects")
   }),
+  memories: createVoiceFileAssistantMemoryStore({
+    ...options,
+    directory: join(options.directory, "memories")
+  }),
   reviews: createVoiceFileReviewStore({
     ...options,
     directory: join(options.directory, "reviews")
@@ -6312,6 +7084,672 @@ var createStoredVoiceExternalObjectMap = (mapping) => createVoiceExternalObjectM
   sourceId: mapping.sourceId,
   sourceType: mapping.sourceType
 });
+// src/modelAdapters.ts
+var OUTPUT_SCHEMA = {
+  additionalProperties: false,
+  properties: {
+    assistantText: {
+      type: "string"
+    },
+    complete: {
+      type: "boolean"
+    },
+    escalate: {
+      additionalProperties: false,
+      properties: {
+        metadata: {
+          additionalProperties: true,
+          type: "object"
+        },
+        reason: {
+          type: "string"
+        }
+      },
+      required: ["reason"],
+      type: "object"
+    },
+    noAnswer: {
+      additionalProperties: false,
+      properties: {
+        metadata: {
+          additionalProperties: true,
+          type: "object"
+        }
+      },
+      type: "object"
+    },
+    result: {
+      additionalProperties: true,
+      type: "object"
+    },
+    transfer: {
+      additionalProperties: false,
+      properties: {
+        metadata: {
+          additionalProperties: true,
+          type: "object"
+        },
+        reason: {
+          type: "string"
+        },
+        target: {
+          type: "string"
+        }
+      },
+      required: ["target"],
+      type: "object"
+    },
+    voicemail: {
+      additionalProperties: false,
+      properties: {
+        metadata: {
+          additionalProperties: true,
+          type: "object"
+        }
+      },
+      type: "object"
+    }
+  },
+  type: "object"
+};
+var ROUTE_RESULT_INSTRUCTION = "Return only a JSON object with assistantText, complete, transfer, escalate, voicemail, noAnswer, and result when you are not calling tools. Only set transfer, escalate, voicemail, or noAnswer when the user explicitly asks for that lifecycle outcome or a tool result says that exact outcome. Do not infer voicemail from generic words like voice, voice app, or voice integration.";
+var stripJSONCodeFence = (value) => {
+  const trimmed = value.trim();
+  const match = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+  return match?.[1]?.trim() ?? value;
+};
+var parseJSON = (value) => {
+  try {
+    const parsed = JSON.parse(stripJSONCodeFence(value));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {
+      assistantText: value
+    };
+  }
+};
+var parseJSONValue = (value) => {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+};
+var getMessageToolCalls = (message) => {
+  const toolCalls = message.metadata?.toolCalls;
+  return Array.isArray(toolCalls) ? toolCalls.filter((toolCall) => toolCall && typeof toolCall === "object" && typeof toolCall.name === "string") : [];
+};
+var createHTTPError = (provider, response) => new Error(`${provider} voice assistant model failed: HTTP ${response.status}`);
+var sleep4 = (ms) => new Promise((resolve2) => {
+  setTimeout(resolve2, ms);
+});
+var errorMessage = (error) => error instanceof Error ? error.message : String(error);
+var defaultIsRateLimitError = (error) => /(\b429\b|rate limit|quota|too many requests)/i.test(errorMessage(error));
+var normalizeRouteOutput = (output) => {
+  const result = {};
+  if (typeof output.assistantText === "string") {
+    result.assistantText = output.assistantText;
+  }
+  if (typeof output.complete === "boolean") {
+    result.complete = output.complete;
+  }
+  if (output.result !== undefined) {
+    result.result = output.result;
+  }
+  if (output.transfer && typeof output.transfer === "object") {
+    const transfer = output.transfer;
+    if (typeof transfer.target === "string") {
+      result.transfer = {
+        metadata: transfer.metadata && typeof transfer.metadata === "object" ? transfer.metadata : undefined,
+        reason: typeof transfer.reason === "string" ? transfer.reason : undefined,
+        target: transfer.target
+      };
+    }
+  }
+  if (output.escalate && typeof output.escalate === "object") {
+    const escalate = output.escalate;
+    if (typeof escalate.reason === "string") {
+      result.escalate = {
+        metadata: escalate.metadata && typeof escalate.metadata === "object" ? escalate.metadata : undefined,
+        reason: escalate.reason
+      };
+    }
+  }
+  if (output.voicemail && typeof output.voicemail === "object") {
+    const voicemail = output.voicemail;
+    result.voicemail = {
+      metadata: voicemail.metadata && typeof voicemail.metadata === "object" ? voicemail.metadata : undefined
+    };
+  }
+  if (output.noAnswer && typeof output.noAnswer === "object") {
+    const noAnswer = output.noAnswer;
+    result.noAnswer = {
+      metadata: noAnswer.metadata && typeof noAnswer.metadata === "object" ? noAnswer.metadata : undefined
+    };
+  }
+  return result;
+};
+var createJSONVoiceAssistantModel = (options) => ({
+  generate: async (input) => {
+    const output = await options.generate(input);
+    if ("assistantText" in output || "toolCalls" in output || "complete" in output || "transfer" in output || "escalate" in output) {
+      return output;
+    }
+    return options.mapOutput?.(output) ?? normalizeRouteOutput(output);
+  }
+});
+var createVoiceProviderRouter = (options) => {
+  const providerIds = Object.keys(options.providers);
+  const firstProvider = providerIds[0];
+  const resolveOrder = async (input) => {
+    const selectedProvider = await options.selectProvider?.(input);
+    const fallbackOrder = typeof options.fallback === "function" ? await options.fallback(input) : options.fallback;
+    const preferred = selectedProvider ?? fallbackOrder?.[0] ?? firstProvider;
+    const seen = new Set;
+    const order = [];
+    for (const provider of [
+      preferred,
+      ...fallbackOrder ?? [],
+      ...providerIds
+    ]) {
+      if (!provider || seen.has(provider) || !options.providers[provider]) {
+        continue;
+      }
+      seen.add(provider);
+      order.push(provider);
+    }
+    return {
+      order,
+      selectedProvider: preferred
+    };
+  };
+  const emit = async (event, input) => {
+    await options.onProviderEvent?.(event, input);
+  };
+  return {
+    generate: async (input) => {
+      const { order, selectedProvider } = await resolveOrder(input);
+      if (!selectedProvider || order.length === 0) {
+        throw new Error("Voice provider router has no available providers.");
+      }
+      let lastError;
+      for (const [index, provider] of order.entries()) {
+        const model = options.providers[provider];
+        if (!model) {
+          continue;
+        }
+        const startedAt = Date.now();
+        try {
+          const output = await model.generate(input);
+          await emit({
+            at: Date.now(),
+            elapsedMs: Date.now() - startedAt,
+            fallbackProvider: provider === selectedProvider ? undefined : provider,
+            provider,
+            recovered: provider !== selectedProvider,
+            selectedProvider,
+            status: provider === selectedProvider ? "success" : "fallback"
+          }, input);
+          return output;
+        } catch (error) {
+          lastError = error;
+          const hasNextProvider = index < order.length - 1;
+          const isProviderError = options.isProviderError?.(error, provider) ?? true;
+          const nextProvider = hasNextProvider ? order[index + 1] : undefined;
+          await emit({
+            at: Date.now(),
+            elapsedMs: Date.now() - startedAt,
+            error: errorMessage(error),
+            fallbackProvider: isProviderError ? nextProvider : undefined,
+            provider,
+            rateLimited: options.isRateLimitError?.(error, provider) ?? defaultIsRateLimitError(error),
+            selectedProvider,
+            status: "error"
+          }, input);
+          if (!hasNextProvider || !isProviderError) {
+            throw error;
+          }
+        }
+      }
+      throw lastError ?? new Error("Voice provider router did not run a provider.");
+    }
+  };
+};
+var messageToOpenAIInput = (message) => {
+  if (message.role === "tool") {
+    return [
+      {
+        call_id: message.toolCallId ?? message.name ?? crypto.randomUUID(),
+        output: message.content,
+        type: "function_call_output"
+      }
+    ];
+  }
+  const toolCalls = getMessageToolCalls(message);
+  if (message.role === "assistant" && toolCalls.length) {
+    return toolCalls.map((toolCall) => ({
+      arguments: JSON.stringify(toolCall.args),
+      call_id: toolCall.id ?? crypto.randomUUID(),
+      name: toolCall.name,
+      type: "function_call"
+    }));
+  }
+  return [
+    {
+      content: message.content,
+      role: message.role === "system" ? "developer" : message.role
+    }
+  ];
+};
+var messagesToOpenAIInput = (messages) => messages.flatMap(messageToOpenAIInput);
+var messageToAnthropicMessage = (message) => {
+  if (message.role === "system") {
+    return;
+  }
+  if (message.role === "tool") {
+    if (!message.toolCallId) {
+      return {
+        content: `Tool result from ${message.name ?? "tool"}: ${message.content}`,
+        role: "user"
+      };
+    }
+    return {
+      content: [
+        {
+          content: message.content,
+          tool_use_id: message.toolCallId,
+          type: "tool_result"
+        }
+      ],
+      role: "user"
+    };
+  }
+  const toolCalls = getMessageToolCalls(message);
+  if (message.role === "assistant" && toolCalls.length) {
+    return {
+      content: [
+        ...message.content ? [
+          {
+            text: message.content,
+            type: "text"
+          }
+        ] : [],
+        ...toolCalls.map((toolCall) => ({
+          id: toolCall.id ?? crypto.randomUUID(),
+          input: toolCall.args,
+          name: toolCall.name,
+          type: "tool_use"
+        }))
+      ],
+      role: "assistant"
+    };
+  }
+  return {
+    content: message.content,
+    role: message.role
+  };
+};
+var toGeminiSchema = (schema) => {
+  const next = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === "additionalProperties") {
+      continue;
+    }
+    if (key === "type" && typeof value === "string") {
+      next[key] = value.toUpperCase();
+      continue;
+    }
+    if (Array.isArray(value)) {
+      next[key] = value.map((item) => item && typeof item === "object" ? toGeminiSchema(item) : item);
+      continue;
+    }
+    if (value && typeof value === "object") {
+      next[key] = toGeminiSchema(value);
+      continue;
+    }
+    next[key] = value;
+  }
+  return next;
+};
+var messageToGeminiContent = (message) => {
+  if (message.role === "system") {
+    return;
+  }
+  if (message.role === "tool") {
+    return {
+      parts: [
+        {
+          functionResponse: {
+            id: message.toolCallId,
+            name: message.name ?? "tool",
+            response: {
+              result: parseJSONValue(message.content)
+            }
+          }
+        }
+      ],
+      role: "user"
+    };
+  }
+  const toolCalls = getMessageToolCalls(message);
+  if (message.role === "assistant" && toolCalls.length) {
+    return {
+      parts: [
+        ...message.content ? [
+          {
+            text: message.content
+          }
+        ] : [],
+        ...toolCalls.map((toolCall) => ({
+          functionCall: {
+            args: toolCall.args,
+            id: toolCall.id,
+            name: toolCall.name
+          }
+        }))
+      ],
+      role: "model"
+    };
+  }
+  return {
+    parts: [
+      {
+        text: message.content
+      }
+    ],
+    role: message.role === "assistant" ? "model" : "user"
+  };
+};
+var extractText = (response) => {
+  if (typeof response.output_text === "string") {
+    return response.output_text;
+  }
+  const output = Array.isArray(response.output) ? response.output : [];
+  for (const item of output) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const record = item;
+    const content = Array.isArray(record.content) ? record.content : [];
+    for (const contentItem of content) {
+      if (!contentItem || typeof contentItem !== "object") {
+        continue;
+      }
+      const contentRecord = contentItem;
+      if (typeof contentRecord.text === "string") {
+        return contentRecord.text;
+      }
+    }
+  }
+  return "";
+};
+var extractToolCalls = (response) => {
+  const output = Array.isArray(response.output) ? response.output : [];
+  const toolCalls = [];
+  for (const item of output) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const record = item;
+    if (record.type !== "function_call" || typeof record.name !== "string") {
+      continue;
+    }
+    const args = typeof record.arguments === "string" ? parseJSON(record.arguments) : {};
+    toolCalls.push({
+      args,
+      id: typeof record.call_id === "string" ? record.call_id : typeof record.id === "string" ? record.id : undefined,
+      name: record.name
+    });
+  }
+  return toolCalls;
+};
+var createOpenAIVoiceAssistantModel = (options) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const baseUrl = options.baseUrl ?? "https://api.openai.com/v1";
+  const model = options.model ?? "gpt-4.1-mini";
+  return {
+    generate: async (input) => {
+      const response = await fetchImpl(`${baseUrl.replace(/\/$/, "")}/responses`, {
+        body: JSON.stringify({
+          input: messagesToOpenAIInput(input.messages),
+          instructions: [
+            input.system,
+            "Return a JSON object with assistantText, complete, transfer, escalate, voicemail, noAnswer, and result when you are not calling tools."
+          ].filter(Boolean).join(`
+
+`),
+          max_output_tokens: options.maxOutputTokens,
+          model,
+          temperature: options.temperature,
+          text: {
+            format: {
+              name: "voice_route_result",
+              schema: OUTPUT_SCHEMA,
+              strict: false,
+              type: "json_schema"
+            }
+          },
+          tool_choice: input.tools.length ? "auto" : "none",
+          tools: input.tools.map((tool) => ({
+            description: tool.description,
+            name: tool.name,
+            parameters: tool.parameters ?? {
+              additionalProperties: true,
+              type: "object"
+            },
+            strict: false,
+            type: "function"
+          }))
+        }),
+        headers: {
+          authorization: `Bearer ${options.apiKey}`,
+          "content-type": "application/json"
+        },
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw createHTTPError("OpenAI", response);
+      }
+      const body = await response.json();
+      if (body.usage && typeof body.usage === "object") {
+        await options.onUsage?.(body.usage);
+      }
+      const toolCalls = extractToolCalls(body);
+      if (toolCalls.length) {
+        return {
+          toolCalls
+        };
+      }
+      return normalizeRouteOutput(parseJSON(extractText(body)));
+    }
+  };
+};
+var extractAnthropicText = (response) => {
+  const content = Array.isArray(response.content) ? response.content : [];
+  return content.map((item) => item && typeof item === "object" && item.type === "text" && typeof item.text === "string" ? item.text : "").filter(Boolean).join(`
+`);
+};
+var extractAnthropicToolCalls = (response) => {
+  const content = Array.isArray(response.content) ? response.content : [];
+  const toolCalls = [];
+  for (const item of content) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const record = item;
+    if (record.type !== "tool_use" || typeof record.name !== "string") {
+      continue;
+    }
+    toolCalls.push({
+      args: record.input && typeof record.input === "object" ? record.input : {},
+      id: typeof record.id === "string" ? record.id : undefined,
+      name: record.name
+    });
+  }
+  return toolCalls;
+};
+var createAnthropicVoiceAssistantModel = (options) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const baseUrl = options.baseUrl ?? "https://api.anthropic.com/v1";
+  const model = options.model ?? "claude-sonnet-4-5";
+  return {
+    generate: async (input) => {
+      const response = await fetchImpl(`${baseUrl.replace(/\/$/, "")}/messages`, {
+        body: JSON.stringify({
+          max_tokens: options.maxOutputTokens ?? 1024,
+          messages: input.messages.map(messageToAnthropicMessage).filter(Boolean),
+          model,
+          system: [input.system, ROUTE_RESULT_INSTRUCTION].filter(Boolean).join(`
+
+`),
+          temperature: options.temperature,
+          tool_choice: input.tools.length ? { type: "auto" } : { type: "none" },
+          tools: input.tools.map((tool) => ({
+            description: tool.description,
+            input_schema: tool.parameters ?? {
+              additionalProperties: true,
+              type: "object"
+            },
+            name: tool.name
+          }))
+        }),
+        headers: {
+          "anthropic-version": options.version ?? "2023-06-01",
+          "content-type": "application/json",
+          "x-api-key": options.apiKey
+        },
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw createHTTPError("Anthropic", response);
+      }
+      const body = await response.json();
+      if (body.usage && typeof body.usage === "object") {
+        await options.onUsage?.(body.usage);
+      }
+      const toolCalls = extractAnthropicToolCalls(body);
+      if (toolCalls.length) {
+        return {
+          assistantText: extractAnthropicText(body) || undefined,
+          toolCalls
+        };
+      }
+      return normalizeRouteOutput(parseJSON(extractAnthropicText(body)));
+    }
+  };
+};
+var extractGeminiCandidateParts = (response) => {
+  const candidates = Array.isArray(response.candidates) ? response.candidates : [];
+  const first = candidates[0];
+  if (!first || typeof first !== "object") {
+    return [];
+  }
+  const content = first.content;
+  if (!content || typeof content !== "object") {
+    return [];
+  }
+  const parts = content.parts;
+  return Array.isArray(parts) ? parts : [];
+};
+var extractGeminiText = (response) => extractGeminiCandidateParts(response).map((part) => part && typeof part === "object" && typeof part.text === "string" ? part.text : "").filter(Boolean).join(`
+`);
+var extractGeminiToolCalls = (response) => {
+  const toolCalls = [];
+  for (const part of extractGeminiCandidateParts(response)) {
+    if (!part || typeof part !== "object") {
+      continue;
+    }
+    const functionCall = part.functionCall;
+    if (!functionCall || typeof functionCall !== "object") {
+      continue;
+    }
+    const record = functionCall;
+    if (typeof record.name !== "string") {
+      continue;
+    }
+    toolCalls.push({
+      args: record.args && typeof record.args === "object" ? record.args : {},
+      id: typeof record.id === "string" ? record.id : undefined,
+      name: record.name
+    });
+  }
+  return toolCalls;
+};
+var createGeminiVoiceAssistantModel = (options) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const baseUrl = options.baseUrl ?? "https://generativelanguage.googleapis.com/v1beta";
+  const model = options.model ?? "gemini-2.5-flash";
+  const maxRetries = Math.max(0, options.maxRetries ?? 2);
+  return {
+    generate: async (input) => {
+      const endpoint = `${baseUrl.replace(/\/$/, "")}/models/${encodeURIComponent(model)}:generateContent?key=${encodeURIComponent(options.apiKey)}`;
+      let response;
+      for (let attempt = 0;attempt <= maxRetries; attempt += 1) {
+        response = await fetchImpl(endpoint, {
+          body: JSON.stringify({
+            contents: input.messages.map(messageToGeminiContent).filter(Boolean),
+            generationConfig: {
+              maxOutputTokens: options.maxOutputTokens,
+              ...input.tools.length ? {} : {
+                responseMimeType: "application/json",
+                responseSchema: toGeminiSchema(OUTPUT_SCHEMA)
+              },
+              temperature: options.temperature
+            },
+            systemInstruction: {
+              parts: [
+                {
+                  text: [input.system, ROUTE_RESULT_INSTRUCTION].filter(Boolean).join(`
+
+`)
+                }
+              ]
+            },
+            tools: input.tools.length ? [
+              {
+                functionDeclarations: input.tools.map((tool) => ({
+                  description: tool.description,
+                  name: tool.name,
+                  parameters: toGeminiSchema(tool.parameters ?? {
+                    additionalProperties: true,
+                    type: "object"
+                  })
+                }))
+              }
+            ] : undefined
+          }),
+          headers: {
+            "content-type": "application/json"
+          },
+          method: "POST"
+        });
+        if (response.ok || response.status !== 429 && response.status < 500 || attempt === maxRetries) {
+          break;
+        }
+        const retryAfter = Number(response.headers.get("retry-after"));
+        await sleep4(Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter * 1000 : 500 * 2 ** attempt);
+      }
+      if (!response) {
+        throw new Error("Gemini voice assistant model failed: no response");
+      }
+      if (!response.ok) {
+        throw createHTTPError("Gemini", response);
+      }
+      const body = await response.json();
+      if (body.usageMetadata && typeof body.usageMetadata === "object") {
+        await options.onUsage?.(body.usageMetadata);
+      }
+      const toolCalls = extractGeminiToolCalls(body);
+      if (toolCalls.length) {
+        return {
+          assistantText: extractGeminiText(body) || undefined,
+          toolCalls
+        };
+      }
+      return normalizeRouteOutput(parseJSON(extractGeminiText(body)));
+    }
+  };
+};
 // src/sqliteStore.ts
 import { Database } from "bun:sqlite";
 var normalizeTableNameSegment = (value) => value.trim().replace(/[^a-zA-Z0-9_]+/g, "_").replace(/^_+|_+$/g, "") || "voice";
@@ -7509,10 +8947,10 @@ var createVoiceOpsTaskProcessorWorker = (options) => ({
         result.completed += 1;
       } catch (error) {
         await options.onError?.(error, task);
-        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorMessage2 = error instanceof Error ? error.message : String(error);
         const failedTask = failVoiceOpsTask(task, {
           actor: task.claimedBy ?? "ops-worker",
-          error: errorMessage
+          error: errorMessage2
         });
         if (shouldDeadLetterTask(failedTask, options.maxFailures)) {
           const deadLetterTask = deadLetterVoiceOpsTask(failedTask, {
@@ -7987,230 +9425,6 @@ var resolveVoiceOpsPreset = (name, overrides = {}) => {
     taskPolicies: mergePolicies(preset.taskPolicies, overrides.taskPolicies)
   };
 };
-// src/outcomeRecipes.ts
-var RECIPE_DEFAULTS = {
-  "appointment-booking": {
-    completedAction: "Verify appointment details, confirm calendar state, and send any required confirmation.",
-    completedDescription: "The call completed an appointment-booking flow and should be checked against the scheduling system.",
-    completedKind: "appointment-booking",
-    completedTitle: "Confirm booked appointment",
-    defaultCompletedCreatesTask: true,
-    defaultDueInMs: 30 * 60000,
-    defaultPriority: "normal",
-    defaultQueue: "appointments",
-    description: "Creates appointment confirmation work for completed calls and callback/retry work for missed booking attempts.",
-    escalationQueue: "appointments-escalations"
-  },
-  "lead-qualification": {
-    completedAction: "Review qualification signals, update CRM fields, and route the lead to the right owner.",
-    completedDescription: "The call completed a lead-qualification flow and should be reviewed for sales follow-up.",
-    completedKind: "lead-qualification",
-    completedTitle: "Review qualified lead",
-    defaultCompletedCreatesTask: true,
-    defaultDueInMs: 15 * 60000,
-    defaultPriority: "high",
-    defaultQueue: "sales-leads",
-    description: "Creates sales follow-up work for completed qualification calls and fast callbacks for missed leads.",
-    escalationQueue: "sales-escalations"
-  },
-  "support-triage": {
-    completedAction: "Review the triage result, confirm the support category, and route any unresolved issue.",
-    completedDescription: "The call completed support triage and may need queue routing or human follow-up.",
-    completedKind: "support-triage",
-    completedTitle: "Review support triage",
-    defaultCompletedCreatesTask: true,
-    defaultDueInMs: 20 * 60000,
-    defaultPriority: "normal",
-    defaultQueue: "support-triage",
-    description: "Creates support triage work for completed calls and urgent escalation/callback work for unresolved callers.",
-    escalationQueue: "support-escalations"
-  },
-  "voicemail-callback": {
-    completedAction: "No callback is required for completed calls.",
-    completedDescription: "The call completed without requiring voicemail follow-up.",
-    completedKind: "callback",
-    completedTitle: "Completed call",
-    defaultCompletedCreatesTask: false,
-    defaultDueInMs: 15 * 60000,
-    defaultPriority: "high",
-    defaultQueue: "callbacks",
-    description: "Creates callback work for voicemail, no-answer, failed, or escalated calls while ignoring completed calls.",
-    escalationQueue: "callback-escalations"
-  },
-  "warm-transfer": {
-    completedAction: "Confirm the handoff target received the caller context and close the transfer loop.",
-    completedDescription: "The call is part of a warm-transfer flow and should be verified downstream.",
-    completedKind: "transfer-check",
-    completedTitle: "Verify warm transfer",
-    defaultCompletedCreatesTask: false,
-    defaultDueInMs: 10 * 60000,
-    defaultPriority: "normal",
-    defaultQueue: "transfer-verification",
-    description: "Creates transfer verification work for transferred calls and escalation work when the handoff fails.",
-    escalationQueue: "transfer-escalations"
-  }
-};
-var buildRecipeTask = (input) => {
-  const createdAt = input.review.generatedAt ?? Date.now();
-  const queue = input.options.queue ?? input.defaults.defaultQueue;
-  const target = input.options.target ?? input.review.postCall?.target;
-  const common = {
-    assignee: input.options.assignee,
-    createdAt,
-    history: [
-      {
-        actor: "system",
-        at: createdAt,
-        detail: input.review.postCall?.summary,
-        type: "created"
-      }
-    ],
-    id: `${input.review.id}:${input.defaults.completedKind}`,
-    intakeId: input.review.id,
-    outcome: input.review.summary.outcome,
-    priority: input.options.priority ?? input.defaults.defaultPriority,
-    queue,
-    reviewId: input.review.id,
-    status: "open",
-    target,
-    updatedAt: createdAt
-  };
-  switch (input.disposition) {
-    case "completed":
-      if (!(input.options.completedCreatesTask ?? input.defaults.defaultCompletedCreatesTask)) {
-        return null;
-      }
-      return {
-        ...common,
-        description: input.defaults.completedDescription,
-        kind: input.defaults.completedKind,
-        recommendedAction: input.defaults.completedAction,
-        title: target ? `${input.defaults.completedTitle}: ${target}` : input.defaults.completedTitle
-      };
-    case "voicemail":
-      return {
-        ...common,
-        description: input.review.postCall?.summary ?? "The caller reached voicemail and needs a callback.",
-        id: `${input.review.id}:callback`,
-        kind: "callback",
-        recommendedAction: input.review.postCall?.recommendedAction ?? "Call the customer back and continue the original flow.",
-        title: target ? `Call back ${target}` : "Call back voicemail lead"
-      };
-    case "no-answer":
-      return {
-        ...common,
-        description: input.review.postCall?.summary ?? "The call did not reach a live respondent and should be retried.",
-        id: `${input.review.id}:retry`,
-        kind: "callback",
-        recommendedAction: input.review.postCall?.recommendedAction ?? "Retry the call or schedule a callback.",
-        title: "Retry no-answer call"
-      };
-    case "transferred":
-      return {
-        ...common,
-        description: input.review.postCall?.summary ?? "The call was transferred and should be verified downstream.",
-        id: `${input.review.id}:transfer-check`,
-        kind: "transfer-check",
-        recommendedAction: input.review.postCall?.recommendedAction ?? "Confirm the receiving team got the caller context.",
-        title: target ? `Verify transfer to ${target}` : "Verify call transfer"
-      };
-    case "escalated":
-      return {
-        ...common,
-        description: input.review.postCall?.summary ?? "The call escalated and needs human review.",
-        id: `${input.review.id}:escalation`,
-        kind: "escalation",
-        priority: "urgent",
-        queue: input.options.escalationQueue ?? input.defaults.escalationQueue,
-        assignee: input.options.escalationAssignee ?? input.options.assignee,
-        recommendedAction: input.review.postCall?.recommendedAction ?? "Review the escalated call and respond immediately.",
-        title: "Review escalated call"
-      };
-    case "failed":
-    case "closed":
-      return {
-        ...common,
-        description: input.review.postCall?.summary ?? "The call ended before successful completion and needs review.",
-        id: `${input.review.id}:retry-review`,
-        kind: "retry-review",
-        priority: "high",
-        recommendedAction: input.review.postCall?.recommendedAction ?? "Inspect the call and decide whether to retry, escalate, or close.",
-        title: "Inspect incomplete call"
-      };
-    default:
-      return null;
-  }
-};
-var resolveVoiceOutcomeRecipe = (name, options = {}) => {
-  const defaults = RECIPE_DEFAULTS[name];
-  const taskPolicies = {
-    completed: {
-      assignee: options.assignee,
-      dueInMs: options.dueInMs ?? defaults.defaultDueInMs,
-      name: `${name}-completed`,
-      priority: options.priority ?? defaults.defaultPriority,
-      queue: options.queue ?? defaults.defaultQueue
-    },
-    escalated: {
-      assignee: options.escalationAssignee ?? options.assignee,
-      dueInMs: Math.min(options.dueInMs ?? defaults.defaultDueInMs, 10 * 60000),
-      name: `${name}-escalation`,
-      priority: "urgent",
-      queue: options.escalationQueue ?? defaults.escalationQueue
-    },
-    failed: {
-      assignee: options.assignee,
-      dueInMs: options.dueInMs ?? defaults.defaultDueInMs,
-      name: `${name}-failed-review`,
-      priority: "high",
-      queue: options.queue ?? defaults.defaultQueue
-    },
-    "no-answer": {
-      assignee: options.assignee,
-      dueInMs: options.dueInMs ?? defaults.defaultDueInMs,
-      name: `${name}-no-answer`,
-      priority: options.priority ?? defaults.defaultPriority,
-      queue: options.queue ?? defaults.defaultQueue
-    },
-    transferred: {
-      assignee: options.assignee,
-      dueInMs: Math.min(options.dueInMs ?? defaults.defaultDueInMs, 20 * 60000),
-      name: `${name}-transfer-check`,
-      priority: options.priority ?? defaults.defaultPriority,
-      queue: name === "warm-transfer" ? options.queue ?? defaults.defaultQueue : "transfer-verification"
-    },
-    voicemail: {
-      assignee: options.assignee,
-      dueInMs: options.dueInMs ?? defaults.defaultDueInMs,
-      name: `${name}-voicemail`,
-      priority: options.priority ?? defaults.defaultPriority,
-      queue: options.queue ?? defaults.defaultQueue
-    }
-  };
-  const taskAssignmentRules = [
-    {
-      assign: options.escalationAssignee ?? options.assignee,
-      description: `Route urgent ${name} work to the escalation lane.`,
-      name: `${name}-urgent-routing`,
-      queue: options.escalationQueue ?? defaults.escalationQueue,
-      when: {
-        priority: "urgent"
-      }
-    }
-  ].filter((rule) => rule.assign || rule.queue);
-  return {
-    createTaskFromReview: ({ disposition, review }) => buildRecipeTask({
-      defaults,
-      disposition,
-      options,
-      review
-    }),
-    description: defaults.description,
-    name,
-    taskAssignmentRules,
-    taskPolicies
-  };
-};
 // src/correction.ts
 var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 var buildAliasMatcher = (alias) => new RegExp(`(?<![\\p{L}\\p{N}'])${escapeRegExp(alias)}(?![\\p{L}\\p{N}'])`, "giu");
@@ -8990,6 +10204,7 @@ export {
   summarizeVoiceOpsTaskQueue,
   summarizeVoiceOpsTaskAnalytics,
   summarizeVoiceIntegrationEvents,
+  summarizeVoiceAssistantRuns,
   startVoiceOpsTask,
   shapeTelephonyAssistantText,
   selectVoiceTraceEventsForPrune,
@@ -9001,6 +10216,7 @@ export {
   resolveVoiceOpsTaskAssignment,
   resolveVoiceOpsTaskAgeBucket,
   resolveVoiceOpsPreset,
+  resolveVoiceAssistantMemoryNamespace,
   resolveTurnDetectionConfig,
   resolveAudioConditioningConfig,
   requeueVoiceOpsTask,
@@ -9061,6 +10277,7 @@ export {
   createVoiceReviewSavedEvent,
   createVoiceRedisTaskLeaseCoordinator,
   createVoiceRedisIdempotencyStore,
+  createVoiceProviderRouter,
   createVoicePostgresTraceSinkDeliveryStore,
   createVoicePostgresTraceEventStore,
   createVoicePostgresTaskStore,
@@ -9076,6 +10293,7 @@ export {
   createVoiceMemoryTraceSinkDeliveryStore,
   createVoiceMemoryTraceEventStore,
   createVoiceMemoryStore,
+  createVoiceMemoryAssistantMemoryStore,
   createVoiceLinearIssueUpdateSink,
   createVoiceLinearIssueSyncSinks,
   createVoiceLinearIssueSink,
@@ -9095,13 +10313,18 @@ export {
   createVoiceFileReviewStore,
   createVoiceFileIntegrationEventStore,
   createVoiceFileExternalObjectMapStore,
+  createVoiceFileAssistantMemoryStore,
   createVoiceExternalObjectMapId,
   createVoiceExternalObjectMap,
+  createVoiceExperiment,
   createVoiceCallReviewRecorder,
   createVoiceCallReviewFromSession,
   createVoiceCallReviewFromLiveTelephonyReport,
   createVoiceCallCompletedEvent,
   createVoiceCRMActivitySink,
+  createVoiceAssistantMemoryRecord,
+  createVoiceAssistantMemoryHandle,
+  createVoiceAssistant,
   createVoiceAgentTool,
   createVoiceAgentSquad,
   createVoiceAgent,
@@ -9113,9 +10336,13 @@ export {
   createStoredVoiceCallReviewArtifact,
   createRiskyTurnCorrectionHandler,
   createPhraseHintCorrectionHandler,
+  createOpenAIVoiceAssistantModel,
+  createJSONVoiceAssistantModel,
   createId,
+  createGeminiVoiceAssistantModel,
   createDomainPhraseHints,
   createDomainLexicon,
+  createAnthropicVoiceAssistantModel,
   conditionAudioChunk,
   completeVoiceOpsTask,
   claimVoiceOpsTask,