@absolutejs/voice 0.0.22-beta.4 → 0.0.22-beta.41

package/dist/index.js

@@ -2992,6 +2992,289 @@ var toVoiceSessionSummary = (session) => ({
 // src/session.ts
 import { Buffer } from "buffer";
 
+// src/handoff.ts
+var toHex3 = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+var signHandoffBody = async (input) => {
+  const encoder = new TextEncoder;
+  const key = await crypto.subtle.importKey("raw", encoder.encode(input.secret), {
+    hash: "SHA-256",
+    name: "HMAC"
+  }, false, ["sign"]);
+  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(`${input.timestamp}.${input.body}`));
+  return `sha256=${toHex3(new Uint8Array(signature))}`;
+};
+var toErrorMessage2 = (error) => error instanceof Error ? error.message : String(error);
+var createSkippedDelivery = (adapter) => ({
+  adapterId: adapter.id,
+  adapterKind: adapter.kind,
+  status: "skipped"
+});
+var aggregateHandoffStatus = (deliveries) => {
+  const statuses = Object.values(deliveries).map((delivery) => delivery.status);
+  if (statuses.some((status) => status === "failed")) {
+    return "failed";
+  }
+  if (statuses.some((status) => status === "delivered")) {
+    return "delivered";
+  }
+  return "skipped";
+};
+var createHandoffDeliveryId = (input) => [
+  "voice-handoff",
+  input.sessionId,
+  input.action,
+  Date.now(),
+  crypto.randomUUID()
+].join(":");
+var resolveHandoffDeliveryError = (deliveries) => Object.values(deliveries).map((delivery) => delivery.error).find(Boolean);
+var defaultWebhookBody = (input) => ({
+  action: input.action,
+  metadata: input.metadata,
+  reason: input.reason,
+  result: input.result,
+  session: {
+    id: input.session.id,
+    scenarioId: input.session.scenarioId,
+    status: input.session.status
+  },
+  source: "absolutejs-voice",
+  target: input.target
+});
+var deliverVoiceHandoff = async (input) => {
+  if (!input.config || input.config.adapters.length === 0) {
+    return;
+  }
+  const deliveries = {};
+  for (const adapter of input.config.adapters) {
+    if (adapter.actions && !adapter.actions.includes(input.handoff.action)) {
+      deliveries[adapter.id] = createSkippedDelivery(adapter);
+      continue;
+    }
+    try {
+      const result = await adapter.handoff(input.handoff);
+      deliveries[adapter.id] = {
+        ...result,
+        adapterId: adapter.id,
+        adapterKind: adapter.kind
+      };
+    } catch (error) {
+      deliveries[adapter.id] = {
+        adapterId: adapter.id,
+        adapterKind: adapter.kind,
+        error: toErrorMessage2(error),
+        status: "failed"
+      };
+      if (input.config.failMode === "throw") {
+        throw error;
+      }
+    }
+  }
+  return {
+    action: input.handoff.action,
+    deliveries,
+    status: aggregateHandoffStatus(deliveries)
+  };
+};
+var createVoiceHandoffDeliveryRecord = (input) => {
+  const now = Date.now();
+  return {
+    action: input.action,
+    context: input.context,
+    createdAt: now,
+    deliveryAttempts: 0,
+    deliveryStatus: "pending",
+    id: input.id ?? createHandoffDeliveryId({
+      action: input.action,
+      sessionId: input.session.id
+    }),
+    metadata: input.metadata,
+    reason: input.reason,
+    result: input.result,
+    session: input.session,
+    sessionId: input.session.id,
+    target: input.target,
+    updatedAt: now
+  };
+};
+var applyVoiceHandoffDeliveryResult = (delivery, result) => ({
+  ...delivery,
+  deliveredAt: result.status === "delivered" || result.status === "skipped" ? Date.now() : delivery.deliveredAt,
+  deliveries: result.deliveries,
+  deliveryAttempts: (delivery.deliveryAttempts ?? 0) + 1,
+  deliveryError: result.status === "failed" ? resolveHandoffDeliveryError(result.deliveries) : undefined,
+  deliveryStatus: result.status,
+  updatedAt: Date.now()
+});
+var deliverVoiceHandoffDelivery = async (options) => {
+  const result = await deliverVoiceHandoff({
+    config: {
+      adapters: options.adapters,
+      failMode: options.failMode
+    },
+    handoff: {
+      action: options.delivery.action,
+      api: options.api,
+      context: options.delivery.context,
+      metadata: options.delivery.metadata,
+      reason: options.delivery.reason,
+      result: options.delivery.result,
+      session: options.delivery.session,
+      target: options.delivery.target
+    }
+  });
+  return result ? applyVoiceHandoffDeliveryResult(options.delivery, result) : {
+    ...options.delivery,
+    deliveryAttempts: (options.delivery.deliveryAttempts ?? 0) + 1,
+    deliveryStatus: "skipped",
+    updatedAt: Date.now()
+  };
+};
+var createVoiceMemoryHandoffDeliveryStore = () => {
+  const deliveries = new Map;
+  return {
+    get: async (id) => deliveries.get(id),
+    list: async () => [...deliveries.values()].sort((left, right) => left.createdAt - right.createdAt || left.id.localeCompare(right.id)),
+    remove: async (id) => {
+      deliveries.delete(id);
+    },
+    set: async (id, delivery) => {
+      deliveries.set(id, delivery);
+    }
+  };
+};
+var createVoiceWebhookHandoffAdapter = (options) => ({
+  actions: options.actions,
+  handoff: async (input) => {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if (typeof fetchImpl !== "function") {
+      return {
+        deliveredTo: options.url,
+        error: "Handoff delivery failed: fetch is not available in this runtime.",
+        status: "failed"
+      };
+    }
+    const body = JSON.stringify(await options.body?.(input) ?? defaultWebhookBody(input));
+    const headers = {
+      "content-type": "application/json",
+      ...options.headers
+    };
+    if (options.signingSecret) {
+      const timestamp = String(Date.now());
+      headers["x-absolutejs-timestamp"] = timestamp;
+      headers["x-absolutejs-signature"] = await signHandoffBody({
+        body,
+        secret: options.signingSecret,
+        timestamp
+      });
+    }
+    const controller = options.timeoutMs && options.timeoutMs > 0 ? new AbortController : undefined;
+    const timeout = controller && options.timeoutMs ? setTimeout(() => controller.abort(), options.timeoutMs) : undefined;
+    try {
+      const response = await fetchImpl(options.url, {
+        body,
+        headers,
+        method: options.method ?? "POST",
+        signal: controller?.signal
+      });
+      if (!response.ok) {
+        return {
+          deliveredTo: options.url,
+          error: `Handoff delivery failed with response ${response.status}.`,
+          status: "failed"
+        };
+      }
+      return {
+        deliveredAt: Date.now(),
+        deliveredTo: options.url,
+        status: "delivered"
+      };
+    } finally {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+    }
+  },
+  id: options.id,
+  kind: options.kind ?? "webhook"
+});
+var escapeXml = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+var defaultTwilioTransferTwiML = (input) => {
+  if (!input.target) {
+    return "<Response><Hangup /></Response>";
+  }
+  return `<Response><Dial>${escapeXml(input.target)}</Dial></Response>`;
+};
+var resolveTwilioCallSid = async (resolver, input) => {
+  if (typeof resolver === "function") {
+    return resolver(input);
+  }
+  if (typeof resolver === "string" && resolver.length > 0) {
+    return resolver;
+  }
+  const metadataSid = typeof input.metadata?.callSid === "string" ? input.metadata.callSid : undefined;
+  const sessionMetadata = input.session.metadata && typeof input.session.metadata === "object" ? input.session.metadata : undefined;
+  const sessionSid = typeof sessionMetadata?.callSid === "string" ? sessionMetadata.callSid : undefined;
+  return metadataSid ?? sessionSid;
+};
+var createVoiceTwilioRedirectHandoffAdapter = (options) => ({
+  actions: options.actions ?? ["transfer"],
+  handoff: async (input) => {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    const callSid = await resolveTwilioCallSid(options.callSid, input);
+    if (!callSid) {
+      return {
+        error: "Twilio handoff requires a callSid.",
+        status: "failed"
+      };
+    }
+    if (typeof fetchImpl !== "function") {
+      return {
+        error: "Twilio handoff failed: fetch is not available in this runtime.",
+        status: "failed"
+      };
+    }
+    const url = `https://api.twilio.com/2010-04-01/Accounts/${encodeURIComponent(options.accountSid)}/Calls/${encodeURIComponent(callSid)}.json`;
+    const body = new URLSearchParams({
+      Twiml: await (options.buildTwiML?.(input) ?? defaultTwilioTransferTwiML(input))
+    });
+    const auth = btoa(`${options.accountSid}:${options.authToken}`);
+    const controller = options.timeoutMs && options.timeoutMs > 0 ? new AbortController : undefined;
+    const timeout = controller && options.timeoutMs ? setTimeout(() => controller.abort(), options.timeoutMs) : undefined;
+    try {
+      const response = await fetchImpl(url, {
+        body,
+        headers: {
+          authorization: `Basic ${auth}`,
+          "content-type": "application/x-www-form-urlencoded"
+        },
+        method: "POST",
+        signal: controller?.signal
+      });
+      if (!response.ok) {
+        return {
+          deliveredTo: url,
+          error: `Twilio handoff failed with response ${response.status}.`,
+          status: "failed"
+        };
+      }
+      return {
+        deliveredAt: Date.now(),
+        deliveredTo: url,
+        metadata: {
+          callSid
+        },
+        status: "delivered"
+      };
+    } finally {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+    }
+  },
+  id: options.id ?? "twilio-redirect",
+  kind: "twilio-redirect"
+});
+
 // src/turnDetection.ts
 var DEFAULT_SILENCE_MS = 700;
 var DEFAULT_SPEECH_THRESHOLD = 0.015;
@@ -3288,6 +3571,7 @@ var pushCallLifecycleEvent = (session, input) => {
   }
   return lifecycle;
 };
+var getLatestCallLifecycleEvent = (session) => session.call?.events.at(-1);
 var createVoiceSession = (options) => {
   const logger = resolveLogger(options.logger);
   const reconnect = {
@@ -3388,6 +3672,64 @@ var createVoiceSession = (options) => {
       });
     }
   };
+  const sendCallLifecycle = async (session) => {
+    const event = getLatestCallLifecycleEvent(session);
+    if (!event) {
+      return;
+    }
+    await send({
+      event,
+      sessionId: options.id,
+      type: "call_lifecycle"
+    });
+  };
+  const runHandoff = async (input) => {
+    const queuedDelivery = options.handoff?.deliveryQueue ? createVoiceHandoffDeliveryRecord({
+      action: input.action,
+      context: options.context,
+      metadata: input.metadata,
+      reason: input.reason,
+      result: input.result,
+      session: input.session,
+      target: input.target
+    }) : undefined;
+    if (queuedDelivery) {
+      await options.handoff?.deliveryQueue?.set(queuedDelivery.id, queuedDelivery);
+    }
+    if (options.handoff?.enqueueOnly) {
+      return;
+    }
+    const result = await deliverVoiceHandoff({
+      config: options.handoff,
+      handoff: {
+        action: input.action,
+        api,
+        context: options.context,
+        metadata: input.metadata,
+        reason: input.reason,
+        result: input.result,
+        session: input.session,
+        target: input.target
+      }
+    });
+    if (!result) {
+      return;
+    }
+    if (queuedDelivery) {
+      const updatedDelivery = applyVoiceHandoffDeliveryResult(queuedDelivery, result);
+      await options.handoff?.deliveryQueue?.set(updatedDelivery.id, updatedDelivery);
+    }
+    await appendTrace({
+      metadata: input.metadata,
+      payload: {
+        ...result,
+        reason: input.reason,
+        target: input.target
+      },
+      session: input.session,
+      type: "call.handoff"
+    });
+  };
   const readSession = async () => options.store.getOrCreate(options.id);
   const writeSession = async (mutate) => {
     const session = await options.store.getOrCreate(options.id);
@@ -3578,6 +3920,7 @@ var createVoiceSession = (options) => {
     await appendTrace({
       payload: {
         disposition,
+        metadata: input.metadata,
         reason: input.reason,
         target: input.target,
         type: "end"
@@ -3585,6 +3928,7 @@ var createVoiceSession = (options) => {
       session,
       type: "call.lifecycle"
     });
+    await sendCallLifecycle(session);
     await send({
       sessionId: options.id,
       type: "complete"
@@ -3664,6 +4008,15 @@ var createVoiceSession = (options) => {
       session,
       type: "call.lifecycle"
     });
+    await sendCallLifecycle(session);
+    await runHandoff({
+      action: "transfer",
+      metadata: input.metadata,
+      reason: input.reason,
+      result: input.result,
+      session,
+      target: input.target
+    });
     await completeInternal(input.result, {
       disposition: "transferred",
       invokeOnComplete: false,
@@ -3689,6 +4042,14 @@ var createVoiceSession = (options) => {
       session,
       type: "call.lifecycle"
     });
+    await sendCallLifecycle(session);
+    await runHandoff({
+      action: "escalate",
+      metadata: input.metadata,
+      reason: input.reason,
+      result: input.result,
+      session
+    });
     await completeInternal(input.result, {
       disposition: "escalated",
       invokeOnComplete: false,
@@ -3711,6 +4072,13 @@ var createVoiceSession = (options) => {
       session,
       type: "call.lifecycle"
     });
+    await sendCallLifecycle(session);
+    await runHandoff({
+      action: "no-answer",
+      metadata: input?.metadata,
+      result: input?.result,
+      session
+    });
     await completeInternal(input?.result, {
       disposition: "no-answer",
       invokeOnComplete: false,
@@ -3732,6 +4100,13 @@ var createVoiceSession = (options) => {
       session,
       type: "call.lifecycle"
     });
+    await sendCallLifecycle(session);
+    await runHandoff({
+      action: "voicemail",
+      metadata: input?.metadata,
+      result: input?.result,
+      session
+    });
     await completeInternal(input?.result, {
       disposition: "voicemail",
       invokeOnComplete: false,
@@ -4518,6 +4893,7 @@ var createVoiceSession = (options) => {
         session,
         type: "call.lifecycle"
       });
+      await sendCallLifecycle(session);
     }
     await send({
       sessionId: options.id,
@@ -4755,6 +5131,14 @@ var isVoiceClientMessage = (value) => {
     return false;
   }
   switch (value.type) {
+    case "call_control":
+      if (!("action" in value)) {
+        return false;
+      }
+      if (value.action !== "complete" && value.action !== "escalate" && value.action !== "no-answer" && value.action !== "transfer" && value.action !== "voicemail") {
+        return false;
+      }
+      return (!("metadata" in value) || value.metadata === undefined || value.metadata !== null && typeof value.metadata === "object") && (!("reason" in value) || value.reason === undefined || typeof value.reason === "string") && (!("target" in value) || value.target === undefined || typeof value.target === "string");
     case "close":
       return true;
     case "end_turn":
@@ -4895,6 +5279,7 @@ var voice = (config) => {
       audioConditioning: sessionOptions.audioConditioning,
       context,
       id: sessionId,
+      handoff: config.handoff,
       languageStrategy: config.languageStrategy,
       lexicon,
       logger: sessionOptions.logger,
@@ -5006,6 +5391,42 @@ var voice = (config) => {
           await current.close(message.reason);
           runtime.activeSessions.delete(sessionState.sessionId);
         }
+        if (message.type === "call_control" && current) {
+          if (message.action === "transfer") {
+            if (message.target) {
+              await current.transfer({
+                metadata: message.metadata,
+                reason: message.reason,
+                target: message.target
+              });
+            } else {
+              ws.send(JSON.stringify({
+                message: "call_control transfer requires target",
+                recoverable: true,
+                type: "error"
+              }));
+            }
+          }
+          if (message.action === "escalate") {
+            await current.escalate({
+              metadata: message.metadata,
+              reason: message.reason ?? "client-requested-escalation"
+            });
+          }
+          if (message.action === "voicemail") {
+            await current.markVoicemail({
+              metadata: message.metadata
+            });
+          }
+          if (message.action === "no-answer") {
+            await current.markNoAnswer({
+              metadata: message.metadata
+            });
+          }
+          if (message.action === "complete") {
+            await current.complete();
+          }
+        }
         if (message.type === "start" && message.sessionId && message.sessionId !== sessionState.sessionId) {
           const currentSession = runtime.activeSessions.get(sessionState.sessionId);
           if (currentSession) {
@@ -5054,7 +5475,7 @@ var voice = (config) => {
 };
 // src/agent.ts
 var normalizeText3 = (value) => typeof value === "string" ? value.trim() : "";
-var toErrorMessage2 = (error) => error instanceof Error ? error.message : String(error);
+var toErrorMessage3 = (error) => error instanceof Error ? error.message : String(error);
 var createHistoryMessages = (session, turn) => {
   const messages = [];
   for (const previousTurn of session.turns) {
@@ -5150,6 +5571,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"
         });
       }
@@ -5224,7 +5656,7 @@ var createVoiceAgent = (options) => {
             toolCallId: toolCall.id
           });
         } catch (error) {
-          const errorMessage = toErrorMessage2(error);
+          const errorMessage = toErrorMessage3(error);
           toolResults.push({
             error: errorMessage,
             status: "error",
@@ -6090,53 +6522,352 @@ var summarizeVoiceAssistantRuns = async (input) => {
     totalRuns: assistantRuns.length
   };
 };
-// src/fileStore.ts
-import { mkdir, readFile, readdir, rename, rm, writeFile } from "fs/promises";
-import { join } from "path";
+// src/assistantHealth.ts
+import { Elysia as Elysia3 } from "elysia";
 
-// src/trace.ts
-var createVoiceTraceEventId = (event) => [
-  event.sessionId,
-  event.turnId ?? "session",
-  event.type,
-  String(event.at ?? Date.now()),
-  crypto.randomUUID()
-].map(encodeURIComponent).join(":");
-var createVoiceTraceEvent = (event) => ({
-  ...event,
-  at: event.at,
-  id: event.id ?? createVoiceTraceEventId({
-    at: event.at,
-    sessionId: event.sessionId,
-    turnId: event.turnId,
-    type: event.type
-  })
-});
-var createVoiceTraceSinkDeliveryId = (events) => {
-  const firstEvent = events[0];
-  return [
-    firstEvent?.sessionId ?? "trace",
-    firstEvent?.traceId ?? "sink",
-    String(firstEvent?.at ?? Date.now()),
-    crypto.randomUUID()
-  ].map(encodeURIComponent).join(":");
-};
-var createVoiceTraceSinkDeliveryRecord = (input) => {
-  const createdAt = input.createdAt ?? Date.now();
-  return {
-    createdAt,
-    deliveredAt: input.deliveredAt,
-    deliveryAttempts: input.deliveryAttempts,
-    deliveryError: input.deliveryError,
-    deliveryStatus: input.deliveryStatus ?? "pending",
-    events: input.events,
-    id: input.id ?? createVoiceTraceSinkDeliveryId(input.events),
-    sinkDeliveries: input.sinkDeliveries,
-    updatedAt: input.updatedAt ?? createdAt
+// 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",
+      timeoutCount: 0
+    };
+    entries.set(provider, entry);
+    return entry;
   };
-};
-var matchesTraceFilter = (event, filter) => {
-  if (filter.sessionId !== undefined && event.sessionId !== filter.sessionId) {
+  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;
+    if (event.payload.timedOut === true) {
+      entry.timeoutCount += 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,
+      timeoutCount: entry.timeoutCount
+    };
+  });
+  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>Timeouts</dt><dd>${String(provider.timeoutCount)}</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/diagnosticsRoutes.ts
+import { Elysia as Elysia4 } from "elysia";
+
+// src/trace.ts
+var createVoiceTraceEventId = (event) => [
+  event.sessionId,
+  event.turnId ?? "session",
+  event.type,
+  String(event.at ?? Date.now()),
+  crypto.randomUUID()
+].map(encodeURIComponent).join(":");
+var createVoiceTraceEvent = (event) => ({
+  ...event,
+  at: event.at,
+  id: event.id ?? createVoiceTraceEventId({
+    at: event.at,
+    sessionId: event.sessionId,
+    turnId: event.turnId,
+    type: event.type
+  })
+});
+var createVoiceTraceSinkDeliveryId = (events) => {
+  const firstEvent = events[0];
+  return [
+    firstEvent?.sessionId ?? "trace",
+    firstEvent?.traceId ?? "sink",
+    String(firstEvent?.at ?? Date.now()),
+    crypto.randomUUID()
+  ].map(encodeURIComponent).join(":");
+};
+var createVoiceTraceSinkDeliveryRecord = (input) => {
+  const createdAt = input.createdAt ?? Date.now();
+  return {
+    createdAt,
+    deliveredAt: input.deliveredAt,
+    deliveryAttempts: input.deliveryAttempts,
+    deliveryError: input.deliveryError,
+    deliveryStatus: input.deliveryStatus ?? "pending",
+    events: input.events,
+    id: input.id ?? createVoiceTraceSinkDeliveryId(input.events),
+    sinkDeliveries: input.sinkDeliveries,
+    updatedAt: input.updatedAt ?? createdAt
+  };
+};
+var matchesTraceFilter = (event, filter) => {
+  if (filter.sessionId !== undefined && event.sessionId !== filter.sessionId) {
     return false;
   }
   if (filter.turnId !== undefined && event.turnId !== filter.turnId) {
@@ -6196,7 +6927,7 @@ var sleep3 = async (delayMs) => {
   }
   await new Promise((resolve2) => setTimeout(resolve2, delayMs));
 };
-var toHex3 = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+var toHex4 = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
 var signVoiceTraceSinkBody = async (input) => {
   const encoder = new TextEncoder;
   const key = await crypto.subtle.importKey("raw", encoder.encode(input.secret), {
@@ -6205,7 +6936,7 @@ var signVoiceTraceSinkBody = async (input) => {
   }, false, ["sign"]);
   const payload = encoder.encode(`${input.timestamp}.${input.body}`);
   const signature = await crypto.subtle.sign("HMAC", key, payload);
-  return `sha256=${toHex3(new Uint8Array(signature))}`;
+  return `sha256=${toHex4(new Uint8Array(signature))}`;
 };
 var createVoiceTraceSinkDeliveryError = (input) => {
   if (input.response) {
@@ -6426,7 +7157,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 "";
@@ -6704,10 +7435,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(`
@@ -6718,7 +7449,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}",
@@ -6732,7 +7463,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>`,
@@ -6746,7 +7477,7 @@ var renderVoiceTraceHTML = (events, options = {}) => {
     eventRows,
     "</tbody></table>",
     "<h2>Markdown Export</h2>",
-    `<pre>${escapeHtml3(markdown)}</pre>`,
+    `<pre>${escapeHtml5(markdown)}</pre>`,
     "</main></body></html>"
   ].join(`
 `);
@@ -6758,7 +7489,385 @@ var buildVoiceTraceReplay = (events, options = {}) => ({
   summary: summarizeVoiceTrace(options.redact ? redactVoiceTraceEvents(events, options.redact) : events)
 });
 
+// src/diagnosticsRoutes.ts
+var escapeHtml6 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var getString3 = (value) => typeof value === "string" && value.trim() ? value : undefined;
+var getNumber2 = (value) => {
+  const parsed = typeof value === "number" ? value : typeof value === "string" ? Number(value) : undefined;
+  return typeof parsed === "number" && Number.isFinite(parsed) ? parsed : undefined;
+};
+var getBoolean = (value) => value === true || value === "true" || value === "1";
+var parseTraceTypeFilter = (value) => {
+  if (typeof value !== "string" || !value.trim()) {
+    return;
+  }
+  const types = value.split(",").map((entry) => entry.trim()).filter(Boolean);
+  return types.length <= 1 ? types[0] : types;
+};
+var resolveVoiceDiagnosticsTraceFilter = (query) => ({
+  limit: getNumber2(query.limit),
+  scenarioId: getString3(query.scenarioId),
+  sessionId: getString3(query.sessionId),
+  traceId: getString3(query.traceId),
+  turnId: getString3(query.turnId),
+  type: parseTraceTypeFilter(query.type)
+});
+var filterByDiagnosticsQuery = (events, query) => {
+  const provider = getString3(query.provider);
+  const status = getString3(query.status);
+  const since = getNumber2(query.since);
+  const until = getNumber2(query.until);
+  return filterVoiceTraceEvents(events, resolveVoiceDiagnosticsTraceFilter(query)).filter((event) => (!provider || event.payload.provider === provider) && (!status || event.payload.providerStatus === status || event.payload.status === status) && (since === undefined || event.at >= since) && (until === undefined || event.at <= until));
+};
+var buildVoiceDiagnosticsMarkdown = (events, options = {}) => {
+  const summary = summarizeVoiceTrace(events);
+  const evaluation = evaluateVoiceTrace(events, options.evaluation);
+  const trace = renderVoiceTraceMarkdown(events, {
+    evaluation: options.evaluation,
+    title: options.title ?? `Voice Diagnostics ${summary.sessionId ?? ""}`.trim()
+  });
+  return [
+    `# ${options.title ?? "Voice Diagnostics Bug Report"}`,
+    "",
+    `Session: ${summary.sessionId ?? "unknown"}`,
+    `Pass: ${evaluation.pass ? "yes" : "no"}`,
+    `Events: ${summary.eventCount}`,
+    `Turns: ${summary.turnCount}`,
+    `Errors: ${summary.errorCount}`,
+    `Tool errors: ${summary.toolErrorCount}`,
+    `Estimated cost units: ${summary.cost.estimatedRelativeCostUnits}`,
+    "",
+    "## Issues",
+    "",
+    evaluation.issues.length ? evaluation.issues.map((issue) => `- [${issue.severity}] ${issue.code}: ${issue.message}`).join(`
+`) : "- none",
+    "",
+    "## Trace",
+    "",
+    trace
+  ].join(`
+`);
+};
+var renderDiagnosticsIndex = (input) => {
+  const sessions = new Map;
+  for (const event of input.events) {
+    sessions.set(event.sessionId, [...sessions.get(event.sessionId) ?? [], event]);
+  }
+  const rows = [...sessions.entries()].sort(([, left], [, right]) => (right.at(-1)?.at ?? 0) - (left.at(-1)?.at ?? 0)).slice(0, 50).map(([sessionId, events]) => {
+    const summary = summarizeVoiceTrace(events);
+    const encoded = encodeURIComponent(sessionId);
+    return `<tr><td>${escapeHtml6(sessionId)}</td><td>${summary.eventCount}</td><td>${summary.turnCount}</td><td>${summary.errorCount}</td><td><a href="${input.basePath}/html?sessionId=${encoded}&redact=true">HTML</a> \xB7 <a href="${input.basePath}/markdown?sessionId=${encoded}&redact=true">Markdown</a> \xB7 <a href="${input.basePath}/json?sessionId=${encoded}&redact=true">JSON</a></td></tr>`;
+  }).join("");
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" /><title>${escapeHtml6(input.title)}</title><style>body{font-family:ui-sans-serif,system-ui,sans-serif;margin:2rem;background:#f8f7f2;color:#181713}main{max-width:1100px;margin:auto}table{width:100%;border-collapse:collapse;background:white}td,th{border-bottom:1px solid #eee;padding:.7rem;text-align:left}a{color:#9a3412}</style></head><body><main><h1>${escapeHtml6(input.title)}</h1><p>Recent voice trace diagnostics. Exports support filters: sessionId, traceId, turnId, scenarioId, type, provider, status, since, until, limit, redact.</p><table><thead><tr><th>Session</th><th>Events</th><th>Turns</th><th>Errors</th><th>Exports</th></tr></thead><tbody>${rows}</tbody></table></main></body></html>`;
+};
+var withRedaction = (events, query, defaultRedact) => {
+  const shouldRedact = query.redact === undefined ? defaultRedact : getBoolean(query.redact);
+  return shouldRedact ? redactVoiceTraceEvents(events, shouldRedact) : events;
+};
+var createVoiceDiagnosticsRoutes = (options) => {
+  const path = options.path ?? "/diagnostics";
+  const title = options.title ?? "AbsoluteJS Voice Diagnostics";
+  const routes = new Elysia4({
+    name: options.name ?? "absolutejs-voice-diagnostics"
+  });
+  routes.get(path, async () => {
+    const events = await options.store.list();
+    return new Response(renderDiagnosticsIndex({ basePath: path, events, title }), {
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+        ...options.headers
+      }
+    });
+  });
+  routes.get(`${path}/json`, async ({ query }) => {
+    const events = filterByDiagnosticsQuery(await options.store.list(), query);
+    const redacted = withRedaction(events, query, options.redact);
+    return Response.json({
+      ...await exportVoiceTrace({
+        filter: resolveVoiceDiagnosticsTraceFilter(query),
+        redact: false,
+        store: {
+          ...options.store,
+          list: async () => redacted
+        }
+      }),
+      filteredCount: events.length,
+      redacted: redacted !== events
+    });
+  });
+  routes.get(`${path}/markdown`, async ({ query }) => {
+    const events = withRedaction(filterByDiagnosticsQuery(await options.store.list(), query), query, options.redact ?? true);
+    const body = buildVoiceDiagnosticsMarkdown(events, {
+      evaluation: options.evaluation,
+      title
+    });
+    return new Response(body, {
+      headers: {
+        "Content-Type": "text/markdown; charset=utf-8",
+        ...options.headers
+      }
+    });
+  });
+  routes.get(`${path}/html`, async ({ query }) => {
+    const events = withRedaction(filterByDiagnosticsQuery(await options.store.list(), query), query, options.redact ?? true);
+    const body = renderVoiceTraceHTML(events, {
+      evaluation: options.evaluation,
+      title
+    });
+    return new Response(body, {
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+        ...options.headers
+      }
+    });
+  });
+  return routes;
+};
+// src/sessionReplay.ts
+import { Elysia as Elysia5 } from "elysia";
+var getString4 = (value) => typeof value === "string" ? value : undefined;
+var escapeHtml7 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var increment2 = (record, key) => {
+  record[key] = (record[key] ?? 0) + 1;
+};
+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: getString4(event.payload.text)
+        });
+        break;
+      case "turn.committed":
+        turn.committedText = getString4(event.payload.text);
+        break;
+      case "turn.assistant": {
+        const text = getString4(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 summarizeVoiceSessions = async (options = {}) => {
+  const events = options.events ?? await options.store?.list() ?? [];
+  const grouped = new Map;
+  for (const event of events) {
+    grouped.set(event.sessionId, [...grouped.get(event.sessionId) ?? [], event]);
+  }
+  const sessions = [...grouped.entries()].map(([sessionId, sessionEvents]) => {
+    const sorted = filterVoiceTraceEvents(sessionEvents);
+    const summary = buildVoiceTraceReplay(sorted, {
+      evaluation: {
+        requireAssistantReply: false,
+        requireCompletedCall: false,
+        requireTranscript: false,
+        requireTurn: false
+      }
+    }).summary;
+    const providerErrors = {};
+    const providers = new Set;
+    let latestOutcome;
+    let errorCount = 0;
+    for (const event of sorted) {
+      const provider = getString4(event.payload.provider);
+      if (provider) {
+        providers.add(provider);
+      }
+      if (event.type === "session.error" && (event.payload.providerStatus === "error" || typeof event.payload.error === "string")) {
+        errorCount += 1;
+        increment2(providerErrors, provider ?? "unknown");
+      }
+      const outcome = getString4(event.payload.outcome);
+      if (outcome) {
+        latestOutcome = outcome;
+      }
+    }
+    const item = {
+      endedAt: summary.endedAt,
+      errorCount,
+      eventCount: summary.eventCount,
+      latestOutcome,
+      providerErrors,
+      providers: [...providers].sort(),
+      sessionId,
+      startedAt: summary.startedAt,
+      status: errorCount > 0 ? "failed" : "healthy",
+      transcriptCount: summary.transcriptCount,
+      turnCount: summary.turnCount
+    };
+    const replayHref = options.replayHref === false ? "" : typeof options.replayHref === "function" ? options.replayHref(item) : `${options.replayHref ?? "/api/voice-sessions"}/${encodeURIComponent(sessionId)}/replay/htmx`;
+    return {
+      ...item,
+      replayHref
+    };
+  });
+  const search = options.q?.trim().toLowerCase();
+  return sessions.filter((session) => {
+    if (options.status && options.status !== "all" && session.status !== options.status) {
+      return false;
+    }
+    if (options.provider && !session.providers.includes(options.provider)) {
+      return false;
+    }
+    if (!search) {
+      return true;
+    }
+    return [
+      session.sessionId,
+      session.latestOutcome,
+      session.status,
+      ...session.providers
+    ].some((value) => value?.toLowerCase().includes(search));
+  }).sort((left, right) => (right.endedAt ?? right.startedAt ?? 0) - (left.endedAt ?? left.startedAt ?? 0)).slice(0, options.limit ?? 50);
+};
+var renderVoiceSessionsHTML = (sessions) => sessions.length === 0 ? '<p class="voice-sessions-empty">No voice sessions found.</p>' : [
+  '<div class="voice-sessions-list">',
+  ...sessions.map((session) => [
+    `<article class="voice-session-card ${escapeHtml7(session.status)}">`,
+    '<div class="voice-session-card-header">',
+    `<strong>${escapeHtml7(session.sessionId)}</strong>`,
+    `<span>${escapeHtml7(session.status)}</span>`,
+    "</div>",
+    "<dl>",
+    `<div><dt>Events</dt><dd>${String(session.eventCount)}</dd></div>`,
+    `<div><dt>Turns</dt><dd>${String(session.turnCount)}</dd></div>`,
+    `<div><dt>Transcripts</dt><dd>${String(session.transcriptCount)}</dd></div>`,
+    `<div><dt>Errors</dt><dd>${String(session.errorCount)}</dd></div>`,
+    "</dl>",
+    session.latestOutcome ? `<p>Outcome: ${escapeHtml7(session.latestOutcome)}</p>` : "",
+    session.providers.length ? `<p>Providers: ${session.providers.map(escapeHtml7).join(", ")}</p>` : "",
+    session.replayHref ? `<p><a href="${escapeHtml7(session.replayHref)}">Open replay</a></p>` : "",
+    "</article>"
+  ].join("")),
+  "</div>"
+].join("");
+var createVoiceSessionsJSONHandler = (options = {}) => async ({ query }) => summarizeVoiceSessions({
+  ...options,
+  limit: typeof query?.limit === "string" ? Number(query.limit) : options.limit,
+  provider: query?.provider ?? options.provider,
+  q: query?.q ?? options.q,
+  status: query?.status === "failed" || query?.status === "healthy" || query?.status === "all" ? query.status : options.status
+});
+var createVoiceSessionsHTMLHandler = (options = {}) => async ({ query }) => {
+  const sessions = await summarizeVoiceSessions({
+    ...options,
+    limit: typeof query?.limit === "string" ? Number(query.limit) : options.limit,
+    provider: query?.provider ?? options.provider,
+    q: query?.q ?? options.q,
+    status: query?.status === "failed" || query?.status === "healthy" || query?.status === "all" ? query.status : options.status
+  });
+  const body = await (options.render?.(sessions) ?? renderVoiceSessionsHTML(sessions));
+  return new Response(body, {
+    headers: {
+      "Content-Type": "text/html; charset=utf-8",
+      ...options.headers
+    }
+  });
+};
+var createVoiceSessionListRoutes = (options = {}) => {
+  const path = options.path ?? "/api/voice-sessions";
+  const htmlPath = options.htmlPath === undefined ? `${path}/htmx` : options.htmlPath;
+  const routes = new Elysia5({
+    name: options.name ?? "absolutejs-voice-session-list"
+  }).get(path, createVoiceSessionsJSONHandler(options));
+  if (htmlPath) {
+    routes.get(htmlPath, createVoiceSessionsHTMLHandler(options));
+  }
+  return routes;
+};
+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 Elysia5({
+    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, {
@@ -7006,73 +8115,2021 @@ var createVoiceFileAssistantMemoryStore = (options) => {
       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 };
+  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,
+    directory: join(options.directory, "sessions")
+  }),
+  tasks: createVoiceFileTaskStore({
+    ...options,
+    directory: join(options.directory, "tasks")
+  }),
+  traceDeliveries: createVoiceFileTraceSinkDeliveryStore({
+    ...options,
+    directory: join(options.directory, "trace-deliveries")
+  }),
+  traces: createVoiceFileTraceEventStore({
+    ...options,
+    directory: join(options.directory, "traces")
+  })
+});
+var createStoredVoiceCallReviewArtifact = (id, artifact) => withVoiceCallReviewId(id, artifact);
+var createStoredVoiceOpsTask = (id, task) => withVoiceOpsTaskId(id, task);
+var createStoredVoiceIntegrationEvent = (id, event) => withVoiceIntegrationEventId(id, event);
+var createStoredVoiceExternalObjectMap = (mapping) => createVoiceExternalObjectMap({
+  at: mapping.at,
+  externalId: mapping.externalId,
+  provider: mapping.provider,
+  sinkId: mapping.sinkId,
+  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;
+  }
+};
+
+class VoiceProviderTimeoutError extends Error {
+  provider;
+  timeoutMs;
+  constructor(provider, timeoutMs) {
+    super(`Voice provider ${provider} exceeded ${timeoutMs}ms latency budget.`);
+    this.name = "VoiceProviderTimeoutError";
+    this.provider = provider;
+    this.timeoutMs = timeoutMs;
+  }
+}
+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 getProviderTimeoutMs = (provider) => {
+    const timeoutMs = options.providerProfiles?.[provider]?.timeoutMs ?? options.timeoutMs;
+    return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined;
+  };
+  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);
+  };
+  const runProvider = async (provider, model, input) => {
+    const timeoutMs = getProviderTimeoutMs(provider);
+    if (!timeoutMs) {
+      return model.generate(input);
+    }
+    let timeout;
+    try {
+      return await Promise.race([
+        model.generate(input),
+        new Promise((_, reject) => {
+          timeout = setTimeout(() => reject(new VoiceProviderTimeoutError(provider, timeoutMs)), timeoutMs);
+        })
+      ]);
+    } finally {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+    }
+  };
+  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 runProvider(provider, model, input);
+          const providerHealth = recordProviderSuccess(provider);
+          await emit({
+            at: Date.now(),
+            attempt: index + 1,
+            elapsedMs: Date.now() - startedAt,
+            fallbackProvider: provider === selectedProvider ? undefined : provider,
+            latencyBudgetMs: getProviderTimeoutMs(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 timedOut = options.isTimeoutError?.(error, provider) ?? error instanceof VoiceProviderTimeoutError;
+          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(),
+            attempt: index + 1,
+            elapsedMs: Date.now() - startedAt,
+            error: errorMessage(error),
+            fallbackProvider: shouldFallback ? nextProvider : undefined,
+            latencyBudgetMs: getProviderTimeoutMs(provider),
+            provider,
+            providerHealth,
+            rateLimited,
+            selectedProvider,
+            suppressionRemainingMs: getSuppressionRemainingMs(provider),
+            suppressedUntil: providerHealth?.suppressedUntil,
+            status: "error",
+            timedOut
+          }, 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/opsConsoleRoutes.ts
+import { Elysia as Elysia9 } from "elysia";
+
+// src/handoffHealth.ts
+import { Elysia as Elysia6 } 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;
+};
+var normalizeDelivery = (adapterId, value) => {
+  const record = value && typeof value === "object" ? value : {};
+  return {
+    adapterId: getString5(record.adapterId) ?? adapterId,
+    adapterKind: getString5(record.adapterKind),
+    deliveredAt: typeof record.deliveredAt === "number" ? record.deliveredAt : undefined,
+    deliveredTo: getString5(record.deliveredTo),
+    error: getString5(record.error),
+    status: isStatus(record.status) ? record.status : "failed"
+  };
+};
+var normalizeDeliveries = (payload) => {
+  const deliveries = payload.deliveries;
+  if (!deliveries || typeof deliveries !== "object") {
+    return [];
+  }
+  return Object.entries(deliveries).map(([adapterId, value]) => normalizeDelivery(adapterId, value));
+};
+var resolveReplayHref = (event, replayHref) => {
+  if (replayHref === false) {
+    return;
+  }
+  if (typeof replayHref === "function") {
+    return replayHref(event);
+  }
+  return `${replayHref ?? "/api/voice-sessions"}/${encodeURIComponent(event.sessionId)}/replay/htmx`;
+};
+var summarizeVoiceHandoffHealth = async (options = {}) => {
+  const sourceEvents = options.events ?? await options.store?.list() ?? [];
+  const search = options.q?.trim().toLowerCase();
+  const byAction = {};
+  const byAdapter = {};
+  const byStatus = {
+    delivered: 0,
+    failed: 0,
+    skipped: 0
+  };
+  const events = sourceEvents.filter((event) => event.type === "call.handoff").map((event) => {
+    const status = isStatus(event.payload.status) ? event.payload.status : "failed";
+    const deliveries = normalizeDeliveries(event.payload);
+    const item = {
+      action: getString5(event.payload.action),
+      at: event.at,
+      deliveries,
+      reason: getString5(event.payload.reason),
+      sessionId: event.sessionId,
+      status,
+      target: getString5(event.payload.target)
+    };
+    return {
+      ...item,
+      replayHref: resolveReplayHref(item, options.replayHref)
+    };
+  }).filter((event) => {
+    if (options.status && options.status !== "all" && event.status !== options.status) {
+      return false;
+    }
+    if (!search) {
+      return true;
+    }
+    return [
+      event.action,
+      event.reason,
+      event.sessionId,
+      event.status,
+      event.target,
+      ...event.deliveries.flatMap((delivery) => [
+        delivery.adapterId,
+        delivery.adapterKind,
+        delivery.deliveredTo,
+        delivery.error,
+        delivery.status
+      ])
+    ].some((value) => value?.toLowerCase().includes(search));
+  }).sort((left, right) => right.at - left.at).slice(0, options.limit ?? 50);
+  for (const event of events) {
+    byStatus[event.status] += 1;
+    if (event.action) {
+      increment3(byAction, event.action);
+    }
+    for (const delivery of event.deliveries) {
+      byAdapter[delivery.adapterId] ??= {
+        delivered: 0,
+        failed: 0,
+        skipped: 0
+      };
+      byAdapter[delivery.adapterId][delivery.status] += 1;
+    }
+  }
+  return {
+    byAction,
+    byAdapter,
+    byStatus,
+    events,
+    failed: byStatus.failed,
+    total: events.length
+  };
+};
+var renderMetricGrid = (summary) => [
+  '<section class="voice-handoff-health-grid">',
+  `<article><span>Total</span><strong>${String(summary.total)}</strong></article>`,
+  `<article><span>Delivered</span><strong>${String(summary.byStatus.delivered)}</strong></article>`,
+  `<article><span>Failed</span><strong>${String(summary.byStatus.failed)}</strong></article>`,
+  `<article><span>Skipped</span><strong>${String(summary.byStatus.skipped)}</strong></article>`,
+  "</section>"
+].join("");
+var renderActionSummary = (summary) => {
+  const actions = Object.entries(summary.byAction).sort((left, right) => right[1] - left[1]);
+  const adapters = Object.entries(summary.byAdapter).sort(([left], [right]) => left.localeCompare(right));
+  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>${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>${escapeHtml8(adapterId)}: ${String(counts.delivered)} delivered / ${String(counts.failed)} failed / ${String(counts.skipped)} skipped</li>`).join("")}</ul>`,
+    "</article>",
+    "</section>"
+  ].join("");
+};
+var renderVoiceHandoffHealthHTML = (summary) => [
+  '<div class="voice-handoff-health">',
+  renderMetricGrid(summary),
+  renderActionSummary(summary),
+  "<section>",
+  "<h3>Recent Handoffs</h3>",
+  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="${escapeHtml8(event.status)}">`,
+      '<div class="voice-handoff-health-event-header">',
+      `<strong>${escapeHtml8(event.action ?? "handoff")}</strong>`,
+      `<span>${escapeHtml8(event.status)}</span>`,
+      "</div>",
+      `<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>",
+        `${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="${escapeHtml8(event.replayHref)}">Open replay</a></p>` : "",
+      "</article>"
+    ].join("")),
+    "</div>"
+  ].join(""),
+  "</section>",
+  "</div>"
+].join("");
+var createVoiceHandoffHealthJSONHandler = (options = {}) => async ({ query }) => summarizeVoiceHandoffHealth({
+  ...options,
+  limit: typeof query?.limit === "string" ? Number(query.limit) : options.limit,
+  q: query?.q ?? options.q,
+  status: query?.status === "delivered" || query?.status === "failed" || query?.status === "skipped" || query?.status === "all" ? query.status : options.status
+});
+var createVoiceHandoffHealthHTMLHandler = (options = {}) => async ({ query }) => {
+  const summary = await summarizeVoiceHandoffHealth({
+    ...options,
+    limit: typeof query?.limit === "string" ? Number(query.limit) : options.limit,
+    q: query?.q ?? options.q,
+    status: query?.status === "delivered" || query?.status === "failed" || query?.status === "skipped" || query?.status === "all" ? query.status : options.status
+  });
+  const body = await (options.render?.(summary) ?? renderVoiceHandoffHealthHTML(summary));
+  return new Response(body, {
+    headers: {
+      "Content-Type": "text/html; charset=utf-8",
+      ...options.headers
+    }
+  });
+};
+var createVoiceHandoffHealthRoutes = (options = {}) => {
+  const path = options.path ?? "/api/voice-handoffs";
+  const htmlPath = options.htmlPath === undefined ? `${path}/htmx` : options.htmlPath;
+  const routes = new Elysia6({
+    name: options.name ?? "absolutejs-voice-handoff-health"
+  }).get(path, createVoiceHandoffHealthJSONHandler(options));
+  if (htmlPath) {
+    routes.get(htmlPath, createVoiceHandoffHealthHTMLHandler(options));
+  }
+  return routes;
+};
+
+// src/qualityRoutes.ts
+import { Elysia as Elysia7 } from "elysia";
+var DEFAULT_THRESHOLDS = {
+  maxDuplicateTurnRate: 0,
+  maxEmptyTurnRate: 0.02,
+  maxHandoffFailureRate: 0,
+  maxMissingAssistantReplyRate: 0.05,
+  maxProviderAverageLatencyMs: 3000,
+  maxProviderErrorRate: 0.05,
+  maxProviderFallbackRate: 0.25,
+  maxProviderTimeoutRate: 0.03
+};
+var getString6 = (value) => typeof value === "string" ? value : undefined;
+var getNumber3 = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+var rate = (count, total) => count / Math.max(1, total);
+var roundMetric2 = (value) => Math.round(value * 1e4) / 1e4;
+var createMetric = (input) => ({
+  ...input,
+  actual: roundMetric2(input.actual),
+  pass: input.actual <= input.threshold
+});
+var evaluateVoiceQuality = async (input) => {
+  const events = filterVoiceTraceEvents(input.events ?? await input.store?.list() ?? []);
+  const thresholds = {
+    ...DEFAULT_THRESHOLDS,
+    ...input.thresholds
+  };
+  const committedTurns = events.filter((event) => event.type === "turn.committed");
+  const assistantReplies = events.filter((event) => event.type === "turn.assistant");
+  const sessionIdsWithAssistantReply = new Set(assistantReplies.map((event) => event.sessionId));
+  const sessionsWithTurns = new Set(committedTurns.map((event) => event.sessionId));
+  const emptyTurns = committedTurns.filter((event) => !getString6(event.payload.text)?.trim());
+  const turnTextsBySession = new Map;
+  let duplicateTurns = 0;
+  for (const turn of committedTurns) {
+    const normalized = getString6(turn.payload.text)?.trim().toLowerCase();
+    if (!normalized) {
+      continue;
+    }
+    const seen = turnTextsBySession.get(turn.sessionId) ?? new Set;
+    if (seen.has(normalized)) {
+      duplicateTurns += 1;
+    }
+    seen.add(normalized);
+    turnTextsBySession.set(turn.sessionId, seen);
+  }
+  const missingAssistantReplySessions = [...sessionsWithTurns].filter((sessionId) => !sessionIdsWithAssistantReply.has(sessionId)).length;
+  const providerEvents = events.filter((event) => event.type === "session.error" && typeof event.payload.provider === "string" && typeof event.payload.providerStatus === "string");
+  const providerErrors = providerEvents.filter((event) => event.payload.providerStatus === "error");
+  const providerFallbacks = providerEvents.filter((event) => event.payload.providerStatus === "fallback");
+  const providerTimeouts = providerEvents.filter((event) => event.payload.timedOut === true);
+  const providerLatencies = providerEvents.map((event) => getNumber3(event.payload.elapsedMs)).filter((value) => value !== undefined);
+  const averageProviderLatencyMs = providerLatencies.length > 0 ? providerLatencies.reduce((sum, value) => sum + value, 0) / providerLatencies.length : 0;
+  const handoffHealth = await summarizeVoiceHandoffHealth({ events });
+  const metrics = {
+    duplicateTurnRate: createMetric({
+      actual: rate(duplicateTurns, committedTurns.length),
+      label: "Duplicate turn rate",
+      threshold: thresholds.maxDuplicateTurnRate,
+      unit: "rate"
+    }),
+    emptyTurnRate: createMetric({
+      actual: rate(emptyTurns.length, committedTurns.length),
+      label: "Empty turn rate",
+      threshold: thresholds.maxEmptyTurnRate,
+      unit: "rate"
+    }),
+    handoffFailureRate: createMetric({
+      actual: rate(handoffHealth.failed, handoffHealth.total),
+      label: "Handoff failure rate",
+      threshold: thresholds.maxHandoffFailureRate,
+      unit: "rate"
+    }),
+    missingAssistantReplyRate: createMetric({
+      actual: rate(missingAssistantReplySessions, sessionsWithTurns.size),
+      label: "Missing assistant reply rate",
+      threshold: thresholds.maxMissingAssistantReplyRate,
+      unit: "rate"
+    }),
+    providerAverageLatencyMs: createMetric({
+      actual: averageProviderLatencyMs,
+      label: "Average provider latency",
+      threshold: thresholds.maxProviderAverageLatencyMs,
+      unit: "ms"
+    }),
+    providerErrorRate: createMetric({
+      actual: rate(providerErrors.length, providerEvents.length),
+      label: "Provider error rate",
+      threshold: thresholds.maxProviderErrorRate,
+      unit: "rate"
+    }),
+    providerFallbackRate: createMetric({
+      actual: rate(providerFallbacks.length, providerEvents.length),
+      label: "Provider fallback rate",
+      threshold: thresholds.maxProviderFallbackRate,
+      unit: "rate"
+    }),
+    providerTimeoutRate: createMetric({
+      actual: rate(providerTimeouts.length, providerEvents.length),
+      label: "Provider timeout rate",
+      threshold: thresholds.maxProviderTimeoutRate,
+      unit: "rate"
+    })
+  };
+  const status = Object.values(metrics).every((metric) => metric.pass) ? "pass" : "fail";
+  return {
+    checkedAt: Date.now(),
+    eventCount: events.length,
+    metrics,
+    status,
+    thresholds
+  };
+};
+var escapeHtml9 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var formatMetricValue = (metric) => metric.unit === "rate" ? `${(metric.actual * 100).toFixed(2)}%` : metric.unit === "ms" ? `${Math.round(metric.actual)}ms` : String(metric.actual);
+var formatThreshold = (metric) => metric.unit === "rate" ? `${(metric.threshold * 100).toFixed(2)}%` : metric.unit === "ms" ? `${Math.round(metric.threshold)}ms` : String(metric.threshold);
+var renderVoiceQualityHTML = (report, options = {}) => {
+  const rows = Object.entries(report.metrics).map(([key, metric]) => `<tr class="${metric.pass ? "pass" : "fail"}"><td>${escapeHtml9(metric.label)}</td><td>${escapeHtml9(formatMetricValue(metric))}</td><td>${escapeHtml9(formatThreshold(metric))}</td><td>${metric.pass ? "pass" : "fail"}</td><td><code>${escapeHtml9(key)}</code></td></tr>`).join("");
+  const links = options.links?.length ? `<nav>${options.links.map((link) => `<a href="${escapeHtml9(link.href)}">${escapeHtml9(link.label)}</a>`).join("")}</nav>` : "";
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" /><title>AbsoluteJS Voice Quality</title><style>body{font-family:ui-sans-serif,system-ui,sans-serif;margin:2rem;background:#f8f7f2;color:#181713}main{max-width:1100px;margin:auto}nav{display:flex;flex-wrap:wrap;gap:.5rem;margin:0 0 1.25rem}nav a{background:#181713;border-radius:999px;color:white;padding:.35rem .7rem;text-decoration:none}.status{border-radius:999px;display:inline-flex;padding:.35rem .75rem;font-weight:800}.status.pass{background:#dcfce7;color:#166534}.status.fail{background:#fee2e2;color:#991b1b}table{border-collapse:collapse;width:100%;background:white;margin-top:1rem}td,th{border-bottom:1px solid #eee;padding:.75rem;text-align:left}.pass td{border-left:4px solid #16a34a}.fail td{border-left:4px solid #dc2626}code{background:#f3f4f6;padding:.15rem .3rem;border-radius:.3rem}</style></head><body><main>${links}<h1>Voice quality gates</h1><p class="status ${report.status}">${report.status}</p><p>${report.eventCount} event(s) checked.</p><table><thead><tr><th>Metric</th><th>Actual</th><th>Threshold</th><th>Status</th><th>Key</th></tr></thead><tbody>${rows}</tbody></table></main></body></html>`;
+};
+var createVoiceQualityRoutes = (options) => {
+  const path = options.path ?? "/quality";
+  const routes = new Elysia7({
+    name: options.name ?? "absolutejs-voice-quality"
+  });
+  const getReport = () => evaluateVoiceQuality({
+    events: options.events,
+    store: options.store,
+    thresholds: options.thresholds
+  });
+  routes.get(path, async () => {
+    const report = await getReport();
+    return new Response(renderVoiceQualityHTML(report, { links: options.links }), {
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+        ...options.headers
+      }
+    });
+  });
+  routes.get(`${path}/json`, async () => getReport());
+  routes.get(`${path}/status`, async ({ set }) => {
+    const report = await getReport();
+    if (report.status === "fail") {
+      set.status = 503;
+    }
+    return report;
+  });
+  return routes;
+};
+
+// src/resilienceRoutes.ts
+import { Elysia as Elysia8 } from "elysia";
+var escapeHtml10 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var getString7 = (value) => typeof value === "string" ? value : undefined;
+var getNumber4 = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+var getBoolean2 = (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 = getString7(event.payload.provider);
+    const providerStatus = isProviderStatus2(event.payload.providerStatus) ? event.payload.providerStatus : undefined;
+    if (!provider || !providerStatus) {
+      continue;
+    }
+    const kind = getString7(event.payload.kind);
+    routingEvents.push({
+      at: event.at,
+      attempt: getNumber4(event.payload.attempt),
+      elapsedMs: getNumber4(event.payload.elapsedMs),
+      error: getString7(event.payload.error),
+      fallbackProvider: getString7(event.payload.fallbackProvider),
+      kind: kind === "stt" || kind === "tts" ? kind : "llm",
+      latencyBudgetMs: getNumber4(event.payload.latencyBudgetMs),
+      operation: getString7(event.payload.operation),
+      provider,
+      selectedProvider: getString7(event.payload.selectedProvider),
+      sessionId: event.sessionId,
+      status: providerStatus,
+      timedOut: getBoolean2(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 ${escapeHtml10(title)} provider health yet.</p>`;
+  }
+  return `<div class="provider-grid">${providers.map((provider) => `
+        <article class="card provider ${escapeHtml10(provider.status)}">
+          <div class="card-header">
+            <strong>${escapeHtml10(provider.provider)}</strong>
+            <span>${escapeHtml10(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">${escapeHtml10(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 ${escapeHtml10(event.status ?? "unknown")}">
+          <div class="card-header">
+            <strong>${escapeHtml10(event.kind.toUpperCase())} ${escapeHtml10(event.operation ?? "generate")}</strong>
+            <span>${new Date(event.at).toLocaleString()}</span>
+          </div>
+          <p>
+            <span class="pill">${escapeHtml10(event.status ?? "unknown")}</span>
+            <span class="pill">provider: ${escapeHtml10(event.provider ?? "unknown")}</span>
+            ${event.fallbackProvider ? `<span class="pill">fallback: ${escapeHtml10(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>${escapeHtml10(event.sessionId)}</dd></div>
+          </dl>
+          ${event.error ? `<p class="muted">${escapeHtml10(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="${escapeHtml10(pathPrefix)}">
+    <p class="muted">${escapeHtml10(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="${escapeHtml10(provider)}"${canFail(provider) ? "" : " disabled"}>Simulate ${escapeHtml10(provider)} ${kind.toUpperCase()} failure</button>`).join("")}
+      ${configuredProviders.map((provider) => `<button type="button" data-provider-recover="${escapeHtml10(provider.provider)}">Mark ${escapeHtml10(provider.provider)} recovered</button>`).join("")}
+    </div>
+    ${simulation.fallbackRequiredProvider && !configuredProviders.some((entry) => entry.provider === simulation.fallbackRequiredProvider) ? `<p class="muted">${escapeHtml10(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">${escapeHtml10(kind)}: ${String(count)}</span>`).join("");
+  const links = input.links?.length ? input.links.map((link) => `<a href="${escapeHtml10(link.href)}">${escapeHtml10(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>${escapeHtml10(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 Elysia8({
+    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/opsConsoleRoutes.ts
+var DEFAULT_LINKS = [
+  {
+    description: "Quality gates for CI, deploy checks, and production readiness.",
+    href: "/quality",
+    label: "Quality",
+    statusHref: "/quality/status"
+  },
+  {
+    description: "Provider health, fallback paths, and failure simulation.",
+    href: "/resilience",
+    label: "Resilience"
+  },
+  {
+    description: "Redacted trace exports for debugging and support handoffs.",
+    href: "/diagnostics",
+    label: "Diagnostics"
+  },
+  {
+    description: "Recent sessions with replay links.",
+    href: "/sessions",
+    label: "Sessions"
+  },
+  {
+    description: "Transfer and webhook delivery health.",
+    href: "/handoffs",
+    label: "Handoffs"
+  }
+];
+var escapeHtml11 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var countProviderStatuses = (providers) => {
+  const degradedStatuses = new Set(["degraded", "rate-limited", "suppressed"]);
+  const healthy = providers.filter((provider) => provider.status === "healthy").length;
+  const degraded = providers.filter((provider) => degradedStatuses.has(provider.status)).length;
+  return {
+    degraded,
+    healthy,
+    total: providers.length
+  };
+};
+var buildVoiceOpsConsoleReport = async (options) => {
+  const events = await options.store.list();
+  const providers = [
+    ...await summarizeVoiceProviderHealth({
+      events,
+      providers: options.llmProviders
+    }),
+    ...await summarizeVoiceProviderHealth({
+      events,
+      providers: options.sttProviders
+    }),
+    ...await summarizeVoiceProviderHealth({
+      events,
+      providers: options.ttsProviders
+    })
+  ];
+  const handoffs = await summarizeVoiceHandoffHealth({ events });
+  const sessions = await summarizeVoiceSessions({
+    events,
+    limit: 8,
+    status: "all"
+  });
+  const quality = await evaluateVoiceQuality({ events });
+  const routingEvents = listVoiceRoutingEvents(events).slice(0, 10);
+  const trace = summarizeVoiceTrace(events);
+  return {
+    checkedAt: Date.now(),
+    eventCount: events.length,
+    handoffs: {
+      failed: handoffs.failed,
+      total: handoffs.total
+    },
+    links: options.links ?? DEFAULT_LINKS,
+    providers: countProviderStatuses(providers),
+    quality,
+    recentRoutingEvents: routingEvents,
+    recentSessions: sessions,
+    sessions: {
+      failed: sessions.filter((session) => session.status === "failed").length,
+      healthy: sessions.filter((session) => session.status === "healthy").length,
+      total: sessions.length
+    },
+    trace
+  };
+};
+var renderMetricCard = (input) => `<article class="metric"><span>${escapeHtml11(input.label)}</span><strong>${escapeHtml11(String(input.value))}</strong>${input.status ? `<p class="${escapeHtml11(input.status)}">${escapeHtml11(input.status)}</p>` : ""}${input.href ? `<a href="${escapeHtml11(input.href)}">Open</a>` : ""}</article>`;
+var renderVoiceOpsConsoleHTML = (report, options = {}) => {
+  const links = report.links.map((link) => `<article class="surface">
+<div><h2>${escapeHtml11(link.label)}</h2>${link.description ? `<p>${escapeHtml11(link.description)}</p>` : ""}</div>
+<p><a href="${escapeHtml11(link.href)}">Open ${escapeHtml11(link.label)}</a>${link.statusHref ? ` \xB7 <a href="${escapeHtml11(link.statusHref)}">Status</a>` : ""}</p>
+</article>`).join("");
+  const sessions = report.recentSessions.length ? report.recentSessions.map((session) => `<tr><td>${escapeHtml11(session.sessionId)}</td><td>${escapeHtml11(session.status)}</td><td>${session.turnCount}</td><td>${session.errorCount}</td><td>${session.replayHref ? `<a href="${escapeHtml11(session.replayHref)}">Replay</a>` : ""}</td></tr>`).join("") : '<tr><td colspan="5">No sessions yet.</td></tr>';
+  const routing = report.recentRoutingEvents.length ? report.recentRoutingEvents.map((event) => `<tr><td>${escapeHtml11(event.kind)}</td><td>${escapeHtml11(event.provider ?? "unknown")}</td><td>${escapeHtml11(event.status ?? "unknown")}</td><td>${event.elapsedMs ?? 0}ms</td><td>${escapeHtml11(event.sessionId)}</td></tr>`).join("") : '<tr><td colspan="5">No provider routing events yet.</td></tr>';
+  const title = options.title ?? "AbsoluteJS Voice Ops Console";
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" /><title>${escapeHtml11(title)}</title><style>body{font-family:ui-sans-serif,system-ui,sans-serif;background:#101316;color:#f6f2e8;margin:0}main{max-width:1180px;margin:auto;padding:32px}a{color:#fbbf24}header{display:flex;justify-content:space-between;gap:24px;align-items:flex-start;margin-bottom:24px}.eyebrow{color:#fbbf24;font-weight:800;letter-spacing:.08em;text-transform:uppercase}h1{font-size:clamp(2.2rem,5vw,4.5rem);line-height:.95;margin:.2rem 0 1rem}.muted{color:#a8b0b8}.grid{display:grid;gap:14px;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));margin:20px 0}.metric,.surface{background:#181d22;border:1px solid #2a323a;border-radius:20px;padding:18px}.metric strong{display:block;font-size:2.2rem;margin:.25rem 0}.pass,.healthy{color:#86efac}.fail,.failed,.degraded{color:#fca5a5}.surfaces{display:grid;gap:16px;grid-template-columns:repeat(auto-fit,minmax(240px,1fr));margin:24px 0}table{width:100%;border-collapse:collapse;background:#181d22;border-radius:16px;overflow:hidden;margin:12px 0 28px}td,th{border-bottom:1px solid #2a323a;padding:12px;text-align:left}section{margin-top:30px}@media(max-width:700px){main{padding:20px}header{display:block}}</style></head><body><main><header><div><p class="eyebrow">Self-hosted voice operations</p><h1>${escapeHtml11(title)}</h1><p class="muted">One deployable control plane for quality gates, failover, traces, sessions, handoffs, and provider health.</p></div><p class="muted">Checked ${escapeHtml11(new Date(report.checkedAt).toLocaleString())}</p></header><div class="grid">${renderMetricCard({ label: "Quality", value: report.quality.status, status: report.quality.status, href: "/quality" })}${renderMetricCard({ label: "Events", value: report.eventCount, href: "/diagnostics" })}${renderMetricCard({ label: "Sessions", value: report.sessions.total, status: report.sessions.failed > 0 ? "failed" : "healthy", href: "/sessions" })}${renderMetricCard({ label: "Handoffs failed", value: report.handoffs.failed, status: report.handoffs.failed > 0 ? "failed" : "healthy", href: "/handoffs" })}${renderMetricCard({ label: "Providers degraded", value: report.providers.degraded, status: report.providers.degraded > 0 ? "degraded" : "healthy", href: "/resilience" })}</div><section><h2>Operational Surfaces</h2><div class="surfaces">${links}</div></section><section><h2>Recent Sessions</h2><table><thead><tr><th>Session</th><th>Status</th><th>Turns</th><th>Errors</th><th>Replay</th></tr></thead><tbody>${sessions}</tbody></table></section><section><h2>Recent Provider Routing</h2><table><thead><tr><th>Kind</th><th>Provider</th><th>Status</th><th>Elapsed</th><th>Session</th></tr></thead><tbody>${routing}</tbody></table></section></main></body></html>`;
+};
+var createVoiceOpsConsoleRoutes = (options) => {
+  const path = options.path ?? "/ops-console";
+  const routes = new Elysia9({
+    name: options.name ?? "absolutejs-voice-ops-console"
+  });
+  const getReport = () => buildVoiceOpsConsoleReport(options);
+  routes.get(path, async () => {
+    const report = await getReport();
+    return new Response(renderVoiceOpsConsoleHTML(report, { title: options.title }), {
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+        ...options.headers
+      }
+    });
+  });
+  routes.get(`${path}/json`, async () => getReport());
+  return routes;
+};
+// src/providerAdapters.ts
+class VoiceIOProviderTimeoutError extends Error {
+  provider;
+  timeoutMs;
+  constructor(kind, provider, timeoutMs) {
+    super(`Voice ${kind} provider ${provider} exceeded ${timeoutMs}ms latency budget.`);
+    this.name = "VoiceIOProviderTimeoutError";
+    this.provider = provider;
+    this.timeoutMs = timeoutMs;
+  }
+}
+var errorMessage2 = (error) => error instanceof Error ? error.message : String(error);
+var createEmitter = () => {
+  const listeners = new Map;
+  return {
+    emit: async (event, payload) => {
+      await Promise.all([...listeners.get(event) ?? []].map((handler) => Promise.resolve(handler(payload))));
+    },
+    on: (event, handler) => {
+      const set = listeners.get(event) ?? new Set;
+      set.add(handler);
+      listeners.set(event, set);
+      return () => {
+        set.delete(handler);
+      };
+    }
+  };
+};
+var getTimeoutMs = (options, provider) => {
+  const timeoutMs = options.providerProfiles?.[provider]?.timeoutMs ?? options.timeoutMs;
+  return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined;
+};
+var withTimeout = async (input) => {
+  if (!input.timeoutMs) {
+    return input.run();
+  }
+  let timeout;
+  try {
+    return await Promise.race([
+      Promise.resolve(input.run()),
+      new Promise((_, reject) => {
+        timeout = setTimeout(() => reject(new VoiceIOProviderTimeoutError(input.kind, input.provider, input.timeoutMs)), input.timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  }
+};
+var createResolver = (options) => {
+  const providerIds = Object.keys(options.adapters);
+  const firstProvider = providerIds[0];
+  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 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 suppressedUntil = getHealth(provider).suppressedUntil;
+    return typeof suppressedUntil === "number" && suppressedUntil > now();
+  };
+  const recordSuccess = (provider) => {
+    if (!healthOptions) {
+      return;
+    }
+    const health = getHealth(provider);
+    health.consecutiveFailures = 0;
+    health.status = "healthy";
+    health.suppressedUntil = undefined;
+    return cloneHealth(provider);
+  };
+  const recordError = (provider, isProviderError) => {
+    if (!healthOptions || !isProviderError) {
+      return cloneHealth(provider);
+    }
+    const health = getHealth(provider);
+    health.consecutiveFailures += 1;
+    health.lastFailureAt = now();
+    if (health.consecutiveFailures >= failureThreshold) {
+      health.status = "suppressed";
+      health.suppressedUntil = now() + cooldownMs;
+    }
+    return cloneHealth(provider);
+  };
+  const resolveOrder = async (input) => {
+    const selectedProvider = await options.selectProvider?.(input) ?? firstProvider;
+    const fallbackOrder = typeof options.fallback === "function" ? await options.fallback(input) : options.fallback;
+    const candidates = [selectedProvider, ...fallbackOrder ?? providerIds];
+    const seen = new Set;
+    const rankedOrder = candidates.filter((provider) => {
+      if (!provider || seen.has(provider) || !options.adapters[provider]) {
+        return false;
+      }
+      seen.add(provider);
+      return true;
+    });
+    const healthyOrder = healthOptions ? rankedOrder.filter((provider) => !isSuppressed(provider)) : rankedOrder;
+    const order = healthyOrder.length ? healthyOrder : rankedOrder;
+    return {
+      order,
+      selectedProvider: selectedProvider && !isSuppressed(selectedProvider) ? selectedProvider : order[0]
+    };
+  };
+  const emit = async (event, input) => {
+    await options.onProviderEvent?.(event, input);
+  };
+  return {
+    emit,
+    getSuppressionRemainingMs,
+    providerIds,
+    recordError,
+    recordSuccess,
+    resolveOrder
+  };
+};
+var createVoiceSTTProviderRouter = (options) => {
+  const resolver = createResolver(options);
+  return {
+    kind: "stt",
+    open: async (input) => {
+      const { order, selectedProvider } = await resolver.resolveOrder(input);
+      if (!selectedProvider || order.length === 0) {
+        throw new Error("Voice STT provider router has no available providers.");
+      }
+      let lastError;
+      for (const [index, provider] of order.entries()) {
+        const adapter = options.adapters[provider];
+        if (!adapter) {
+          continue;
+        }
+        const startedAt = Date.now();
+        try {
+          const session = await withTimeout({
+            kind: "stt",
+            operation: "open",
+            provider,
+            run: () => adapter.open(input),
+            timeoutMs: getTimeoutMs(options, provider)
+          });
+          const providerHealth = resolver.recordSuccess(provider);
+          await resolver.emit({
+            at: Date.now(),
+            attempt: index + 1,
+            elapsedMs: Date.now() - startedAt,
+            fallbackProvider: provider === selectedProvider ? undefined : provider,
+            kind: "stt",
+            latencyBudgetMs: getTimeoutMs(options, provider),
+            operation: "open",
+            provider,
+            providerHealth,
+            selectedProvider,
+            status: provider === selectedProvider ? "success" : "fallback"
+          }, input);
+          return session;
+        } catch (error) {
+          lastError = error;
+          const hasNextProvider = index < order.length - 1;
+          const shouldFallback = options.isProviderError?.(error, provider) ?? true;
+          const providerHealth = resolver.recordError(provider, shouldFallback);
+          await resolver.emit({
+            at: Date.now(),
+            attempt: index + 1,
+            elapsedMs: Date.now() - startedAt,
+            error: errorMessage2(error),
+            fallbackProvider: shouldFallback ? order[index + 1] : undefined,
+            kind: "stt",
+            latencyBudgetMs: getTimeoutMs(options, provider),
+            operation: "open",
+            provider,
+            providerHealth,
+            selectedProvider,
+            status: "error",
+            suppressionRemainingMs: resolver.getSuppressionRemainingMs(provider),
+            suppressedUntil: providerHealth?.suppressedUntil,
+            timedOut: error instanceof VoiceIOProviderTimeoutError
+          }, input);
+          if (!hasNextProvider || !shouldFallback) {
+            throw error;
+          }
+        }
+      }
+      throw lastError ?? new Error("Voice STT provider router did not open a provider.");
+    }
+  };
+};
+var createVoiceTTSProviderRouter = (options) => {
+  const resolver = createResolver(options);
+  return {
+    kind: "tts",
+    open: async (input) => {
+      const { order, selectedProvider } = await resolver.resolveOrder(input);
+      if (!selectedProvider || order.length === 0) {
+        throw new Error("Voice TTS provider router has no available providers.");
+      }
+      const emitter = createEmitter();
+      let activeSession;
+      let activeProvider;
+      let nextProviderIndex = 0;
+      const attach = (session) => {
+        session.on("audio", (event) => emitter.emit("audio", event));
+        session.on("error", (event) => emitter.emit("error", event));
+        session.on("close", (event) => emitter.emit("close", event));
+      };
+      const openProvider = async (provider, attempt) => {
+        const adapter = options.adapters[provider];
+        if (!adapter) {
+          throw new Error(`Voice TTS provider ${provider} is not configured.`);
+        }
+        const startedAt = Date.now();
+        const session = await withTimeout({
+          kind: "tts",
+          operation: "open",
+          provider,
+          run: () => adapter.open(input),
+          timeoutMs: getTimeoutMs(options, provider)
+        });
+        attach(session);
+        activeSession = session;
+        activeProvider = provider;
+        const providerHealth = resolver.recordSuccess(provider);
+        await resolver.emit({
+          at: Date.now(),
+          attempt,
+          elapsedMs: Date.now() - startedAt,
+          fallbackProvider: provider === selectedProvider ? undefined : provider,
+          kind: "tts",
+          latencyBudgetMs: getTimeoutMs(options, provider),
+          operation: "open",
+          provider,
+          providerHealth,
+          selectedProvider,
+          status: provider === selectedProvider ? "success" : "fallback"
+        }, input);
+        return session;
+      };
+      const failProvider = async (inputEvent) => {
+        const shouldFallback = options.isProviderError?.(inputEvent.error, inputEvent.provider) ?? true;
+        const providerHealth = resolver.recordError(inputEvent.provider, shouldFallback);
+        await resolver.emit({
+          at: Date.now(),
+          attempt: inputEvent.attempt,
+          elapsedMs: Date.now() - inputEvent.startedAt,
+          error: errorMessage2(inputEvent.error),
+          fallbackProvider: shouldFallback ? order[nextProviderIndex] : undefined,
+          kind: "tts",
+          latencyBudgetMs: getTimeoutMs(options, inputEvent.provider),
+          operation: inputEvent.operation,
+          provider: inputEvent.provider,
+          providerHealth,
+          selectedProvider,
+          status: "error",
+          suppressionRemainingMs: resolver.getSuppressionRemainingMs(inputEvent.provider),
+          suppressedUntil: providerHealth?.suppressedUntil,
+          timedOut: inputEvent.error instanceof VoiceIOProviderTimeoutError
+        }, input);
+        return shouldFallback;
+      };
+      for (const [index, provider] of order.entries()) {
+        nextProviderIndex = index + 1;
+        const startedAt = Date.now();
+        try {
+          await openProvider(provider, index + 1);
+          break;
+        } catch (error) {
+          const shouldFallback = await failProvider({
+            attempt: index + 1,
+            error,
+            operation: "open",
+            provider,
+            startedAt
+          });
+          if (!shouldFallback || index >= order.length - 1) {
+            throw error;
+          }
+        }
+      }
+      if (!activeSession || !activeProvider) {
+        throw new Error("Voice TTS provider router did not open a provider.");
+      }
+      const sendWithFallback = async (text) => {
+        for (;; ) {
+          const session = activeSession;
+          const provider = activeProvider;
+          if (!session || !provider) {
+            throw new Error("Voice TTS provider router has no active provider.");
+          }
+          const startedAt = Date.now();
+          try {
+            await withTimeout({
+              kind: "tts",
+              operation: "send",
+              provider,
+              run: () => session.send(text),
+              timeoutMs: getTimeoutMs(options, provider)
+            });
+            return;
+          } catch (error) {
+            const shouldFallback = await failProvider({
+              attempt: nextProviderIndex,
+              error,
+              operation: "send",
+              provider,
+              startedAt
+            });
+            const nextProvider = order[nextProviderIndex];
+            if (!shouldFallback || !nextProvider) {
+              throw error;
+            }
+            nextProviderIndex += 1;
+            await session.close("tts-provider-fallback").catch(() => {});
+            await openProvider(nextProvider, nextProviderIndex);
+          }
+        }
+      };
+      return {
+        close: async (reason) => {
+          await activeSession?.close(reason);
+          activeSession = undefined;
+          activeProvider = undefined;
+          await emitter.emit("close", {
+            reason,
+            type: "close"
+          });
+        },
+        on: emitter.on,
+        send: sendWithFallback
+      };
+    }
+  };
 };
-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,
-    directory: join(options.directory, "sessions")
-  }),
-  tasks: createVoiceFileTaskStore({
-    ...options,
-    directory: join(options.directory, "tasks")
-  }),
-  traceDeliveries: createVoiceFileTraceSinkDeliveryStore({
-    ...options,
-    directory: join(options.directory, "trace-deliveries")
-  }),
-  traces: createVoiceFileTraceEventStore({
-    ...options,
-    directory: join(options.directory, "traces")
-  })
-});
-var createStoredVoiceCallReviewArtifact = (id, artifact) => withVoiceCallReviewId(id, artifact);
-var createStoredVoiceOpsTask = (id, task) => withVoiceOpsTaskId(id, task);
-var createStoredVoiceIntegrationEvent = (id, event) => withVoiceIntegrationEventId(id, event);
-var createStoredVoiceExternalObjectMap = (mapping) => createVoiceExternalObjectMap({
-  at: mapping.at,
-  externalId: mapping.externalId,
-  provider: mapping.provider,
-  sinkId: mapping.sinkId,
-  sourceId: mapping.sourceId,
-  sourceType: mapping.sourceType
-});
 // src/sqliteStore.ts
 import { Database } from "bun:sqlite";
 var normalizeTableNameSegment = (value) => value.trim().replace(/[^a-zA-Z0-9_]+/g, "_").replace(/^_+|_+$/g, "") || "voice";
@@ -7554,6 +10611,169 @@ var createVoiceMemoryStore = () => {
   };
   return { get, getOrCreate, list, remove, set };
 };
+// src/opsWebhook.ts
+import { Elysia as Elysia10 } from "elysia";
+var toHex5 = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+var signVoiceOpsWebhookBody = async (input) => {
+  const encoder = new TextEncoder;
+  const key = await crypto.subtle.importKey("raw", encoder.encode(input.secret), {
+    hash: "SHA-256",
+    name: "HMAC"
+  }, false, ["sign"]);
+  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(`${input.timestamp}.${input.body}`));
+  return `sha256=${toHex5(new Uint8Array(signature))}`;
+};
+var timingSafeEqual = (left, right) => {
+  const encoder = new TextEncoder;
+  const leftBytes = encoder.encode(left);
+  const rightBytes = encoder.encode(right);
+  if (leftBytes.length !== rightBytes.length) {
+    return false;
+  }
+  let diff = 0;
+  for (let index = 0;index < leftBytes.length; index += 1) {
+    diff |= leftBytes[index] ^ rightBytes[index];
+  }
+  return diff === 0;
+};
+var resolveWebhookLink = async (resolver, event) => {
+  if (typeof resolver === "function") {
+    return resolver({
+      event
+    });
+  }
+  return resolver;
+};
+var joinBaseUrl = (baseUrl, path) => `${baseUrl.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+var asString = (value) => typeof value === "string" && value.length > 0 ? value : undefined;
+var buildVoiceOpsWebhookEntity = (event) => ({
+  disposition: asString(event.payload.disposition),
+  outcome: asString(event.payload.outcome),
+  priority: asString(event.payload.priority),
+  queue: asString(event.payload.queue),
+  reviewId: asString(event.payload.reviewId),
+  scenarioId: asString(event.payload.scenarioId),
+  sessionId: asString(event.payload.sessionId),
+  status: asString(event.payload.status),
+  target: asString(event.payload.target),
+  taskId: asString(event.payload.taskId)
+});
+var createVoiceOpsWebhookEnvelope = async (input) => {
+  const entity = buildVoiceOpsWebhookEntity(input.event);
+  const replayHref = await resolveWebhookLink(input.replayHref, input.event) ?? (input.baseUrl && entity.sessionId ? joinBaseUrl(input.baseUrl, `/api/voice-sessions/${encodeURIComponent(entity.sessionId)}/replay`) : undefined);
+  const links = {
+    event: await resolveWebhookLink(input.eventHref, input.event),
+    replay: replayHref,
+    review: await resolveWebhookLink(input.reviewHref, input.event),
+    task: await resolveWebhookLink(input.taskHref, input.event)
+  };
+  return {
+    entity,
+    event: {
+      createdAt: input.event.createdAt,
+      id: input.event.id,
+      payload: input.event.payload,
+      type: input.event.type
+    },
+    links: links.event || links.replay || links.review || links.task ? links : undefined,
+    schemaVersion: 1,
+    source: "absolutejs-voice"
+  };
+};
+var createVoiceOpsWebhookSink = (options) => createVoiceIntegrationHTTPSink({
+  ...options,
+  body: ({ event }) => createVoiceOpsWebhookEnvelope({
+    baseUrl: options.baseUrl,
+    event,
+    eventHref: options.eventHref,
+    replayHref: options.replayHref,
+    reviewHref: options.reviewHref,
+    taskHref: options.taskHref
+  }),
+  kind: options.kind ?? "ops-webhook"
+});
+var verifyVoiceOpsWebhookSignature = async (input) => {
+  if (!input.secret) {
+    return {
+      ok: false,
+      reason: "missing-secret"
+    };
+  }
+  if (!input.signature) {
+    return {
+      ok: false,
+      reason: "missing-signature"
+    };
+  }
+  if (!input.signature.startsWith("sha256=")) {
+    return {
+      ok: false,
+      reason: "unsupported-algorithm"
+    };
+  }
+  if (!input.timestamp) {
+    return {
+      ok: false,
+      reason: "missing-timestamp"
+    };
+  }
+  const timestampMs = Number(input.timestamp);
+  const toleranceMs = Math.max(0, input.toleranceMs ?? 5 * 60 * 1000);
+  if (!Number.isFinite(timestampMs) || toleranceMs > 0 && Math.abs((input.now ?? Date.now()) - timestampMs) > toleranceMs) {
+    return {
+      ok: false,
+      reason: "stale-timestamp"
+    };
+  }
+  const expected = await signVoiceOpsWebhookBody({
+    body: input.body,
+    secret: input.secret,
+    timestamp: input.timestamp
+  });
+  if (!timingSafeEqual(expected, input.signature)) {
+    return {
+      ok: false,
+      reason: "invalid-signature"
+    };
+  }
+  return {
+    ok: true
+  };
+};
+var createVoiceOpsWebhookReceiverRoutes = (options = {}) => {
+  const path = options.path ?? "/api/voice-ops/webhook";
+  return new Elysia10().post(path, async ({ body, request, set }) => {
+    const bodyText = typeof body === "string" ? body : JSON.stringify(body);
+    if (options.signingSecret) {
+      const verification = await verifyVoiceOpsWebhookSignature({
+        body: bodyText,
+        secret: options.signingSecret,
+        signature: request.headers.get("x-absolutejs-signature"),
+        timestamp: request.headers.get("x-absolutejs-timestamp"),
+        toleranceMs: options.toleranceMs
+      });
+      if (!verification.ok) {
+        set.status = 401;
+        return {
+          ok: false,
+          reason: verification.reason
+        };
+      }
+    }
+    const envelope = JSON.parse(bodyText);
+    await options.onEnvelope?.({
+      envelope,
+      request
+    });
+    return {
+      eventId: envelope.event?.id,
+      ok: true,
+      type: envelope.event?.type
+    };
+  }, {
+    parse: "text"
+  });
+};
 // src/queue.ts
 var releaseLeaseScript = `
 if redis.call("GET", KEYS[1]) == ARGV[1] then
@@ -7625,6 +10845,8 @@ var shouldDeadLetterSinkEvent = (event, sinks, maxFailures) => typeof maxFailure
 var shouldDeadLetterTask = (task, maxFailures) => typeof maxFailures === "number" && maxFailures > 0 && (task.processingAttempts ?? 0) >= maxFailures;
 var shouldProcessTraceDeliveryStatus = (status, allowed) => allowed.includes(status);
 var shouldDeadLetterTraceDelivery = (delivery, maxFailures) => typeof maxFailures === "number" && maxFailures > 0 && (delivery.deliveryAttempts ?? 0) >= maxFailures;
+var shouldProcessHandoffDeliveryStatus = (status, allowed) => allowed.includes(status);
+var shouldDeadLetterHandoffDelivery = (delivery, maxFailures) => typeof maxFailures === "number" && maxFailures > 0 && (delivery.deliveryAttempts ?? 0) >= maxFailures;
 var summarizeVoiceIntegrationEvents = (events, input = {}) => {
   const buildSummary = async () => {
     const deadLetterIds = new Set(input.deadLetters ? (await input.deadLetters.list()).map((event) => event.id) : []);
@@ -7706,6 +10928,48 @@ var summarizeVoiceTraceSinkDeliveries = (deliveries, input = {}) => {
   };
   return buildSummary();
 };
+var summarizeVoiceHandoffDeliveries = (deliveries, input = {}) => {
+  const buildSummary = async () => {
+    const deadLetterIds = new Set(input.deadLetters ? (await input.deadLetters.list()).map((delivery) => delivery.id) : []);
+    const byAction = new Map;
+    const summary = {
+      byAction: [],
+      deadLettered: 0,
+      delivered: 0,
+      failed: 0,
+      pending: 0,
+      retryEligible: 0,
+      skipped: 0,
+      total: deliveries.length
+    };
+    for (const delivery of deliveries) {
+      byAction.set(delivery.action, (byAction.get(delivery.action) ?? 0) + 1);
+      if (deadLetterIds.has(delivery.id)) {
+        summary.deadLettered += 1;
+      }
+      switch (delivery.deliveryStatus) {
+        case "delivered":
+          summary.delivered += 1;
+          break;
+        case "failed":
+          summary.failed += 1;
+          if ((delivery.deliveryAttempts ?? 0) > 0) {
+            summary.retryEligible += 1;
+          }
+          break;
+        case "skipped":
+          summary.skipped += 1;
+          break;
+        case "pending":
+          summary.pending += 1;
+          break;
+      }
+    }
+    summary.byAction = [...byAction.entries()].sort((left, right) => right[1] - left[1]);
+    return summary;
+  };
+  return buildSummary();
+};
 var summarizeVoiceOpsTaskQueue = (tasks, input = {}) => {
   const buildSummary = async () => {
     const deadLetterIds = new Set(input.deadLetters ? (await input.deadLetters.list()).map((task) => task.id) : []);
@@ -8135,6 +11399,108 @@ var createVoiceTraceSinkDeliveryWorkerLoop = (options) => {
     tick
   };
 };
+var createVoiceHandoffDeliveryWorker = (options) => {
+  const allowedStatuses = options.statuses ?? ["pending", "failed"];
+  const leaseMs = Math.max(1, options.leaseMs ?? 30000);
+  return {
+    drain: async () => {
+      const result = {
+        alreadyProcessed: 0,
+        attempted: 0,
+        deadLettered: 0,
+        delivered: 0,
+        failed: 0,
+        skipped: 0
+      };
+      const deliveries = [...await options.deliveries.list()].sort((left, right) => left.createdAt - right.createdAt);
+      for (const delivery of deliveries) {
+        if (!shouldProcessHandoffDeliveryStatus(delivery.deliveryStatus, allowedStatuses)) {
+          continue;
+        }
+        if (shouldDeadLetterHandoffDelivery(delivery, options.maxFailures)) {
+          await options.deadLetters?.set(delivery.id, delivery);
+          await options.onDeadLetter?.(delivery);
+          result.deadLettered += 1;
+          continue;
+        }
+        const claimed = await options.leases.claim({
+          leaseMs,
+          taskId: delivery.id,
+          workerId: options.workerId
+        });
+        if (!claimed) {
+          continue;
+        }
+        try {
+          const idempotencyKey = `${delivery.id}:handoff`;
+          if (options.idempotency && await options.idempotency.has(idempotencyKey)) {
+            result.alreadyProcessed += 1;
+            continue;
+          }
+          result.attempted += 1;
+          const updatedDelivery = await deliverVoiceHandoffDelivery({
+            adapters: options.adapters,
+            api: options.api,
+            delivery,
+            failMode: options.failMode
+          });
+          await options.deliveries.set(updatedDelivery.id, updatedDelivery);
+          if (updatedDelivery.deliveryStatus === "delivered" || updatedDelivery.deliveryStatus === "skipped") {
+            await options.idempotency?.set(idempotencyKey, {
+              ttlSeconds: options.idempotencyTtlSeconds
+            });
+          }
+          if (updatedDelivery.deliveryStatus === "delivered") {
+            result.delivered += 1;
+          } else if (updatedDelivery.deliveryStatus === "skipped") {
+            result.skipped += 1;
+          } else if (updatedDelivery.deliveryStatus === "failed") {
+            result.failed += 1;
+            if (shouldDeadLetterHandoffDelivery(updatedDelivery, options.maxFailures)) {
+              await options.deadLetters?.set(updatedDelivery.id, updatedDelivery);
+              await options.onDeadLetter?.(updatedDelivery);
+              result.deadLettered += 1;
+            }
+          }
+        } finally {
+          await options.leases.release({
+            taskId: delivery.id,
+            workerId: options.workerId
+          });
+        }
+      }
+      return result;
+    }
+  };
+};
+var createVoiceHandoffDeliveryWorkerLoop = (options) => {
+  const pollIntervalMs = Math.max(1, options.pollIntervalMs ?? 1000);
+  let timer;
+  let running = false;
+  const tick = async () => options.worker.drain();
+  return {
+    isRunning: () => running,
+    start: () => {
+      if (timer) {
+        return;
+      }
+      running = true;
+      timer = setInterval(() => {
+        tick().catch((error) => {
+          options.onError?.(error);
+        });
+      }, pollIntervalMs);
+    },
+    stop: () => {
+      if (timer) {
+        clearInterval(timer);
+        timer = undefined;
+      }
+      running = false;
+    },
+    tick
+  };
+};
 var createVoiceOpsTaskWorker = (options) => {
   const leaseMs = Math.max(1, options.leaseMs ?? 30000);
   const getTask = async (taskId) => {
@@ -8270,10 +11636,10 @@ var createVoiceOpsTaskProcessorWorker = (options) => ({
         result.completed += 1;
       } catch (error) {
         await options.onError?.(error, task);
-        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorMessage3 = error instanceof Error ? error.message : String(error);
         const failedTask = failVoiceOpsTask(task, {
           actor: task.claimedBy ?? "ops-worker",
-          error: errorMessage
+          error: errorMessage3
         });
         if (shouldDeadLetterTask(failedTask, options.maxFailures)) {
           const deadLetterTask = deadLetterVoiceOpsTask(failedTask, {
@@ -9086,7 +12452,7 @@ var createVoiceSTTRoutingCorrectionHandler = (mode = "generic") => {
 import { Buffer as Buffer2 } from "buffer";
 var TWILIO_MULAW_SAMPLE_RATE = 8000;
 var VOICE_PCM_SAMPLE_RATE = 16000;
-var escapeXml = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+var escapeXml2 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 var normalizeOnTurn2 = (handler) => {
   if (handler.length > 1) {
     const directHandler = handler;
@@ -9282,8 +12648,8 @@ var createTwilioSocketAdapter = (socket, getState) => ({
   }
 });
 var createTwilioVoiceResponse = (options) => {
-  const parameters = Object.entries(options.parameters ?? {}).filter((entry) => entry[1] !== undefined).map(([name, value]) => `<Parameter name="${escapeXml(name)}" value="${escapeXml(String(value))}" />`).join("");
-  return `<?xml version="1.0" encoding="UTF-8"?><Response><Connect><Stream url="${escapeXml(options.streamUrl)}"${options.track ? ` track="${escapeXml(options.track)}"` : ""}${options.streamName ? ` name="${escapeXml(options.streamName)}"` : ""}>${parameters}</Stream></Connect></Response>`;
+  const parameters = Object.entries(options.parameters ?? {}).filter((entry) => entry[1] !== undefined).map(([name, value]) => `<Parameter name="${escapeXml2(name)}" value="${escapeXml2(String(value))}" />`).join("");
+  return `<?xml version="1.0" encoding="UTF-8"?><Response><Connect><Stream url="${escapeXml2(options.streamUrl)}"${options.track ? ` track="${escapeXml2(options.track)}"` : ""}${options.streamName ? ` name="${escapeXml2(options.streamName)}"` : ""}>${parameters}</Stream></Connect></Response>`;
 };
 var createTwilioMediaStreamBridge = (socket, options) => {
   const runtimePreset = resolveVoiceRuntimePreset(options.preset);
@@ -9519,15 +12885,22 @@ export {
   withVoiceOpsTaskId,
   withVoiceIntegrationEventId,
   voice,
+  verifyVoiceOpsWebhookSignature,
   transcodeTwilioInboundPayloadToPCM16,
   transcodePCMToTwilioOutboundPayload,
   summarizeVoiceTraceSinkDeliveries,
   summarizeVoiceTrace,
+  summarizeVoiceSessions,
+  summarizeVoiceSessionReplay,
+  summarizeVoiceProviderHealth,
   summarizeVoiceOpsTasks,
   summarizeVoiceOpsTaskQueue,
   summarizeVoiceOpsTaskAnalytics,
   summarizeVoiceIntegrationEvents,
+  summarizeVoiceHandoffHealth,
+  summarizeVoiceHandoffDeliveries,
   summarizeVoiceAssistantRuns,
+  summarizeVoiceAssistantHealth,
   startVoiceOpsTask,
   shapeTelephonyAssistantText,
   selectVoiceTraceEventsForPrune,
@@ -9539,6 +12912,7 @@ export {
   resolveVoiceOpsTaskAssignment,
   resolveVoiceOpsTaskAgeBucket,
   resolveVoiceOpsPreset,
+  resolveVoiceDiagnosticsTraceFilter,
   resolveVoiceAssistantMemoryNamespace,
   resolveTurnDetectionConfig,
   resolveAudioConditioningConfig,
@@ -9546,8 +12920,15 @@ export {
   reopenVoiceOpsTask,
   renderVoiceTraceMarkdown,
   renderVoiceTraceHTML,
+  renderVoiceSessionsHTML,
+  renderVoiceResilienceHTML,
+  renderVoiceQualityHTML,
+  renderVoiceProviderHealthHTML,
+  renderVoiceOpsConsoleHTML,
+  renderVoiceHandoffHealthHTML,
   renderVoiceCallReviewMarkdown,
   renderVoiceCallReviewHTML,
+  renderVoiceAssistantHealthHTML,
   redactVoiceTraceText,
   redactVoiceTraceEvents,
   redactVoiceTraceEvent,
@@ -9555,6 +12936,7 @@ export {
   pruneVoiceTraceEvents,
   matchesVoiceOpsTaskAssignmentRule,
   markVoiceOpsTaskSLABreached,
+  listVoiceRoutingEvents,
   listVoiceOpsTasks,
   isVoiceOpsTaskOverdue,
   heartbeatVoiceOpsTask,
@@ -9563,17 +12945,22 @@ export {
   failVoiceOpsTask,
   exportVoiceTrace,
   evaluateVoiceTrace,
+  evaluateVoiceQuality,
   encodeTwilioMulawBase64,
   deliverVoiceTraceEventsToSinks,
   deliverVoiceIntegrationEventToSinks,
   deliverVoiceIntegrationEvent,
+  deliverVoiceHandoffDelivery,
+  deliverVoiceHandoff,
   decodeTwilioMulawBase64,
   deadLetterVoiceOpsTask,
   createVoiceZendeskTicketUpdateSink,
   createVoiceZendeskTicketSyncSinks,
   createVoiceZendeskTicketSink,
+  createVoiceWebhookHandoffAdapter,
   createVoiceWebhookDeliveryWorkerLoop,
   createVoiceWebhookDeliveryWorker,
+  createVoiceTwilioRedirectHandoffAdapter,
   createVoiceTraceSinkStore,
   createVoiceTraceSinkDeliveryWorkerLoop,
   createVoiceTraceSinkDeliveryWorker,
@@ -9585,9 +12972,17 @@ export {
   createVoiceTaskUpdatedEvent,
   createVoiceTaskSLABreachedEvent,
   createVoiceTaskCreatedEvent,
+  createVoiceTTSProviderRouter,
+  createVoiceSessionsJSONHandler,
+  createVoiceSessionsHTMLHandler,
+  createVoiceSessionReplayRoutes,
+  createVoiceSessionReplayJSONHandler,
+  createVoiceSessionReplayHTMLHandler,
   createVoiceSessionRecord,
+  createVoiceSessionListRoutes,
   createVoiceSession,
   createVoiceSTTRoutingCorrectionHandler,
+  createVoiceSTTProviderRouter,
   createVoiceSQLiteTraceSinkDeliveryStore,
   createVoiceSQLiteTraceEventStore,
   createVoiceSQLiteTaskStore,
@@ -9598,8 +12993,14 @@ export {
   createVoiceSQLiteExternalObjectMapStore,
   createVoiceS3ReviewStore,
   createVoiceReviewSavedEvent,
+  createVoiceResilienceRoutes,
   createVoiceRedisTaskLeaseCoordinator,
   createVoiceRedisIdempotencyStore,
+  createVoiceQualityRoutes,
+  createVoiceProviderRouter,
+  createVoiceProviderHealthRoutes,
+  createVoiceProviderHealthJSONHandler,
+  createVoiceProviderHealthHTMLHandler,
   createVoicePostgresTraceSinkDeliveryStore,
   createVoicePostgresTraceEventStore,
   createVoicePostgresTaskStore,
@@ -9608,13 +13009,18 @@ export {
   createVoicePostgresReviewStore,
   createVoicePostgresIntegrationEventStore,
   createVoicePostgresExternalObjectMapStore,
+  createVoiceOpsWebhookSink,
+  createVoiceOpsWebhookReceiverRoutes,
+  createVoiceOpsWebhookEnvelope,
   createVoiceOpsTaskWorker,
   createVoiceOpsTaskProcessorWorkerLoop,
   createVoiceOpsTaskProcessorWorker,
   createVoiceOpsRuntime,
+  createVoiceOpsConsoleRoutes,
   createVoiceMemoryTraceSinkDeliveryStore,
   createVoiceMemoryTraceEventStore,
   createVoiceMemoryStore,
+  createVoiceMemoryHandoffDeliveryStore,
   createVoiceMemoryAssistantMemoryStore,
   createVoiceLinearIssueUpdateSink,
   createVoiceLinearIssueSyncSinks,
@@ -9627,6 +13033,12 @@ export {
   createVoiceHubSpotTaskSyncSinks,
   createVoiceHubSpotTaskSink,
   createVoiceHelpdeskTicketSink,
+  createVoiceHandoffHealthRoutes,
+  createVoiceHandoffHealthJSONHandler,
+  createVoiceHandoffHealthHTMLHandler,
+  createVoiceHandoffDeliveryWorkerLoop,
+  createVoiceHandoffDeliveryWorker,
+  createVoiceHandoffDeliveryRecord,
   createVoiceFileTraceSinkDeliveryStore,
   createVoiceFileTraceEventStore,
   createVoiceFileTaskStore,
@@ -9639,6 +13051,7 @@ export {
   createVoiceExternalObjectMapId,
   createVoiceExternalObjectMap,
   createVoiceExperiment,
+  createVoiceDiagnosticsRoutes,
   createVoiceCallReviewRecorder,
   createVoiceCallReviewFromSession,
   createVoiceCallReviewFromLiveTelephonyReport,
@@ -9646,6 +13059,9 @@ export {
   createVoiceCRMActivitySink,
   createVoiceAssistantMemoryRecord,
   createVoiceAssistantMemoryHandle,
+  createVoiceAssistantHealthRoutes,
+  createVoiceAssistantHealthJSONHandler,
+  createVoiceAssistantHealthHTMLHandler,
   createVoiceAssistant,
   createVoiceAgentTool,
   createVoiceAgentSquad,
@@ -9658,18 +13074,25 @@ export {
   createStoredVoiceCallReviewArtifact,
   createRiskyTurnCorrectionHandler,
   createPhraseHintCorrectionHandler,
+  createOpenAIVoiceAssistantModel,
+  createJSONVoiceAssistantModel,
   createId,
+  createGeminiVoiceAssistantModel,
   createDomainPhraseHints,
   createDomainLexicon,
+  createAnthropicVoiceAssistantModel,
   conditionAudioChunk,
   completeVoiceOpsTask,
   claimVoiceOpsTask,
   buildVoiceTraceReplay,
   buildVoiceOpsTaskFromSLABreach,
   buildVoiceOpsTaskFromReview,
+  buildVoiceOpsConsoleReport,
+  buildVoiceDiagnosticsMarkdown,
   assignVoiceOpsTask,
   applyVoiceOpsTaskPolicy,
   applyVoiceOpsTaskAssignmentRule,
+  applyVoiceHandoffDeliveryResult,
   applyRiskTieredPhraseHintCorrections,
   applyPhraseHintCorrections,
   TURN_PROFILE_DEFAULTS