@absolutejs/voice 0.0.22-beta.35 → 0.0.22-beta.37

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export { createStoredVoiceCallReviewArtifact, createStoredVoiceExternalObjectMap
 export { createVoiceAssistantMemoryHandle, createVoiceAssistantMemoryRecord, createVoiceMemoryAssistantMemoryStore, resolveVoiceAssistantMemoryNamespace } from './assistantMemory';
 export { createAnthropicVoiceAssistantModel, createGeminiVoiceAssistantModel, createJSONVoiceAssistantModel, createOpenAIVoiceAssistantModel, createVoiceProviderRouter } from './modelAdapters';
 export { createVoiceProviderHealthHTMLHandler, createVoiceProviderHealthJSONHandler, createVoiceProviderHealthRoutes, renderVoiceProviderHealthHTML, summarizeVoiceProviderHealth } from './providerHealth';
+export { createVoiceResilienceRoutes, listVoiceRoutingEvents, renderVoiceResilienceHTML } from './resilienceRoutes';
 export { createVoiceSTTProviderRouter, createVoiceTTSProviderRouter } from './providerAdapters';
 export { buildVoiceTraceReplay, createVoiceMemoryTraceSinkDeliveryStore, createVoiceTraceHTTPSink, createVoiceMemoryTraceEventStore, createVoiceTraceSinkDeliveryId, createVoiceTraceSinkDeliveryRecord, createVoiceTraceSinkStore, createVoiceTraceEvent, createVoiceTraceEventId, deliverVoiceTraceEventsToSinks, evaluateVoiceTrace, exportVoiceTrace, filterVoiceTraceEvents, pruneVoiceTraceEvents, redactVoiceTraceEvent, redactVoiceTraceEvents, redactVoiceTraceText, renderVoiceTraceHTML, renderVoiceTraceMarkdown, resolveVoiceTraceRedactionOptions, selectVoiceTraceEventsForPrune, summarizeVoiceTrace } from './trace';
 export { createVoiceSQLiteExternalObjectMapStore, createVoiceSQLiteIntegrationEventStore, createVoiceSQLiteReviewStore, createVoiceSQLiteRuntimeStorage, createVoiceSQLiteSessionStore, createVoiceSQLiteTaskStore, createVoiceSQLiteTraceSinkDeliveryStore, createVoiceSQLiteTraceEventStore } from './sqliteStore';
@@ -37,6 +38,7 @@ export type { VoiceAssistantMemoryBinding, VoiceAssistantMemoryHandle, VoiceAssi
 export type { VoiceSessionListHTMLHandlerOptions, VoiceSessionListItem, VoiceSessionListOptions, VoiceSessionListRoutesOptions, VoiceSessionListStatus, VoiceSessionReplay, VoiceSessionReplayHTMLHandlerOptions, VoiceSessionReplayOptions, VoiceSessionReplayRoutesOptions, VoiceSessionReplayTurn } from './sessionReplay';
 export type { AnthropicVoiceAssistantModelOptions, GeminiVoiceAssistantModelOptions, OpenAIVoiceAssistantModelOptions, VoiceProviderRouterEvent, VoiceProviderRouterFallbackMode, VoiceProviderRouterHealthOptions, VoiceProviderRouterOptions, VoiceProviderRouterPolicy, VoiceProviderRouterProviderHealth, VoiceProviderRouterProviderProfile, VoiceJSONAssistantModelHandler, VoiceJSONAssistantModelOptions } from './modelAdapters';
 export type { VoiceProviderHealthStatus, VoiceProviderHealthSummary, VoiceProviderHealthSummaryOptions } from './providerHealth';
+export type { VoiceResilienceIOSimulator, VoiceResilienceLink, VoiceResiliencePageData, VoiceResilienceRoutesOptions, VoiceResilienceSimulationProvider, VoiceRoutingEvent, VoiceRoutingEventKind } from './resilienceRoutes';
 export type { VoiceIOProviderRouterEvent, VoiceSTTProviderRouterOptions, VoiceTTSProviderRouterOptions } from './providerAdapters';
 export type { VoiceAgent, VoiceAgentMessage, VoiceAgentMessageRole, VoiceAgentModel, VoiceAgentModelInput, VoiceAgentModelOutput, VoiceAgentOptions, VoiceAgentRunResult, VoiceAgentSquadOptions, VoiceAgentTool, VoiceAgentToolCall, VoiceAgentToolResult } from './agent';
 export type { VoiceOpsRuntime, VoiceOpsRuntimeConfig, VoiceOpsRuntimeSummary, VoiceOpsRuntimeSinkWorkerConfig, VoiceOpsRuntimeTaskWorkerConfig, VoiceOpsRuntimeTickResult, VoiceOpsRuntimeWebhookWorkerConfig } from './opsRuntime';

package/dist/index.js

@@ -8858,6 +8858,319 @@ var createGeminiVoiceAssistantModel = (options) => {
     }
   };
 };
+// src/resilienceRoutes.ts
+import { Elysia as Elysia5 } from "elysia";
+var escapeHtml7 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var getString4 = (value) => typeof value === "string" ? value : undefined;
+var getNumber2 = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+var getBoolean = (value) => value === true;
+var isProviderStatus2 = (value) => value === "error" || value === "fallback" || value === "success";
+var listVoiceRoutingEvents = (events) => {
+  const routingEvents = [];
+  for (const event of events) {
+    if (event.type !== "session.error") {
+      continue;
+    }
+    const provider = getString4(event.payload.provider);
+    const providerStatus = isProviderStatus2(event.payload.providerStatus) ? event.payload.providerStatus : undefined;
+    if (!provider || !providerStatus) {
+      continue;
+    }
+    const kind = getString4(event.payload.kind);
+    routingEvents.push({
+      at: event.at,
+      attempt: getNumber2(event.payload.attempt),
+      elapsedMs: getNumber2(event.payload.elapsedMs),
+      error: getString4(event.payload.error),
+      fallbackProvider: getString4(event.payload.fallbackProvider),
+      kind: kind === "stt" || kind === "tts" ? kind : "llm",
+      latencyBudgetMs: getNumber2(event.payload.latencyBudgetMs),
+      operation: getString4(event.payload.operation),
+      provider,
+      selectedProvider: getString4(event.payload.selectedProvider),
+      sessionId: event.sessionId,
+      status: providerStatus,
+      timedOut: getBoolean(event.payload.timedOut),
+      turnId: event.turnId
+    });
+  }
+  return routingEvents.sort((left, right) => right.at - left.at);
+};
+var summarizeRoutingEvents = (events) => {
+  const byKind = new Map;
+  let errors = 0;
+  let fallbacks = 0;
+  let timeouts = 0;
+  for (const event of events) {
+    byKind.set(event.kind, (byKind.get(event.kind) ?? 0) + 1);
+    if (event.status === "error") {
+      errors += 1;
+    }
+    if (event.status === "fallback") {
+      fallbacks += 1;
+    }
+    if (event.timedOut) {
+      timeouts += 1;
+    }
+  }
+  return {
+    byKind,
+    errors,
+    fallbacks,
+    timeouts,
+    total: events.length
+  };
+};
+var renderProviderCards = (title, providers) => {
+  if (providers.length === 0) {
+    return `<p class="muted">No ${escapeHtml7(title)} provider health yet.</p>`;
+  }
+  return `<div class="provider-grid">${providers.map((provider) => `
+        <article class="card provider ${escapeHtml7(provider.status)}">
+          <div class="card-header">
+            <strong>${escapeHtml7(provider.provider)}</strong>
+            <span>${escapeHtml7(provider.status)}${provider.recommended ? " \xB7 recommended" : ""}</span>
+          </div>
+          <dl>
+            <div><dt>Runs</dt><dd>${provider.runCount}</dd></div>
+            <div><dt>Avg latency</dt><dd>${provider.averageElapsedMs ?? 0}ms</dd></div>
+            <div><dt>Errors</dt><dd>${provider.errorCount}</dd></div>
+            <div><dt>Timeouts</dt><dd>${provider.timeoutCount}</dd></div>
+            <div><dt>Fallbacks</dt><dd>${provider.fallbackCount}</dd></div>
+          </dl>
+          ${provider.lastError ? `<p class="muted">${escapeHtml7(provider.lastError)}</p>` : ""}
+        </article>
+      `).join("")}</div>`;
+};
+var renderTimeline2 = (events) => {
+  if (events.length === 0) {
+    return '<p class="muted">No provider routing events yet. Run the app or simulate provider failover.</p>';
+  }
+  return `<div class="timeline">${events.slice(0, 40).map((event) => `
+        <article class="card event ${escapeHtml7(event.status ?? "unknown")}">
+          <div class="card-header">
+            <strong>${escapeHtml7(event.kind.toUpperCase())} ${escapeHtml7(event.operation ?? "generate")}</strong>
+            <span>${new Date(event.at).toLocaleString()}</span>
+          </div>
+          <p>
+            <span class="pill">${escapeHtml7(event.status ?? "unknown")}</span>
+            <span class="pill">provider: ${escapeHtml7(event.provider ?? "unknown")}</span>
+            ${event.fallbackProvider ? `<span class="pill">fallback: ${escapeHtml7(event.fallbackProvider)}</span>` : ""}
+            ${event.timedOut ? '<span class="pill danger">timed out</span>' : ""}
+          </p>
+          <dl>
+            <div><dt>Attempt</dt><dd>${event.attempt ?? 0}</dd></div>
+            <div><dt>Elapsed</dt><dd>${event.elapsedMs ?? 0}ms</dd></div>
+            <div><dt>Budget</dt><dd>${event.latencyBudgetMs ?? 0}ms</dd></div>
+            <div><dt>Session</dt><dd>${escapeHtml7(event.sessionId)}</dd></div>
+          </dl>
+          ${event.error ? `<p class="muted">${escapeHtml7(event.error)}</p>` : ""}
+        </article>
+      `).join("")}</div>`;
+};
+var renderSimulationControls = (kind, simulation) => {
+  if (!simulation) {
+    return "";
+  }
+  const configuredProviders = simulation.providers.filter((provider) => provider.configured !== false);
+  if (configuredProviders.length === 0) {
+    return `<p class="muted">No ${kind.toUpperCase()} providers are configured for simulation.</p>`;
+  }
+  const pathPrefix = simulation.pathPrefix ?? `/api/${kind}-simulate`;
+  const failureProviders = simulation.failureProviders ?? configuredProviders.map(({ provider }) => provider);
+  const canFail = (provider) => configuredProviders.some((entry) => entry.provider === provider) && (!simulation.fallbackRequiredProvider || configuredProviders.some((entry) => entry.provider === simulation.fallbackRequiredProvider));
+  return `<div class="simulate-panel" data-sim-kind="${kind}" data-sim-prefix="${escapeHtml7(pathPrefix)}">
+    <p class="muted">${escapeHtml7(simulation.failureMessage ?? `Simulate ${kind.toUpperCase()} provider failure without changing provider credentials.`)}</p>
+    <div class="simulate-actions">
+      ${failureProviders.map((provider) => `<button type="button" data-provider-fail="${escapeHtml7(provider)}"${canFail(provider) ? "" : " disabled"}>Simulate ${escapeHtml7(provider)} ${kind.toUpperCase()} failure</button>`).join("")}
+      ${configuredProviders.map((provider) => `<button type="button" data-provider-recover="${escapeHtml7(provider.provider)}">Mark ${escapeHtml7(provider.provider)} recovered</button>`).join("")}
+    </div>
+    ${simulation.fallbackRequiredProvider && !configuredProviders.some((entry) => entry.provider === simulation.fallbackRequiredProvider) ? `<p class="muted">${escapeHtml7(simulation.fallbackRequiredMessage ?? `Configure ${simulation.fallbackRequiredProvider} to enable fallback simulation.`)}</p>` : ""}
+    <pre class="simulate-output" hidden></pre>
+  </div>`;
+};
+var renderVoiceResilienceHTML = (input) => {
+  const summary = summarizeRoutingEvents(input.routingEvents);
+  const kindCounts = [...summary.byKind.entries()].map(([kind, count]) => `<span class="pill">${escapeHtml7(kind)}: ${String(count)}</span>`).join("");
+  const links = input.links?.length ? input.links.map((link) => `<a href="${escapeHtml7(link.href)}">${escapeHtml7(link.label)}</a>`).join(" \xB7 ") : "";
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${escapeHtml7(input.title ?? "AbsoluteJS Voice Resilience")}</title>
+  <style>
+    :root { color-scheme: dark; }
+    body { background: radial-gradient(circle at top left, #172554, #09090b 36%, #050505); color: #f4f4f5; font-family: ui-sans-serif, system-ui, sans-serif; margin: 0; padding: 24px; }
+    main { display: grid; gap: 16px; margin: 0 auto; max-width: 1180px; }
+    section, .card { background: rgba(19, 22, 27, 0.92); border: 1px solid #27272a; border-radius: 20px; padding: 20px; }
+    .hero { background: linear-gradient(135deg, rgba(14, 165, 233, 0.18), rgba(245, 158, 11, 0.12)); }
+    .grid, .provider-grid { display: grid; gap: 14px; grid-template-columns: repeat(4, minmax(0, 1fr)); }
+    .timeline { display: grid; gap: 12px; }
+    .card-header { align-items: center; display: flex; gap: 12px; justify-content: space-between; }
+    .card-header strong { font-size: 1.05rem; }
+    .metric strong { display: block; font-size: 2rem; margin-top: 6px; }
+    .muted, dt, span { color: #a1a1aa; }
+    dl { display: grid; gap: 8px; grid-template-columns: repeat(4, minmax(0, 1fr)); }
+    dl div { background: #0f1217; border: 1px solid #27272a; border-radius: 12px; padding: 10px; }
+    dd { font-weight: 800; margin: 4px 0 0; }
+    .pill { background: #0f1217; border: 1px solid #3f3f46; border-radius: 999px; color: #d4d4d8; display: inline-flex; margin: 3px 4px 3px 0; padding: 5px 9px; }
+    .danger { border-color: rgba(239, 68, 68, 0.75); color: #fecaca; }
+    .event.error { border-color: rgba(239, 68, 68, 0.7); }
+    .event.fallback { border-color: rgba(245, 158, 11, 0.7); }
+    .event.success, .provider.healthy { border-color: rgba(34, 197, 94, 0.5); }
+    .provider.suppressed, .provider.degraded, .provider.rate-limited { border-color: rgba(239, 68, 68, 0.7); }
+    .provider.recoverable { border-color: rgba(59, 130, 246, 0.7); }
+    button { background: #f59e0b; border: 0; border-radius: 999px; color: #111827; cursor: pointer; font-weight: 800; padding: 10px 14px; }
+    button:disabled { cursor: not-allowed; opacity: 0.45; }
+    .simulate-actions { display: flex; flex-wrap: wrap; gap: 10px; margin-top: 12px; }
+    .simulate-output { background: #050505; border: 1px solid #27272a; border-radius: 14px; color: #d4d4d8; overflow: auto; padding: 12px; white-space: pre-wrap; }
+    a { color: #f59e0b; }
+    @media (max-width: 850px) { .grid, .provider-grid, dl { grid-template-columns: 1fr; } }
+  </style>
+</head>
+<body>
+  <main>
+    <section class="hero">
+      <h1>Provider routing and resilience</h1>
+      <p>One view for the production reliability story: LLM failover, STT/TTS routing, latency budgets, timeouts, and fallback decisions.</p>
+      ${links ? `<p>${links}</p>` : ""}
+      <p>${kindCounts || '<span class="pill">No routing events yet</span>'}</p>
+    </section>
+    <section class="grid">
+      <article class="card metric"><span>Total routing events</span><strong>${summary.total}</strong></article>
+      <article class="card metric"><span>Fallbacks</span><strong>${summary.fallbacks}</strong></article>
+      <article class="card metric"><span>Errors</span><strong>${summary.errors}</strong></article>
+      <article class="card metric"><span>Timeouts</span><strong>${summary.timeouts}</strong></article>
+    </section>
+    <section>
+      <h2>LLM provider health</h2>
+      ${renderProviderCards("LLM", input.llmProviderHealth)}
+    </section>
+    <section>
+      <h2>STT provider health</h2>
+      ${renderSimulationControls("stt", input.sttSimulation)}
+      ${renderProviderCards("STT", input.sttProviderHealth)}
+    </section>
+    <section>
+      <h2>TTS provider health</h2>
+      ${renderSimulationControls("tts", input.ttsSimulation)}
+      ${renderProviderCards("TTS", input.ttsProviderHealth)}
+    </section>
+    <section>
+      <h2>Routing timeline</h2>
+      ${renderTimeline2(input.routingEvents)}
+    </section>
+  </main>
+  <script>
+    const showResult = (panel, result) => {
+      const output = panel.querySelector(".simulate-output");
+      if (!output) return;
+      output.hidden = false;
+      output.textContent = JSON.stringify(result, null, 2);
+    };
+    document.querySelectorAll("[data-sim-prefix]").forEach((panel) => {
+      const prefix = panel.getAttribute("data-sim-prefix");
+      panel.querySelectorAll("[data-provider-fail]").forEach((button) => {
+        button.addEventListener("click", async () => {
+          const provider = button.getAttribute("data-provider-fail");
+          const response = await fetch(prefix + "/failure?provider=" + encodeURIComponent(provider || ""), { method: "POST" });
+          showResult(panel, await response.json());
+          if (response.ok) window.setTimeout(() => window.location.reload(), 450);
+        });
+      });
+      panel.querySelectorAll("[data-provider-recover]").forEach((button) => {
+        button.addEventListener("click", async () => {
+          const provider = button.getAttribute("data-provider-recover");
+          const response = await fetch(prefix + "/recovery?provider=" + encodeURIComponent(provider || ""), { method: "POST" });
+          showResult(panel, await response.json());
+          if (response.ok) window.setTimeout(() => window.location.reload(), 450);
+        });
+      });
+    });
+  </script>
+</body>
+</html>`;
+};
+var providerFromQuery = (value, providers) => typeof value === "string" && providers.some((provider) => provider.provider === value && provider.configured !== false) ? value : undefined;
+var registerSimulationRoutes = (routes, simulation, defaultPathPrefix) => {
+  if (!simulation) {
+    return routes;
+  }
+  const pathPrefix = simulation.pathPrefix ?? defaultPathPrefix;
+  routes.post(`${pathPrefix}/failure`, async ({ query, set }) => {
+    const provider = providerFromQuery(query.provider, simulation.providers);
+    if (!provider) {
+      set.status = 400;
+      return {
+        error: "Provider is not configured for simulation."
+      };
+    }
+    if (simulation.failureProviders && !simulation.failureProviders.includes(provider)) {
+      set.status = 400;
+      return {
+        error: `${provider} is not configured for failure simulation.`
+      };
+    }
+    if (simulation.fallbackRequiredProvider && !simulation.providers.some((entry) => entry.provider === simulation.fallbackRequiredProvider && entry.configured !== false)) {
+      set.status = 400;
+      return {
+        error: simulation.fallbackRequiredMessage ?? `Configure ${simulation.fallbackRequiredProvider} before simulating fallback.`
+      };
+    }
+    return simulation.run(provider, "failure");
+  });
+  routes.post(`${pathPrefix}/recovery`, async ({ query, set }) => {
+    const provider = providerFromQuery(query.provider, simulation.providers);
+    if (!provider) {
+      set.status = 400;
+      return {
+        error: "Provider is not configured for simulation."
+      };
+    }
+    return simulation.run(provider, "recovery");
+  });
+  return routes;
+};
+var createVoiceResilienceRoutes = (options) => {
+  const path = options.path ?? "/resilience";
+  const routes = new Elysia5({
+    name: options.name ?? "absolutejs-voice-resilience"
+  }).get(path, async () => {
+    const events = await options.store.list();
+    const sttEvents = events.filter((event) => event.payload.kind === "stt");
+    const ttsEvents = events.filter((event) => event.payload.kind === "tts");
+    const data = {
+      links: options.links,
+      llmProviderHealth: await summarizeVoiceProviderHealth({
+        events,
+        providers: options.llmProviders ?? []
+      }),
+      routingEvents: listVoiceRoutingEvents(events),
+      sttProviderHealth: await summarizeVoiceProviderHealth({
+        events: sttEvents,
+        providers: options.sttProviders ?? []
+      }),
+      sttSimulation: options.sttSimulation,
+      title: options.title,
+      ttsProviderHealth: await summarizeVoiceProviderHealth({
+        events: ttsEvents,
+        providers: options.ttsProviders ?? []
+      }),
+      ttsSimulation: options.ttsSimulation
+    };
+    const body = await (options.render ?? renderVoiceResilienceHTML)(data);
+    return new Response(body, {
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+        ...options.headers
+      }
+    });
+  });
+  registerSimulationRoutes(routes, options.sttSimulation, "/api/stt-simulate");
+  registerSimulationRoutes(routes, options.ttsSimulation, "/api/tts-simulate");
+  return routes;
+};
 // src/providerAdapters.ts
 class VoiceIOProviderTimeoutError extends Error {
   provider;
@@ -9702,7 +10015,7 @@ var createVoiceMemoryStore = () => {
   return { get, getOrCreate, list, remove, set };
 };
 // src/opsWebhook.ts
-import { Elysia as Elysia5 } from "elysia";
+import { Elysia as Elysia6 } from "elysia";
 var toHex5 = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
 var signVoiceOpsWebhookBody = async (input) => {
   const encoder = new TextEncoder;
@@ -9832,7 +10145,7 @@ var verifyVoiceOpsWebhookSignature = async (input) => {
 };
 var createVoiceOpsWebhookReceiverRoutes = (options = {}) => {
   const path = options.path ?? "/api/voice-ops/webhook";
-  return new Elysia5().post(path, async ({ body, request, set }) => {
+  return new Elysia6().post(path, async ({ body, request, set }) => {
     const bodyText = typeof body === "string" ? body : JSON.stringify(body);
     if (options.signingSecret) {
       const verification = await verifyVoiceOpsWebhookSignature({
@@ -9865,9 +10178,9 @@ var createVoiceOpsWebhookReceiverRoutes = (options = {}) => {
   });
 };
 // src/handoffHealth.ts
-import { Elysia as Elysia6 } from "elysia";
-var escapeHtml7 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
-var getString4 = (value) => typeof value === "string" && value.length > 0 ? value : undefined;
+import { Elysia as Elysia7 } from "elysia";
+var escapeHtml8 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var getString5 = (value) => typeof value === "string" && value.length > 0 ? value : undefined;
 var isStatus = (value) => value === "delivered" || value === "failed" || value === "skipped";
 var increment3 = (record, key) => {
   record[key] = (record[key] ?? 0) + 1;
@@ -9875,11 +10188,11 @@ var increment3 = (record, key) => {
 var normalizeDelivery = (adapterId, value) => {
   const record = value && typeof value === "object" ? value : {};
   return {
-    adapterId: getString4(record.adapterId) ?? adapterId,
-    adapterKind: getString4(record.adapterKind),
+    adapterId: getString5(record.adapterId) ?? adapterId,
+    adapterKind: getString5(record.adapterKind),
     deliveredAt: typeof record.deliveredAt === "number" ? record.deliveredAt : undefined,
-    deliveredTo: getString4(record.deliveredTo),
-    error: getString4(record.error),
+    deliveredTo: getString5(record.deliveredTo),
+    error: getString5(record.error),
     status: isStatus(record.status) ? record.status : "failed"
   };
 };
@@ -9913,13 +10226,13 @@ var summarizeVoiceHandoffHealth = async (options = {}) => {
     const status = isStatus(event.payload.status) ? event.payload.status : "failed";
     const deliveries = normalizeDeliveries(event.payload);
     const item = {
-      action: getString4(event.payload.action),
+      action: getString5(event.payload.action),
       at: event.at,
       deliveries,
-      reason: getString4(event.payload.reason),
+      reason: getString5(event.payload.reason),
       sessionId: event.sessionId,
       status,
-      target: getString4(event.payload.target)
+      target: getString5(event.payload.target)
     };
     return {
       ...item,
@@ -9984,10 +10297,10 @@ var renderActionSummary = (summary) => {
   return [
     '<section class="voice-handoff-health-columns">',
     "<article><h3>Actions</h3>",
-    actions.length === 0 ? "<p>No handoff actions yet.</p>" : `<ul>${actions.map(([action, count]) => `<li>${escapeHtml7(action)}: ${String(count)}</li>`).join("")}</ul>`,
+    actions.length === 0 ? "<p>No handoff actions yet.</p>" : `<ul>${actions.map(([action, count]) => `<li>${escapeHtml8(action)}: ${String(count)}</li>`).join("")}</ul>`,
     "</article>",
     "<article><h3>Adapters</h3>",
-    adapters.length === 0 ? "<p>No adapter deliveries yet.</p>" : `<ul>${adapters.map(([adapterId, counts]) => `<li>${escapeHtml7(adapterId)}: ${String(counts.delivered)} delivered / ${String(counts.failed)} failed / ${String(counts.skipped)} skipped</li>`).join("")}</ul>`,
+    adapters.length === 0 ? "<p>No adapter deliveries yet.</p>" : `<ul>${adapters.map(([adapterId, counts]) => `<li>${escapeHtml8(adapterId)}: ${String(counts.delivered)} delivered / ${String(counts.failed)} failed / ${String(counts.skipped)} skipped</li>`).join("")}</ul>`,
     "</article>",
     "</section>"
   ].join("");
@@ -10001,22 +10314,22 @@ var renderVoiceHandoffHealthHTML = (summary) => [
   summary.events.length === 0 ? '<p class="voice-handoff-health-empty">No handoffs found.</p>' : [
     '<div class="voice-handoff-health-events">',
     ...summary.events.map((event) => [
-      `<article class="${escapeHtml7(event.status)}">`,
+      `<article class="${escapeHtml8(event.status)}">`,
       '<div class="voice-handoff-health-event-header">',
-      `<strong>${escapeHtml7(event.action ?? "handoff")}</strong>`,
-      `<span>${escapeHtml7(event.status)}</span>`,
+      `<strong>${escapeHtml8(event.action ?? "handoff")}</strong>`,
+      `<span>${escapeHtml8(event.status)}</span>`,
       "</div>",
-      `<p><small>${escapeHtml7(event.sessionId)}</small></p>`,
-      event.target ? `<p>Target: ${escapeHtml7(event.target)}</p>` : "",
-      event.reason ? `<p>Reason: ${escapeHtml7(event.reason)}</p>` : "",
+      `<p><small>${escapeHtml8(event.sessionId)}</small></p>`,
+      event.target ? `<p>Target: ${escapeHtml8(event.target)}</p>` : "",
+      event.reason ? `<p>Reason: ${escapeHtml8(event.reason)}</p>` : "",
       event.deliveries.length ? `<ul>${event.deliveries.map((delivery) => [
         "<li>",
-        `${escapeHtml7(delivery.adapterId)}: ${escapeHtml7(delivery.status)}`,
-        delivery.deliveredTo ? ` to ${escapeHtml7(delivery.deliveredTo)}` : "",
-        delivery.error ? ` (${escapeHtml7(delivery.error)})` : "",
+        `${escapeHtml8(delivery.adapterId)}: ${escapeHtml8(delivery.status)}`,
+        delivery.deliveredTo ? ` to ${escapeHtml8(delivery.deliveredTo)}` : "",
+        delivery.error ? ` (${escapeHtml8(delivery.error)})` : "",
         "</li>"
       ].join("")).join("")}</ul>` : "",
-      event.replayHref ? `<p><a href="${escapeHtml7(event.replayHref)}">Open replay</a></p>` : "",
+      event.replayHref ? `<p><a href="${escapeHtml8(event.replayHref)}">Open replay</a></p>` : "",
       "</article>"
     ].join("")),
     "</div>"
@@ -10048,7 +10361,7 @@ var createVoiceHandoffHealthHTMLHandler = (options = {}) => async ({ query }) =>
 var createVoiceHandoffHealthRoutes = (options = {}) => {
   const path = options.path ?? "/api/voice-handoffs";
   const htmlPath = options.htmlPath === undefined ? `${path}/htmx` : options.htmlPath;
-  const routes = new Elysia6({
+  const routes = new Elysia7({
     name: options.name ?? "absolutejs-voice-handoff-health"
   }).get(path, createVoiceHandoffHealthJSONHandler(options));
   if (htmlPath) {
@@ -12202,6 +12515,7 @@ export {
   renderVoiceTraceMarkdown,
   renderVoiceTraceHTML,
   renderVoiceSessionsHTML,
+  renderVoiceResilienceHTML,
   renderVoiceProviderHealthHTML,
   renderVoiceHandoffHealthHTML,
   renderVoiceCallReviewMarkdown,
@@ -12214,6 +12528,7 @@ export {
   pruneVoiceTraceEvents,
   matchesVoiceOpsTaskAssignmentRule,
   markVoiceOpsTaskSLABreached,
+  listVoiceRoutingEvents,
   listVoiceOpsTasks,
   isVoiceOpsTaskOverdue,
   heartbeatVoiceOpsTask,
@@ -12269,6 +12584,7 @@ export {
   createVoiceSQLiteExternalObjectMapStore,
   createVoiceS3ReviewStore,
   createVoiceReviewSavedEvent,
+  createVoiceResilienceRoutes,
   createVoiceRedisTaskLeaseCoordinator,
   createVoiceRedisIdempotencyStore,
   createVoiceProviderRouter,

package/dist/resilienceRoutes.d.ts

@@ -0,0 +1,106 @@
+import { Elysia } from 'elysia';
+import { type VoiceProviderHealthSummary } from './providerHealth';
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
+import type { VoiceIOProviderFailureSimulationMode, VoiceIOProviderFailureSimulationResult } from './testing/ioProviderSimulator';
+export type VoiceRoutingEventKind = 'llm' | 'stt' | 'tts';
+export type VoiceRoutingEvent = {
+    at: number;
+    attempt?: number;
+    elapsedMs?: number;
+    error?: string;
+    fallbackProvider?: string;
+    kind: VoiceRoutingEventKind;
+    latencyBudgetMs?: number;
+    operation?: string;
+    provider?: string;
+    selectedProvider?: string;
+    sessionId: string;
+    status?: string;
+    timedOut: boolean;
+    turnId?: string;
+};
+export type VoiceResilienceLink = {
+    href: string;
+    label: string;
+};
+export type VoiceResilienceSimulationProvider<TProvider extends string = string> = {
+    configured?: boolean;
+    provider: TProvider;
+};
+export type VoiceResilienceIOSimulator<TProvider extends string = string> = {
+    failureProviders?: readonly TProvider[];
+    fallbackRequiredProvider?: TProvider;
+    fallbackRequiredMessage?: string;
+    failureMessage?: string;
+    label?: string;
+    pathPrefix?: string;
+    providers: readonly VoiceResilienceSimulationProvider<TProvider>[];
+    recoveryMessage?: string;
+    run: (provider: TProvider, mode: VoiceIOProviderFailureSimulationMode) => Promise<VoiceIOProviderFailureSimulationResult<TProvider>>;
+};
+export type VoiceResiliencePageData = {
+    links?: readonly VoiceResilienceLink[];
+    llmProviderHealth: VoiceProviderHealthSummary<string>[];
+    routingEvents: VoiceRoutingEvent[];
+    sttProviderHealth: VoiceProviderHealthSummary<string>[];
+    sttSimulation?: VoiceResilienceIOSimulator<string>;
+    title?: string;
+    ttsProviderHealth: VoiceProviderHealthSummary<string>[];
+    ttsSimulation?: VoiceResilienceIOSimulator<string>;
+};
+export type VoiceResilienceRoutesOptions = {
+    headers?: HeadersInit;
+    links?: readonly VoiceResilienceLink[];
+    llmProviders?: readonly string[];
+    name?: string;
+    path?: string;
+    render?: (input: VoiceResiliencePageData) => string | Promise<string>;
+    sttProviders?: readonly string[];
+    sttSimulation?: VoiceResilienceIOSimulator<string>;
+    store: VoiceTraceEventStore;
+    title?: string;
+    ttsProviders?: readonly string[];
+    ttsSimulation?: VoiceResilienceIOSimulator<string>;
+};
+export declare const listVoiceRoutingEvents: (events: StoredVoiceTraceEvent[]) => VoiceRoutingEvent[];
+export declare const renderVoiceResilienceHTML: (input: VoiceResiliencePageData) => string;
+export declare const createVoiceResilienceRoutes: (options: VoiceResilienceRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/testing/index.js

@@ -3536,8 +3536,8 @@ var createVoiceIOProviderFailureSimulator = (options) => {
   const now = options.now ?? Date.now;
   const operation = options.operation ?? "open";
   const cooldownMs = Math.max(0, options.cooldownMs ?? 30000);
-  const emit = async (event) => {
-    await options.onProviderEvent?.(event);
+  const emit = async (event, input) => {
+    await options.onProviderEvent?.(event, input);
   };
   const run = async (provider, mode) => {
     if (!options.providers.includes(provider)) {
@@ -3561,7 +3561,7 @@ var createVoiceIOProviderFailureSimulator = (options) => {
         }),
         selectedProvider: provider,
         status: "success"
-      });
+      }, { mode, provider, sessionId });
       return {
         mode,
         provider,
@@ -3594,7 +3594,7 @@ var createVoiceIOProviderFailureSimulator = (options) => {
       selectedProvider: provider,
       status: "error",
       suppressedUntil
-    });
+    }, { mode, provider, sessionId });
     if (fallbackProvider) {
       await emit({
         at: startedAt + 1,
@@ -3612,7 +3612,7 @@ var createVoiceIOProviderFailureSimulator = (options) => {
         }),
         selectedProvider: provider,
         status: "fallback"
-      });
+      }, { mode, provider, sessionId });
     }
     return {
       fallbackProvider,

package/dist/testing/ioProviderSimulator.d.ts

@@ -22,7 +22,11 @@ export type VoiceIOProviderFailureSimulatorOptions<TProvider extends string = st
     kind: VoiceIOProviderFailureSimulationKind;
     latencyBudgets?: Partial<Record<TProvider, number>>;
     now?: () => number;
-    onProviderEvent?: (event: VoiceIOProviderRouterEvent<TProvider>) => Promise<void> | void;
+    onProviderEvent?: (event: VoiceIOProviderRouterEvent<TProvider>, input: {
+        mode: VoiceIOProviderFailureSimulationMode;
+        provider: TProvider;
+        sessionId: string;
+    }) => Promise<void> | void;
     operation?: VoiceIOProviderFailureSimulationOperation;
     providers: readonly TProvider[];
     recoveryElapsedMs?: number | Partial<Record<TProvider, number>>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@absolutejs/voice",
-	"version": "0.0.22-beta.35",
+	"version": "0.0.22-beta.37",
 	"description": "Voice primitives and Elysia plugin for AbsoluteJS",
 	"repository": {
 		"type": "git",