@absolutejs/voice 0.0.22-beta.2 → 0.0.22-beta.21

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"
         });
       }
@@ -5594,6 +5605,112 @@ var resolveVoiceOutcomeRecipe = (name, options = {}) => {
   };
 };
 
+// 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;
@@ -5603,6 +5720,47 @@ var hashString = (value) => {
   }
   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) {
@@ -5671,6 +5829,7 @@ var createVoiceExperiment = (options) => {
 };
 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,
@@ -5700,14 +5859,63 @@ var createVoiceAssistant = (options) => {
     });
   }
   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
+      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,
@@ -5722,12 +5930,56 @@ var createVoiceAssistant = (options) => {
       trace: options.trace,
       tools: variant.tools ?? baseModelOptions.tools
     }) : agent;
-    const result = await runner.run(input) ?? {};
+    const runResult = await runner.run(input) ?? {};
+    const result = runResult;
     const guarded = await options.guardrails?.afterTurn?.({
       ...guardrailInput,
       result
     });
-    return guarded ?? 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,
@@ -5743,9 +5995,408 @@ var createVoiceAssistant = (options) => {
     })
   };
 };
-// src/fileStore.ts
-import { mkdir, readFile, readdir, rename, rm, writeFile } from "fs/promises";
-import { join } from "path";
+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/assistantHealth.ts
+import { Elysia as Elysia3 } from "elysia";
+
+// src/providerHealth.ts
+import { Elysia as Elysia2 } from "elysia";
+var getString = (value) => typeof value === "string" ? value : undefined;
+var getNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+var isProviderStatus = (value) => value === "success" || value === "fallback" || value === "error";
+var summarizeVoiceProviderHealth = async (input) => {
+  const options = Array.isArray(input) ? { events: input } : input;
+  const events = options.events ?? await options.store?.list() ?? [];
+  const providers = options.providers ?? [];
+  const providerSet = new Set(providers);
+  const now = options.now ?? Date.now();
+  const entries = new Map;
+  const isAllowedProvider = (value) => typeof value === "string" && (providerSet.size === 0 || providerSet.has(value));
+  const getEntry = (provider) => {
+    const existing = entries.get(provider);
+    if (existing) {
+      return existing;
+    }
+    const entry = {
+      elapsedCount: 0,
+      elapsedTotal: 0,
+      errorCount: 0,
+      fallbackCount: 0,
+      provider,
+      rateLimited: false,
+      recommended: false,
+      runCount: 0,
+      status: "idle"
+    };
+    entries.set(provider, entry);
+    return entry;
+  };
+  for (const provider of providers) {
+    getEntry(provider);
+  }
+  const hasProviderRouterEvents = events.some((event) => event.type === "session.error" && isAllowedProvider(event.payload.provider) && isProviderStatus(event.payload.providerStatus));
+  for (const event of events) {
+    if (event.type === "assistant.run") {
+      if (hasProviderRouterEvents) {
+        continue;
+      }
+      const provider2 = event.payload.variantId;
+      if (!isAllowedProvider(provider2)) {
+        continue;
+      }
+      const entry2 = getEntry(provider2);
+      entry2.runCount += 1;
+      const elapsedMs = getNumber(event.payload.elapsedMs);
+      if (elapsedMs !== undefined) {
+        entry2.elapsedCount += 1;
+        entry2.elapsedTotal += elapsedMs;
+      }
+      continue;
+    }
+    if (event.type !== "session.error") {
+      continue;
+    }
+    const provider = event.payload.provider;
+    if (!isAllowedProvider(provider)) {
+      continue;
+    }
+    const providerStatus = isProviderStatus(event.payload.providerStatus) ? event.payload.providerStatus : undefined;
+    const applyProviderHealth = () => {
+      const entry2 = getEntry(provider);
+      const providerHealth = event.payload.providerHealth;
+      if (providerHealth && typeof providerHealth === "object") {
+        const suppressedUntil2 = getNumber(providerHealth.suppressedUntil);
+        if (suppressedUntil2 !== undefined) {
+          entry2.suppressedUntil = suppressedUntil2;
+        }
+      }
+      const suppressedUntil = getNumber(event.payload.suppressedUntil);
+      if (suppressedUntil !== undefined) {
+        entry2.suppressedUntil = suppressedUntil;
+      }
+      const suppressionRemainingMs = getNumber(event.payload.suppressionRemainingMs);
+      if (suppressionRemainingMs !== undefined) {
+        entry2.suppressionRemainingMs = suppressionRemainingMs;
+      }
+      return entry2;
+    };
+    if (providerStatus === "success" || providerStatus === "fallback") {
+      const entry2 = applyProviderHealth();
+      entry2.runCount += 1;
+      entry2.lastSuccessAt = event.at;
+      if (providerStatus === "success") {
+        entry2.lastError = undefined;
+        entry2.rateLimited = false;
+        entry2.suppressedUntil = undefined;
+        entry2.suppressionRemainingMs = undefined;
+      }
+      const elapsedMs = getNumber(event.payload.elapsedMs);
+      if (elapsedMs !== undefined) {
+        entry2.elapsedCount += 1;
+        entry2.elapsedTotal += elapsedMs;
+      }
+      const selectedProvider = event.payload.selectedProvider;
+      if (providerStatus === "fallback" && isAllowedProvider(selectedProvider) && selectedProvider !== provider) {
+        getEntry(selectedProvider).fallbackCount += 1;
+      }
+      continue;
+    }
+    const entry = applyProviderHealth();
+    entry.errorCount += 1;
+    entry.lastError = getString(event.payload.error);
+    entry.lastErrorAt = event.at;
+    entry.rateLimited ||= event.payload.rateLimited === true;
+  }
+  const summaries = [...entries.values()].map((entry) => {
+    const hadSuppression = typeof entry.suppressedUntil === "number" || typeof entry.suppressionRemainingMs === "number";
+    const suppressionRemainingMs = typeof entry.suppressedUntil === "number" ? Math.max(0, entry.suppressedUntil - now) : entry.suppressionRemainingMs;
+    const activeSuppression = typeof suppressionRemainingMs === "number" && suppressionRemainingMs > 0;
+    const recoverable = hadSuppression && !activeSuppression;
+    const averageElapsedMs = entry.elapsedCount > 0 ? Math.round(entry.elapsedTotal / entry.elapsedCount) : undefined;
+    const status = activeSuppression ? "suppressed" : recoverable ? "recoverable" : entry.rateLimited ? "rate-limited" : entry.errorCount > 0 && (!entry.lastSuccessAt || !entry.lastErrorAt || entry.lastErrorAt > entry.lastSuccessAt) ? "degraded" : entry.runCount > 0 ? "healthy" : "idle";
+    return {
+      averageElapsedMs,
+      errorCount: entry.errorCount,
+      fallbackCount: entry.fallbackCount,
+      lastError: entry.lastError,
+      lastErrorAt: entry.lastErrorAt,
+      lastSuccessAt: entry.lastSuccessAt,
+      provider: entry.provider,
+      rateLimited: entry.rateLimited,
+      recommended: false,
+      runCount: entry.runCount,
+      status,
+      suppressionRemainingMs: activeSuppression ? suppressionRemainingMs : undefined,
+      suppressedUntil: entry.suppressedUntil
+    };
+  });
+  const recommended = summaries.filter((entry) => entry.status === "healthy").sort((left, right) => (left.averageElapsedMs ?? Number.MAX_SAFE_INTEGER) - (right.averageElapsedMs ?? Number.MAX_SAFE_INTEGER))[0];
+  if (recommended) {
+    recommended.recommended = true;
+  }
+  return summaries;
+};
+var escapeHtml3 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var renderVoiceProviderHealthHTML = (providers) => providers.length === 0 ? '<p class="voice-provider-empty">No provider status yet.</p>' : [
+  '<div class="voice-provider-health">',
+  ...providers.map((provider) => {
+    const suppressionSeconds = typeof provider.suppressionRemainingMs === "number" ? Math.ceil(provider.suppressionRemainingMs / 1000) : undefined;
+    return [
+      `<article class="voice-provider-card ${escapeHtml3(provider.status)}">`,
+      '<div class="voice-provider-card-header">',
+      `<strong>${escapeHtml3(provider.provider)}</strong>`,
+      `<span>${escapeHtml3(provider.status)}${provider.recommended ? " \xB7 recommended" : ""}</span>`,
+      "</div>",
+      "<dl>",
+      `<div><dt>Runs</dt><dd>${String(provider.runCount)}</dd></div>`,
+      `<div><dt>Avg latency</dt><dd>${String(provider.averageElapsedMs ?? 0)}ms</dd></div>`,
+      `<div><dt>Errors</dt><dd>${String(provider.errorCount)}</dd></div>`,
+      `<div><dt>Fallbacks</dt><dd>${String(provider.fallbackCount)}</dd></div>`,
+      "</dl>",
+      suppressionSeconds ? `<p>Temporarily suppressed for ${String(suppressionSeconds)}s.</p>` : "",
+      provider.lastError ? `<p>${escapeHtml3(provider.lastError)}</p>` : "",
+      "</article>"
+    ].join("");
+  }),
+  "</div>"
+].join("");
+var createVoiceProviderHealthJSONHandler = (options) => async () => summarizeVoiceProviderHealth(options);
+var createVoiceProviderHealthHTMLHandler = (options) => async () => {
+  const providers = await summarizeVoiceProviderHealth(options);
+  const render = options.render ?? renderVoiceProviderHealthHTML;
+  const body = await render(providers);
+  return new Response(body, {
+    headers: {
+      "Content-Type": "text/html; charset=utf-8",
+      ...options.headers
+    }
+  });
+};
+var createVoiceProviderHealthRoutes = (options) => {
+  const path = options.path ?? "/api/provider-status";
+  const htmlPath = options.htmlPath === undefined ? `${path}/htmx` : options.htmlPath;
+  const routes = new Elysia2({
+    name: options.name ?? "absolutejs-voice-provider-health"
+  }).get(path, createVoiceProviderHealthJSONHandler(options));
+  if (htmlPath) {
+    routes.get(htmlPath, createVoiceProviderHealthHTMLHandler(options));
+  }
+  return routes;
+};
+
+// src/assistantHealth.ts
+var escapeHtml4 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var renderCountMap = (values) => {
+  const entries = Object.entries(values).sort((left, right) => right[1] - left[1]);
+  if (entries.length === 0) {
+    return '<p class="voice-assistant-health-empty">No data yet.</p>';
+  }
+  return [
+    '<div class="voice-assistant-health-metrics">',
+    ...entries.map(([label, value]) => `<div><span>${escapeHtml4(label)}</span><strong>${String(value)}</strong></div>`),
+    "</div>"
+  ].join("");
+};
+var getString2 = (value) => typeof value === "string" ? value : undefined;
+var getRecentFailures = (events, maxFailures, replayHref) => events.filter((event) => event.type === "session.error" && (event.payload.providerStatus === "error" || typeof event.payload.error === "string") || event.type === "assistant.guardrail" && event.payload.action === "blocked").toReversed().slice(0, maxFailures).map((event) => {
+  const failure = {
+    at: event.at,
+    assistantId: getString2(event.payload.assistantId),
+    error: getString2(event.payload.error),
+    provider: getString2(event.payload.provider),
+    rateLimited: event.payload.rateLimited === true ? true : undefined,
+    sessionId: event.sessionId,
+    status: getString2(event.payload.providerStatus),
+    turnId: event.turnId,
+    type: event.type
+  };
+  const href = replayHref === false ? undefined : typeof replayHref === "function" ? replayHref(failure) : `${replayHref ?? "/api/voice-sessions"}/${encodeURIComponent(event.sessionId)}/replay/htmx`;
+  return {
+    ...failure,
+    replayHref: href
+  };
+});
+var summarizeVoiceAssistantHealth = async (options) => {
+  const events = options.events ?? await options.store?.list() ?? [];
+  return {
+    assistantRuns: await summarizeVoiceAssistantRuns({ events }),
+    providerHealth: await summarizeVoiceProviderHealth({
+      events,
+      providers: options.providers
+    }),
+    recentFailures: getRecentFailures(events, options.maxFailures ?? 8, options.replayHref)
+  };
+};
+var renderVoiceAssistantHealthHTML = (summary) => {
+  const assistant = summary.assistantRuns.assistants[0];
+  const failures = summary.recentFailures;
+  return [
+    '<div class="voice-assistant-health">',
+    '<section class="voice-assistant-health-grid">',
+    `<article><span>Runs</span><strong>${String(assistant?.runCount ?? 0)}</strong></article>`,
+    `<article><span>Sessions</span><strong>${String(assistant?.sessions ?? 0)}</strong></article>`,
+    `<article><span>Guardrails</span><strong>${String(assistant?.guardrailCount ?? 0)}</strong></article>`,
+    `<article><span>Avg latency</span><strong>${String(assistant?.averageElapsedMs ?? 0)}ms</strong></article>`,
+    "</section>",
+    "<section>",
+    "<h3>Provider Health</h3>",
+    renderVoiceProviderHealthHTML(summary.providerHealth),
+    "</section>",
+    '<section class="voice-assistant-health-columns">',
+    `<article><h3>Outcomes</h3>${renderCountMap(assistant?.outcomes ?? {})}</article>`,
+    `<article><h3>Variants</h3>${renderCountMap(assistant?.variants ?? {})}</article>`,
+    `<article><h3>Tools</h3>${renderCountMap(assistant?.toolCalls ?? {})}</article>`,
+    `<article><h3>Artifact Plans</h3>${renderCountMap(assistant?.artifactPlans ?? {})}</article>`,
+    "</section>",
+    "<section>",
+    "<h3>Recent Failures</h3>",
+    failures.length === 0 ? '<p class="voice-assistant-health-empty">No failures yet.</p>' : [
+      '<div class="voice-assistant-health-failures">',
+      ...failures.map((failure) => [
+        "<article>",
+        `<strong>${escapeHtml4(failure.provider ?? failure.assistantId ?? failure.type)}</strong>`,
+        `<span>${escapeHtml4(failure.status ?? (failure.rateLimited ? "rate-limited" : "error"))}</span>`,
+        failure.error ? `<p>${escapeHtml4(failure.error)}</p>` : "",
+        `<small>${escapeHtml4(failure.sessionId)}${failure.turnId ? ` / ${escapeHtml4(failure.turnId)}` : ""}</small>`,
+        failure.replayHref ? `<p><a href="${escapeHtml4(failure.replayHref)}">Open replay</a></p>` : "",
+        "</article>"
+      ].join("")),
+      "</div>"
+    ].join(""),
+    "</section>",
+    "</div>"
+  ].join("");
+};
+var createVoiceAssistantHealthJSONHandler = (options) => async () => summarizeVoiceAssistantHealth(options);
+var createVoiceAssistantHealthHTMLHandler = (options) => async () => {
+  const summary = await summarizeVoiceAssistantHealth(options);
+  const render = options.render ?? renderVoiceAssistantHealthHTML;
+  const body = await render(summary);
+  return new Response(body, {
+    headers: {
+      "Content-Type": "text/html; charset=utf-8",
+      ...options.headers
+    }
+  });
+};
+var createVoiceAssistantHealthRoutes = (options) => {
+  const path = options.path ?? "/api/assistant-health";
+  const htmlPath = options.htmlPath === undefined ? `${path}/htmx` : options.htmlPath;
+  const routes = new Elysia3({
+    name: options.name ?? "absolutejs-voice-assistant-health"
+  }).get(path, createVoiceAssistantHealthJSONHandler(options));
+  if (htmlPath) {
+    routes.get(htmlPath, createVoiceAssistantHealthHTMLHandler(options));
+  }
+  return routes;
+};
+// src/sessionReplay.ts
+import { Elysia as Elysia4 } from "elysia";
 
 // src/trace.ts
 var createVoiceTraceEventId = (event) => [
@@ -6079,7 +6730,7 @@ var exportVoiceTrace = async (input) => {
   };
 };
 var toNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
-var escapeHtml3 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var escapeHtml5 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 var formatTraceValue = (value) => {
   if (value === undefined || value === null) {
     return "";
@@ -6357,10 +7008,10 @@ var renderVoiceTraceHTML = (events, options = {}) => {
     const offset = summary.startedAt === undefined ? event.at : Math.max(0, event.at - summary.startedAt);
     return [
       "<tr>",
-      `<td>${escapeHtml3(String(offset))}</td>`,
-      `<td>${escapeHtml3(event.type)}</td>`,
-      `<td>${escapeHtml3(event.turnId ?? "")}</td>`,
-      `<td><code>${escapeHtml3(JSON.stringify(event.payload))}</code></td>`,
+      `<td>${escapeHtml5(String(offset))}</td>`,
+      `<td>${escapeHtml5(event.type)}</td>`,
+      `<td>${escapeHtml5(event.turnId ?? "")}</td>`,
+      `<td><code>${escapeHtml5(JSON.stringify(event.payload))}</code></td>`,
       "</tr>"
     ].join("");
   }).join(`
@@ -6371,7 +7022,7 @@ var renderVoiceTraceHTML = (events, options = {}) => {
     "<head>",
     '<meta charset="utf-8" />',
     '<meta name="viewport" content="width=device-width, initial-scale=1" />',
-    `<title>${escapeHtml3(options.title ?? "Voice Trace")}</title>`,
+    `<title>${escapeHtml5(options.title ?? "Voice Trace")}</title>`,
     "<style>",
     "body{font-family:ui-sans-serif,system-ui,sans-serif;margin:2rem;line-height:1.45;background:#f8f7f2;color:#181713}",
     "main{max-width:1100px;margin:auto}",
@@ -6385,7 +7036,7 @@ var renderVoiceTraceHTML = (events, options = {}) => {
     "</style>",
     "</head>",
     "<body><main>",
-    `<h1>${escapeHtml3(options.title ?? `Voice Trace ${summary.sessionId ?? ""}`.trim())}</h1>`,
+    `<h1>${escapeHtml5(options.title ?? `Voice Trace ${summary.sessionId ?? ""}`.trim())}</h1>`,
     `<p class="${evaluation.pass ? "pass" : "fail"}">QA: ${evaluation.pass ? "pass" : "fail"}</p>`,
     '<section class="summary">',
     `<div class="card"><strong>Events</strong><br>${summary.eventCount}</div>`,
@@ -6399,7 +7050,7 @@ var renderVoiceTraceHTML = (events, options = {}) => {
     eventRows,
     "</tbody></table>",
     "<h2>Markdown Export</h2>",
-    `<pre>${escapeHtml3(markdown)}</pre>`,
+    `<pre>${escapeHtml5(markdown)}</pre>`,
     "</main></body></html>"
   ].join(`
 `);
@@ -6411,7 +7062,119 @@ var buildVoiceTraceReplay = (events, options = {}) => ({
   summary: summarizeVoiceTrace(options.redact ? redactVoiceTraceEvents(events, options.redact) : events)
 });
 
+// src/sessionReplay.ts
+var getString3 = (value) => typeof value === "string" ? value : undefined;
+var buildReplayTurns = (events) => {
+  const turns = new Map;
+  const getTurn = (turnId) => {
+    const existing = turns.get(turnId);
+    if (existing) {
+      return existing;
+    }
+    const turn = {
+      assistantReplies: [],
+      errors: [],
+      id: turnId,
+      modelCalls: [],
+      tools: [],
+      transcripts: []
+    };
+    turns.set(turnId, turn);
+    return turn;
+  };
+  for (const event of events) {
+    const turnId = event.turnId ?? "session";
+    const turn = getTurn(turnId);
+    switch (event.type) {
+      case "turn.transcript":
+        turn.transcripts.push({
+          isFinal: event.payload.isFinal === true,
+          text: getString3(event.payload.text)
+        });
+        break;
+      case "turn.committed":
+        turn.committedText = getString3(event.payload.text);
+        break;
+      case "turn.assistant": {
+        const text = getString3(event.payload.text);
+        if (text) {
+          turn.assistantReplies.push(text);
+        }
+        break;
+      }
+      case "agent.model":
+      case "assistant.run":
+        turn.modelCalls.push(event.payload);
+        break;
+      case "agent.tool":
+        turn.tools.push(event.payload);
+        break;
+      case "session.error":
+        turn.errors.push(event.payload);
+        break;
+    }
+  }
+  return [...turns.values()];
+};
+var summarizeVoiceSessionReplay = async (options) => {
+  const sourceEvents = options.events ?? await options.store?.list({ sessionId: options.sessionId }) ?? [];
+  const events = filterVoiceTraceEvents(sourceEvents, {
+    sessionId: options.sessionId
+  });
+  const replay = buildVoiceTraceReplay(events, {
+    evaluation: options.evaluation,
+    redact: options.redact,
+    title: options.title ?? `Voice Session ${options.sessionId}`
+  });
+  const startedAt = replay.summary.startedAt;
+  return {
+    evaluation: replay.evaluation,
+    events,
+    html: replay.html,
+    markdown: replay.markdown,
+    sessionId: options.sessionId,
+    summary: replay.summary,
+    timeline: events.map((event) => ({
+      at: event.at,
+      offsetMs: startedAt === undefined ? undefined : Math.max(0, event.at - startedAt),
+      payload: event.payload,
+      turnId: event.turnId,
+      type: event.type
+    })),
+    turns: buildReplayTurns(events)
+  };
+};
+var createVoiceSessionReplayJSONHandler = (options) => async ({ params }) => summarizeVoiceSessionReplay({
+  ...options,
+  sessionId: params.sessionId ?? ""
+});
+var createVoiceSessionReplayHTMLHandler = (options) => async ({ params }) => {
+  const replay = await summarizeVoiceSessionReplay({
+    ...options,
+    sessionId: params.sessionId ?? ""
+  });
+  const body = await (options.render?.(replay) ?? replay.html);
+  return new Response(body, {
+    headers: {
+      "Content-Type": "text/html; charset=utf-8",
+      ...options.headers
+    }
+  });
+};
+var createVoiceSessionReplayRoutes = (options) => {
+  const path = options.path ?? "/api/voice-sessions/:sessionId/replay";
+  const htmlPath = options.htmlPath === undefined ? `${path}/htmx` : options.htmlPath;
+  const routes = new Elysia4({
+    name: options.name ?? "absolutejs-voice-session-replay"
+  }).get(path, createVoiceSessionReplayJSONHandler(options));
+  if (htmlPath) {
+    routes.get(htmlPath, createVoiceSessionReplayHTMLHandler(options));
+  }
+  return routes;
+};
 // src/fileStore.ts
+import { mkdir, readFile, readdir, rename, rm, writeFile } from "fs/promises";
+import { join } from "path";
 var listJsonFiles = async (directory) => {
   try {
     const entries = await readdir(directory, {
@@ -6427,6 +7190,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, {
@@ -6646,18 +7410,56 @@ var createVoiceFileTraceSinkDeliveryStore = (options) => {
   };
   return { get, list, remove, set };
 };
-var createVoiceFileRuntimeStorage = (options) => ({
-  events: createVoiceFileIntegrationEventStore({
-    ...options,
-    directory: join(options.directory, "events")
-  }),
-  externalObjects: createVoiceFileExternalObjectMapStore({
-    ...options,
-    directory: join(options.directory, "external-objects")
-  }),
-  reviews: createVoiceFileReviewStore({
-    ...options,
-    directory: join(options.directory, "reviews")
+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,
+    directory: join(options.directory, "events")
+  }),
+  externalObjects: createVoiceFileExternalObjectMapStore({
+    ...options,
+    directory: join(options.directory, "external-objects")
+  }),
+  memories: createVoiceFileAssistantMemoryStore({
+    ...options,
+    directory: join(options.directory, "memories")
+  }),
+  reviews: createVoiceFileReviewStore({
+    ...options,
+    directory: join(options.directory, "reviews")
   }),
   session: createVoiceFileSessionStore({
     ...options,
@@ -6687,6 +7489,777 @@ 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 policy = typeof options.policy === "string" ? {
+    strategy: options.policy
+  } : options.policy;
+  const strategy = policy?.strategy ?? "prefer-selected";
+  const fallbackMode = policy?.fallbackMode ?? options.fallbackMode ?? "provider-error";
+  const healthOptions = typeof options.providerHealth === "object" ? options.providerHealth : options.providerHealth ? {} : undefined;
+  const healthState = new Map;
+  const now = () => healthOptions?.now?.() ?? Date.now();
+  const failureThreshold = Math.max(1, healthOptions?.failureThreshold ?? 1);
+  const cooldownMs = Math.max(0, healthOptions?.cooldownMs ?? 30000);
+  const rateLimitCooldownMs = Math.max(0, healthOptions?.rateLimitCooldownMs ?? 60000);
+  const getHealth = (provider) => {
+    const existing = healthState.get(provider);
+    if (existing) {
+      return existing;
+    }
+    const next = {
+      consecutiveFailures: 0,
+      provider,
+      status: "healthy"
+    };
+    healthState.set(provider, next);
+    return next;
+  };
+  const cloneHealth = (provider) => {
+    if (!healthOptions) {
+      return;
+    }
+    return {
+      ...getHealth(provider)
+    };
+  };
+  const getSuppressionRemainingMs = (provider) => {
+    if (!healthOptions) {
+      return;
+    }
+    const suppressedUntil = getHealth(provider).suppressedUntil;
+    return typeof suppressedUntil === "number" ? Math.max(0, suppressedUntil - now()) : undefined;
+  };
+  const isSuppressed = (provider) => {
+    if (!healthOptions) {
+      return false;
+    }
+    const health = getHealth(provider);
+    return typeof health.suppressedUntil === "number" && health.suppressedUntil > now();
+  };
+  const recordProviderSuccess = (provider) => {
+    if (!healthOptions) {
+      return;
+    }
+    const health = getHealth(provider);
+    health.consecutiveFailures = 0;
+    health.status = "healthy";
+    health.suppressedUntil = undefined;
+    return cloneHealth(provider);
+  };
+  const recordProviderError = (provider, isProviderError, rateLimited) => {
+    if (!healthOptions || !isProviderError) {
+      return cloneHealth(provider);
+    }
+    const currentTime = now();
+    const health = getHealth(provider);
+    health.consecutiveFailures += 1;
+    health.lastFailureAt = currentTime;
+    if (rateLimited) {
+      health.lastRateLimitedAt = currentTime;
+    }
+    if (rateLimited || health.consecutiveFailures >= failureThreshold) {
+      health.status = "suppressed";
+      health.suppressedUntil = currentTime + (rateLimited ? rateLimitCooldownMs : cooldownMs);
+    }
+    return cloneHealth(provider);
+  };
+  const resolveAllowedProviders = async (input) => {
+    const allowProviders = policy?.allowProviders ?? options.allowProviders;
+    const allowed = typeof allowProviders === "function" ? await allowProviders(input) : allowProviders;
+    return new Set(allowed ?? providerIds);
+  };
+  const sortProviders = (providers) => {
+    if (strategy !== "prefer-cheapest" && strategy !== "prefer-fastest") {
+      return providers;
+    }
+    return [...providers].sort((left, right) => {
+      const leftProfile = options.providerProfiles?.[left];
+      const rightProfile = options.providerProfiles?.[right];
+      const leftValue = strategy === "prefer-cheapest" ? leftProfile?.cost ?? Number.MAX_SAFE_INTEGER : leftProfile?.latencyMs ?? Number.MAX_SAFE_INTEGER;
+      const rightValue = strategy === "prefer-cheapest" ? rightProfile?.cost ?? Number.MAX_SAFE_INTEGER : rightProfile?.latencyMs ?? Number.MAX_SAFE_INTEGER;
+      return leftValue - rightValue || (leftProfile?.priority ?? Number.MAX_SAFE_INTEGER) - (rightProfile?.priority ?? Number.MAX_SAFE_INTEGER);
+    });
+  };
+  const resolveOrder = async (input) => {
+    const selectedProvider = await options.selectProvider?.(input);
+    const allowedProviders = await resolveAllowedProviders(input);
+    const fallbackOrder = typeof options.fallback === "function" ? await options.fallback(input) : options.fallback;
+    const rankedProviders = sortProviders([
+      ...fallbackOrder ?? providerIds
+    ]).filter((provider) => allowedProviders.has(provider));
+    const healthyRankedProviders = healthOptions ? rankedProviders.filter((provider) => !isSuppressed(provider)) : rankedProviders;
+    const candidateRankedProviders = healthyRankedProviders.length ? healthyRankedProviders : rankedProviders;
+    const preferred = selectedProvider && allowedProviders.has(selectedProvider) && (!healthOptions || !isSuppressed(selectedProvider)) ? selectedProvider : candidateRankedProviders[0] ?? firstProvider;
+    const seen = new Set;
+    const order = [];
+    const candidates = strategy === "ordered" ? candidateRankedProviders : [
+      preferred,
+      ...candidateRankedProviders,
+      ...providerIds.filter((provider) => !healthOptions || !isSuppressed(provider))
+    ];
+    for (const provider of candidates) {
+      if (!provider || seen.has(provider) || !allowedProviders.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);
+          const providerHealth = recordProviderSuccess(provider);
+          await emit({
+            at: Date.now(),
+            elapsedMs: Date.now() - startedAt,
+            fallbackProvider: provider === selectedProvider ? undefined : provider,
+            provider,
+            providerHealth,
+            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 rateLimited = options.isRateLimitError?.(error, provider) ?? defaultIsRateLimitError(error);
+          const shouldFallback = fallbackMode === "provider-error" ? isProviderError : fallbackMode === "rate-limit" ? isProviderError && rateLimited : false;
+          const providerHealth = recordProviderError(provider, isProviderError, rateLimited);
+          const nextProvider = hasNextProvider ? order[index + 1] : undefined;
+          await emit({
+            at: Date.now(),
+            elapsedMs: Date.now() - startedAt,
+            error: errorMessage(error),
+            fallbackProvider: shouldFallback ? nextProvider : undefined,
+            provider,
+            providerHealth,
+            rateLimited,
+            selectedProvider,
+            suppressionRemainingMs: getSuppressionRemainingMs(provider),
+            suppressedUntil: providerHealth?.suppressedUntil,
+            status: "error"
+          }, input);
+          if (!hasNextProvider || !shouldFallback) {
+            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";
@@ -7884,10 +9457,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, {
@@ -9137,10 +10710,14 @@ export {
   transcodePCMToTwilioOutboundPayload,
   summarizeVoiceTraceSinkDeliveries,
   summarizeVoiceTrace,
+  summarizeVoiceSessionReplay,
+  summarizeVoiceProviderHealth,
   summarizeVoiceOpsTasks,
   summarizeVoiceOpsTaskQueue,
   summarizeVoiceOpsTaskAnalytics,
   summarizeVoiceIntegrationEvents,
+  summarizeVoiceAssistantRuns,
+  summarizeVoiceAssistantHealth,
   startVoiceOpsTask,
   shapeTelephonyAssistantText,
   selectVoiceTraceEventsForPrune,
@@ -9152,14 +10729,17 @@ export {
   resolveVoiceOpsTaskAssignment,
   resolveVoiceOpsTaskAgeBucket,
   resolveVoiceOpsPreset,
+  resolveVoiceAssistantMemoryNamespace,
   resolveTurnDetectionConfig,
   resolveAudioConditioningConfig,
   requeueVoiceOpsTask,
   reopenVoiceOpsTask,
   renderVoiceTraceMarkdown,
   renderVoiceTraceHTML,
+  renderVoiceProviderHealthHTML,
   renderVoiceCallReviewMarkdown,
   renderVoiceCallReviewHTML,
+  renderVoiceAssistantHealthHTML,
   redactVoiceTraceText,
   redactVoiceTraceEvents,
   redactVoiceTraceEvent,
@@ -9197,6 +10777,9 @@ export {
   createVoiceTaskUpdatedEvent,
   createVoiceTaskSLABreachedEvent,
   createVoiceTaskCreatedEvent,
+  createVoiceSessionReplayRoutes,
+  createVoiceSessionReplayJSONHandler,
+  createVoiceSessionReplayHTMLHandler,
   createVoiceSessionRecord,
   createVoiceSession,
   createVoiceSTTRoutingCorrectionHandler,
@@ -9212,6 +10795,10 @@ export {
   createVoiceReviewSavedEvent,
   createVoiceRedisTaskLeaseCoordinator,
   createVoiceRedisIdempotencyStore,
+  createVoiceProviderRouter,
+  createVoiceProviderHealthRoutes,
+  createVoiceProviderHealthJSONHandler,
+  createVoiceProviderHealthHTMLHandler,
   createVoicePostgresTraceSinkDeliveryStore,
   createVoicePostgresTraceEventStore,
   createVoicePostgresTaskStore,
@@ -9227,6 +10814,7 @@ export {
   createVoiceMemoryTraceSinkDeliveryStore,
   createVoiceMemoryTraceEventStore,
   createVoiceMemoryStore,
+  createVoiceMemoryAssistantMemoryStore,
   createVoiceLinearIssueUpdateSink,
   createVoiceLinearIssueSyncSinks,
   createVoiceLinearIssueSink,
@@ -9246,6 +10834,7 @@ export {
   createVoiceFileReviewStore,
   createVoiceFileIntegrationEventStore,
   createVoiceFileExternalObjectMapStore,
+  createVoiceFileAssistantMemoryStore,
   createVoiceExternalObjectMapId,
   createVoiceExternalObjectMap,
   createVoiceExperiment,
@@ -9254,6 +10843,11 @@ export {
   createVoiceCallReviewFromLiveTelephonyReport,
   createVoiceCallCompletedEvent,
   createVoiceCRMActivitySink,
+  createVoiceAssistantMemoryRecord,
+  createVoiceAssistantMemoryHandle,
+  createVoiceAssistantHealthRoutes,
+  createVoiceAssistantHealthJSONHandler,
+  createVoiceAssistantHealthHTMLHandler,
   createVoiceAssistant,
   createVoiceAgentTool,
   createVoiceAgentSquad,
@@ -9266,9 +10860,13 @@ export {
   createStoredVoiceCallReviewArtifact,
   createRiskyTurnCorrectionHandler,
   createPhraseHintCorrectionHandler,
+  createOpenAIVoiceAssistantModel,
+  createJSONVoiceAssistantModel,
   createId,
+  createGeminiVoiceAssistantModel,
   createDomainPhraseHints,
   createDomainLexicon,
+  createAnthropicVoiceAssistantModel,
   conditionAudioChunk,
   completeVoiceOpsTask,
   claimVoiceOpsTask,