@absolutejs/voice 0.0.22-beta.3 → 0.0.22-beta.31

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",
@@ -5594,6 +6026,112 @@ var resolveVoiceOutcomeRecipe = (name, options = {}) => {
   };
 };
 
+// src/assistantMemory.ts
+var createMemoryId = (input) => `${input.assistantId}:${input.namespace}:${input.key}`;
+var createVoiceAssistantMemoryRecord = (input) => {
+  const now = Date.now();
+  return {
+    ...input,
+    createdAt: input.createdAt ?? input.updatedAt ?? now,
+    updatedAt: input.updatedAt ?? now
+  };
+};
+var createVoiceMemoryAssistantMemoryStore = () => {
+  const records = new Map;
+  return {
+    delete: async (input) => {
+      records.delete(createMemoryId(input));
+    },
+    get: async (input) => records.get(createMemoryId(input)),
+    list: async (input) => [...records.values()].filter((record) => record.assistantId === input.assistantId && (input.namespace === undefined || record.namespace === input.namespace)).sort((left, right) => right.updatedAt - left.updatedAt),
+    set: async (input) => {
+      const id = createMemoryId(input);
+      const existing = records.get(id);
+      const record = createVoiceAssistantMemoryRecord({
+        ...input,
+        createdAt: input.createdAt ?? existing?.createdAt,
+        updatedAt: input.updatedAt
+      });
+      records.set(id, record);
+      return record;
+    }
+  };
+};
+var resolveVoiceAssistantMemoryNamespace = async (input) => typeof input.memory.namespace === "function" ? await input.memory.namespace(input) : input.memory.namespace;
+var createVoiceAssistantMemoryHandle = async (input) => {
+  const namespace = await resolveVoiceAssistantMemoryNamespace({
+    assistantId: input.assistantId,
+    context: input.context,
+    memory: input.memory,
+    session: input.session
+  });
+  const trace = async (event) => {
+    await input.trace?.append({
+      at: Date.now(),
+      payload: {
+        assistantId: input.assistantId,
+        namespace,
+        ...event
+      },
+      scenarioId: input.session.scenarioId,
+      sessionId: input.session.id,
+      type: "assistant.memory"
+    });
+  };
+  return {
+    delete: async (key) => {
+      await input.memory.store.delete({
+        assistantId: input.assistantId,
+        key,
+        namespace
+      });
+      await trace({
+        action: "delete",
+        key
+      });
+    },
+    get: async (key) => {
+      const record = await input.memory.store.get({
+        assistantId: input.assistantId,
+        key,
+        namespace
+      });
+      await trace({
+        action: "get",
+        found: Boolean(record),
+        key
+      });
+      return record?.value;
+    },
+    list: async () => {
+      const records = await input.memory.store.list({
+        assistantId: input.assistantId,
+        namespace
+      });
+      await trace({
+        action: "list",
+        count: records.length
+      });
+      return records;
+    },
+    namespace,
+    set: async (key, value, metadata) => {
+      const record = await input.memory.store.set({
+        assistantId: input.assistantId,
+        key,
+        metadata,
+        namespace,
+        value
+      });
+      await trace({
+        action: "set",
+        key
+      });
+      return record;
+    }
+  };
+};
+
 // src/assistant.ts
 var hashString = (value) => {
   let hash = 2166136261;
@@ -5742,12 +6280,35 @@ var createVoiceAssistant = (options) => {
     });
   }
   const onTurn = async (input) => {
+    const memory = options.memory ? await createVoiceAssistantMemoryHandle({
+      assistantId: options.id,
+      context: input.context,
+      memory: options.memory,
+      session: input.session,
+      trace: options.trace
+    }) : undefined;
     const guardrailInput = {
       ...input,
-      assistantId: options.id
+      assistantId: options.id,
+      memory
     };
+    if (memory) {
+      await options.memoryLifecycle?.beforeTurn?.({
+        ...input,
+        assistantId: options.id,
+        memory
+      });
+    }
     const blocked = await options.guardrails?.beforeTurn?.(guardrailInput);
     if (blocked) {
+      if (memory) {
+        await options.memoryLifecycle?.afterTurn?.({
+          ...input,
+          assistantId: options.id,
+          memory,
+          result: blocked
+        });
+      }
       await appendAssistantTrace({
         assistantId: options.id,
         event: {
@@ -5797,6 +6358,14 @@ var createVoiceAssistant = (options) => {
       result
     });
     const finalResult = guarded ?? result;
+    if (memory) {
+      await options.memoryLifecycle?.afterTurn?.({
+        ...input,
+        assistantId: options.id,
+        memory,
+        result: finalResult
+      });
+    }
     if (guarded) {
       await appendAssistantTrace({
         assistantId: options.id,
@@ -5864,6 +6433,12 @@ var summarizeVoiceAssistantRuns = async (input) => {
         escalationCount: 0,
         experiments: {},
         guardrailCount: 0,
+        memory: {
+          deletes: 0,
+          gets: 0,
+          lists: 0,
+          sets: 0
+        },
         outcomes: {},
         runCount: 0,
         sessionIds: new Set,
@@ -5919,6 +6494,24 @@ var summarizeVoiceAssistantRuns = async (input) => {
     const summary = getSummary(assistantId);
     summary.guardrailCount += 1;
   }
+  for (const event of events.filter((event2) => event2.type === "assistant.memory")) {
+    const assistantId = typeof event.payload.assistantId === "string" ? event.payload.assistantId : "unknown";
+    const summary = getSummary(assistantId);
+    switch (event.payload.action) {
+      case "delete":
+        summary.memory.deletes += 1;
+        break;
+      case "get":
+        summary.memory.gets += 1;
+        break;
+      case "list":
+        summary.memory.lists += 1;
+        break;
+      case "set":
+        summary.memory.sets += 1;
+        break;
+    }
+  }
   const assistants = [...byAssistant.values()].map(({ elapsedCount, elapsedTotal, sessionIds, ...summary }) => ({
     ...summary,
     averageElapsedMs: elapsedCount > 0 ? Math.round(elapsedTotal / elapsedCount) : undefined,
@@ -5929,9 +6522,302 @@ 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/providerHealth.ts
+import { Elysia as Elysia2 } from "elysia";
+var getString = (value) => typeof value === "string" ? value : undefined;
+var getNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+var isProviderStatus = (value) => value === "success" || value === "fallback" || value === "error";
+var summarizeVoiceProviderHealth = async (input) => {
+  const options = Array.isArray(input) ? { events: input } : input;
+  const events = options.events ?? await options.store?.list() ?? [];
+  const providers = options.providers ?? [];
+  const providerSet = new Set(providers);
+  const now = options.now ?? Date.now();
+  const entries = new Map;
+  const isAllowedProvider = (value) => typeof value === "string" && (providerSet.size === 0 || providerSet.has(value));
+  const getEntry = (provider) => {
+    const existing = entries.get(provider);
+    if (existing) {
+      return existing;
+    }
+    const entry = {
+      elapsedCount: 0,
+      elapsedTotal: 0,
+      errorCount: 0,
+      fallbackCount: 0,
+      provider,
+      rateLimited: false,
+      recommended: false,
+      runCount: 0,
+      status: "idle"
+    };
+    entries.set(provider, entry);
+    return entry;
+  };
+  for (const provider of providers) {
+    getEntry(provider);
+  }
+  const hasProviderRouterEvents = events.some((event) => event.type === "session.error" && isAllowedProvider(event.payload.provider) && isProviderStatus(event.payload.providerStatus));
+  for (const event of events) {
+    if (event.type === "assistant.run") {
+      if (hasProviderRouterEvents) {
+        continue;
+      }
+      const provider2 = event.payload.variantId;
+      if (!isAllowedProvider(provider2)) {
+        continue;
+      }
+      const entry2 = getEntry(provider2);
+      entry2.runCount += 1;
+      const elapsedMs = getNumber(event.payload.elapsedMs);
+      if (elapsedMs !== undefined) {
+        entry2.elapsedCount += 1;
+        entry2.elapsedTotal += elapsedMs;
+      }
+      continue;
+    }
+    if (event.type !== "session.error") {
+      continue;
+    }
+    const provider = event.payload.provider;
+    if (!isAllowedProvider(provider)) {
+      continue;
+    }
+    const providerStatus = isProviderStatus(event.payload.providerStatus) ? event.payload.providerStatus : undefined;
+    const applyProviderHealth = () => {
+      const entry2 = getEntry(provider);
+      const providerHealth = event.payload.providerHealth;
+      if (providerHealth && typeof providerHealth === "object") {
+        const suppressedUntil2 = getNumber(providerHealth.suppressedUntil);
+        if (suppressedUntil2 !== undefined) {
+          entry2.suppressedUntil = suppressedUntil2;
+        }
+      }
+      const suppressedUntil = getNumber(event.payload.suppressedUntil);
+      if (suppressedUntil !== undefined) {
+        entry2.suppressedUntil = suppressedUntil;
+      }
+      const suppressionRemainingMs = getNumber(event.payload.suppressionRemainingMs);
+      if (suppressionRemainingMs !== undefined) {
+        entry2.suppressionRemainingMs = suppressionRemainingMs;
+      }
+      return entry2;
+    };
+    if (providerStatus === "success" || providerStatus === "fallback") {
+      const entry2 = applyProviderHealth();
+      entry2.runCount += 1;
+      entry2.lastSuccessAt = event.at;
+      if (providerStatus === "success") {
+        entry2.lastError = undefined;
+        entry2.rateLimited = false;
+        entry2.suppressedUntil = undefined;
+        entry2.suppressionRemainingMs = undefined;
+      }
+      const elapsedMs = getNumber(event.payload.elapsedMs);
+      if (elapsedMs !== undefined) {
+        entry2.elapsedCount += 1;
+        entry2.elapsedTotal += elapsedMs;
+      }
+      const selectedProvider = event.payload.selectedProvider;
+      if (providerStatus === "fallback" && isAllowedProvider(selectedProvider) && selectedProvider !== provider) {
+        getEntry(selectedProvider).fallbackCount += 1;
+      }
+      continue;
+    }
+    const entry = applyProviderHealth();
+    entry.errorCount += 1;
+    entry.lastError = getString(event.payload.error);
+    entry.lastErrorAt = event.at;
+    entry.rateLimited ||= event.payload.rateLimited === true;
+  }
+  const summaries = [...entries.values()].map((entry) => {
+    const hadSuppression = typeof entry.suppressedUntil === "number" || typeof entry.suppressionRemainingMs === "number";
+    const suppressionRemainingMs = typeof entry.suppressedUntil === "number" ? Math.max(0, entry.suppressedUntil - now) : entry.suppressionRemainingMs;
+    const activeSuppression = typeof suppressionRemainingMs === "number" && suppressionRemainingMs > 0;
+    const recoverable = hadSuppression && !activeSuppression;
+    const averageElapsedMs = entry.elapsedCount > 0 ? Math.round(entry.elapsedTotal / entry.elapsedCount) : undefined;
+    const status = activeSuppression ? "suppressed" : recoverable ? "recoverable" : entry.rateLimited ? "rate-limited" : entry.errorCount > 0 && (!entry.lastSuccessAt || !entry.lastErrorAt || entry.lastErrorAt > entry.lastSuccessAt) ? "degraded" : entry.runCount > 0 ? "healthy" : "idle";
+    return {
+      averageElapsedMs,
+      errorCount: entry.errorCount,
+      fallbackCount: entry.fallbackCount,
+      lastError: entry.lastError,
+      lastErrorAt: entry.lastErrorAt,
+      lastSuccessAt: entry.lastSuccessAt,
+      provider: entry.provider,
+      rateLimited: entry.rateLimited,
+      recommended: false,
+      runCount: entry.runCount,
+      status,
+      suppressionRemainingMs: activeSuppression ? suppressionRemainingMs : undefined,
+      suppressedUntil: entry.suppressedUntil
+    };
+  });
+  const recommended = summaries.filter((entry) => entry.status === "healthy").sort((left, right) => (left.averageElapsedMs ?? Number.MAX_SAFE_INTEGER) - (right.averageElapsedMs ?? Number.MAX_SAFE_INTEGER))[0];
+  if (recommended) {
+    recommended.recommended = true;
+  }
+  return summaries;
+};
+var escapeHtml3 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var renderVoiceProviderHealthHTML = (providers) => providers.length === 0 ? '<p class="voice-provider-empty">No provider status yet.</p>' : [
+  '<div class="voice-provider-health">',
+  ...providers.map((provider) => {
+    const suppressionSeconds = typeof provider.suppressionRemainingMs === "number" ? Math.ceil(provider.suppressionRemainingMs / 1000) : undefined;
+    return [
+      `<article class="voice-provider-card ${escapeHtml3(provider.status)}">`,
+      '<div class="voice-provider-card-header">',
+      `<strong>${escapeHtml3(provider.provider)}</strong>`,
+      `<span>${escapeHtml3(provider.status)}${provider.recommended ? " \xB7 recommended" : ""}</span>`,
+      "</div>",
+      "<dl>",
+      `<div><dt>Runs</dt><dd>${String(provider.runCount)}</dd></div>`,
+      `<div><dt>Avg latency</dt><dd>${String(provider.averageElapsedMs ?? 0)}ms</dd></div>`,
+      `<div><dt>Errors</dt><dd>${String(provider.errorCount)}</dd></div>`,
+      `<div><dt>Fallbacks</dt><dd>${String(provider.fallbackCount)}</dd></div>`,
+      "</dl>",
+      suppressionSeconds ? `<p>Temporarily suppressed for ${String(suppressionSeconds)}s.</p>` : "",
+      provider.lastError ? `<p>${escapeHtml3(provider.lastError)}</p>` : "",
+      "</article>"
+    ].join("");
+  }),
+  "</div>"
+].join("");
+var createVoiceProviderHealthJSONHandler = (options) => async () => summarizeVoiceProviderHealth(options);
+var createVoiceProviderHealthHTMLHandler = (options) => async () => {
+  const providers = await summarizeVoiceProviderHealth(options);
+  const render = options.render ?? renderVoiceProviderHealthHTML;
+  const body = await render(providers);
+  return new Response(body, {
+    headers: {
+      "Content-Type": "text/html; charset=utf-8",
+      ...options.headers
+    }
+  });
+};
+var createVoiceProviderHealthRoutes = (options) => {
+  const path = options.path ?? "/api/provider-status";
+  const htmlPath = options.htmlPath === undefined ? `${path}/htmx` : options.htmlPath;
+  const routes = new Elysia2({
+    name: options.name ?? "absolutejs-voice-provider-health"
+  }).get(path, createVoiceProviderHealthJSONHandler(options));
+  if (htmlPath) {
+    routes.get(htmlPath, createVoiceProviderHealthHTMLHandler(options));
+  }
+  return routes;
+};
+
+// src/assistantHealth.ts
+var escapeHtml4 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var renderCountMap = (values) => {
+  const entries = Object.entries(values).sort((left, right) => right[1] - left[1]);
+  if (entries.length === 0) {
+    return '<p class="voice-assistant-health-empty">No data yet.</p>';
+  }
+  return [
+    '<div class="voice-assistant-health-metrics">',
+    ...entries.map(([label, value]) => `<div><span>${escapeHtml4(label)}</span><strong>${String(value)}</strong></div>`),
+    "</div>"
+  ].join("");
+};
+var getString2 = (value) => typeof value === "string" ? value : undefined;
+var getRecentFailures = (events, maxFailures, replayHref) => events.filter((event) => event.type === "session.error" && (event.payload.providerStatus === "error" || typeof event.payload.error === "string") || event.type === "assistant.guardrail" && event.payload.action === "blocked").toReversed().slice(0, maxFailures).map((event) => {
+  const failure = {
+    at: event.at,
+    assistantId: getString2(event.payload.assistantId),
+    error: getString2(event.payload.error),
+    provider: getString2(event.payload.provider),
+    rateLimited: event.payload.rateLimited === true ? true : undefined,
+    sessionId: event.sessionId,
+    status: getString2(event.payload.providerStatus),
+    turnId: event.turnId,
+    type: event.type
+  };
+  const href = replayHref === false ? undefined : typeof replayHref === "function" ? replayHref(failure) : `${replayHref ?? "/api/voice-sessions"}/${encodeURIComponent(event.sessionId)}/replay/htmx`;
+  return {
+    ...failure,
+    replayHref: href
+  };
+});
+var summarizeVoiceAssistantHealth = async (options) => {
+  const events = options.events ?? await options.store?.list() ?? [];
+  return {
+    assistantRuns: await summarizeVoiceAssistantRuns({ events }),
+    providerHealth: await summarizeVoiceProviderHealth({
+      events,
+      providers: options.providers
+    }),
+    recentFailures: getRecentFailures(events, options.maxFailures ?? 8, options.replayHref)
+  };
+};
+var renderVoiceAssistantHealthHTML = (summary) => {
+  const assistant = summary.assistantRuns.assistants[0];
+  const failures = summary.recentFailures;
+  return [
+    '<div class="voice-assistant-health">',
+    '<section class="voice-assistant-health-grid">',
+    `<article><span>Runs</span><strong>${String(assistant?.runCount ?? 0)}</strong></article>`,
+    `<article><span>Sessions</span><strong>${String(assistant?.sessions ?? 0)}</strong></article>`,
+    `<article><span>Guardrails</span><strong>${String(assistant?.guardrailCount ?? 0)}</strong></article>`,
+    `<article><span>Avg latency</span><strong>${String(assistant?.averageElapsedMs ?? 0)}ms</strong></article>`,
+    "</section>",
+    "<section>",
+    "<h3>Provider Health</h3>",
+    renderVoiceProviderHealthHTML(summary.providerHealth),
+    "</section>",
+    '<section class="voice-assistant-health-columns">',
+    `<article><h3>Outcomes</h3>${renderCountMap(assistant?.outcomes ?? {})}</article>`,
+    `<article><h3>Variants</h3>${renderCountMap(assistant?.variants ?? {})}</article>`,
+    `<article><h3>Tools</h3>${renderCountMap(assistant?.toolCalls ?? {})}</article>`,
+    `<article><h3>Artifact Plans</h3>${renderCountMap(assistant?.artifactPlans ?? {})}</article>`,
+    "</section>",
+    "<section>",
+    "<h3>Recent Failures</h3>",
+    failures.length === 0 ? '<p class="voice-assistant-health-empty">No failures yet.</p>' : [
+      '<div class="voice-assistant-health-failures">',
+      ...failures.map((failure) => [
+        "<article>",
+        `<strong>${escapeHtml4(failure.provider ?? failure.assistantId ?? failure.type)}</strong>`,
+        `<span>${escapeHtml4(failure.status ?? (failure.rateLimited ? "rate-limited" : "error"))}</span>`,
+        failure.error ? `<p>${escapeHtml4(failure.error)}</p>` : "",
+        `<small>${escapeHtml4(failure.sessionId)}${failure.turnId ? ` / ${escapeHtml4(failure.turnId)}` : ""}</small>`,
+        failure.replayHref ? `<p><a href="${escapeHtml4(failure.replayHref)}">Open replay</a></p>` : "",
+        "</article>"
+      ].join("")),
+      "</div>"
+    ].join(""),
+    "</section>",
+    "</div>"
+  ].join("");
+};
+var createVoiceAssistantHealthJSONHandler = (options) => async () => summarizeVoiceAssistantHealth(options);
+var createVoiceAssistantHealthHTMLHandler = (options) => async () => {
+  const summary = await summarizeVoiceAssistantHealth(options);
+  const render = options.render ?? renderVoiceAssistantHealthHTML;
+  const body = await render(summary);
+  return new Response(body, {
+    headers: {
+      "Content-Type": "text/html; charset=utf-8",
+      ...options.headers
+    }
+  });
+};
+var createVoiceAssistantHealthRoutes = (options) => {
+  const path = options.path ?? "/api/assistant-health";
+  const htmlPath = options.htmlPath === undefined ? `${path}/htmx` : options.htmlPath;
+  const routes = new Elysia3({
+    name: options.name ?? "absolutejs-voice-assistant-health"
+  }).get(path, createVoiceAssistantHealthJSONHandler(options));
+  if (htmlPath) {
+    routes.get(htmlPath, createVoiceAssistantHealthHTMLHandler(options));
+  }
+  return routes;
+};
+// src/sessionReplay.ts
+import { Elysia as Elysia4 } from "elysia";
 
 // src/trace.ts
 var createVoiceTraceEventId = (event) => [
@@ -6035,7 +6921,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), {
@@ -6044,7 +6930,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) {
@@ -6265,7 +7151,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 "";
@@ -6543,10 +7429,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(`
@@ -6557,7 +7443,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}",
@@ -6571,7 +7457,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>`,
@@ -6585,7 +7471,7 @@ var renderVoiceTraceHTML = (events, options = {}) => {
     eventRows,
     "</tbody></table>",
     "<h2>Markdown Export</h2>",
-    `<pre>${escapeHtml3(markdown)}</pre>`,
+    `<pre>${escapeHtml5(markdown)}</pre>`,
     "</main></body></html>"
   ].join(`
 `);
@@ -6597,7 +7483,250 @@ var buildVoiceTraceReplay = (events, options = {}) => ({
   summary: summarizeVoiceTrace(options.redact ? redactVoiceTraceEvents(events, options.redact) : events)
 });
 
+// src/sessionReplay.ts
+var getString3 = (value) => typeof value === "string" ? value : undefined;
+var escapeHtml6 = (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: getString3(event.payload.text)
+        });
+        break;
+      case "turn.committed":
+        turn.committedText = getString3(event.payload.text);
+        break;
+      case "turn.assistant": {
+        const text = getString3(event.payload.text);
+        if (text) {
+          turn.assistantReplies.push(text);
+        }
+        break;
+      }
+      case "agent.model":
+      case "assistant.run":
+        turn.modelCalls.push(event.payload);
+        break;
+      case "agent.tool":
+        turn.tools.push(event.payload);
+        break;
+      case "session.error":
+        turn.errors.push(event.payload);
+        break;
+    }
+  }
+  return [...turns.values()];
+};
+var summarizeVoiceSessionReplay = async (options) => {
+  const sourceEvents = options.events ?? await options.store?.list({ sessionId: options.sessionId }) ?? [];
+  const events = filterVoiceTraceEvents(sourceEvents, {
+    sessionId: options.sessionId
+  });
+  const replay = buildVoiceTraceReplay(events, {
+    evaluation: options.evaluation,
+    redact: options.redact,
+    title: options.title ?? `Voice Session ${options.sessionId}`
+  });
+  const startedAt = replay.summary.startedAt;
+  return {
+    evaluation: replay.evaluation,
+    events,
+    html: replay.html,
+    markdown: replay.markdown,
+    sessionId: options.sessionId,
+    summary: replay.summary,
+    timeline: events.map((event) => ({
+      at: event.at,
+      offsetMs: startedAt === undefined ? undefined : Math.max(0, event.at - startedAt),
+      payload: event.payload,
+      turnId: event.turnId,
+      type: event.type
+    })),
+    turns: buildReplayTurns(events)
+  };
+};
+var 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 = getString3(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 = getString3(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 ${escapeHtml6(session.status)}">`,
+    '<div class="voice-session-card-header">',
+    `<strong>${escapeHtml6(session.sessionId)}</strong>`,
+    `<span>${escapeHtml6(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: ${escapeHtml6(session.latestOutcome)}</p>` : "",
+    session.providers.length ? `<p>Providers: ${session.providers.map(escapeHtml6).join(", ")}</p>` : "",
+    session.replayHref ? `<p><a href="${escapeHtml6(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 Elysia4({
+    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 Elysia4({
+    name: options.name ?? "absolutejs-voice-session-replay"
+  }).get(path, createVoiceSessionReplayJSONHandler(options));
+  if (htmlPath) {
+    routes.get(htmlPath, createVoiceSessionReplayHTMLHandler(options));
+  }
+  return routes;
+};
 // src/fileStore.ts
+import { mkdir, readFile, readdir, rename, rm, writeFile } from "fs/promises";
+import { join } from "path";
 var listJsonFiles = async (directory) => {
   try {
     const entries = await readdir(directory, {
@@ -6613,6 +7742,7 @@ var listJsonFiles = async (directory) => {
 };
 var encodeStoreId = (id) => `${encodeURIComponent(id)}.json`;
 var resolveFilePath = (directory, id) => join(directory, encodeStoreId(id));
+var createMemoryStoreId = (input) => `${input.assistantId}:${input.namespace}:${input.key}`;
 var readJsonFile = async (path) => JSON.parse(await readFile(path, "utf8"));
 var writeJsonFile = async (path, value, options) => {
   await mkdir(options.directory, {
@@ -6832,6 +7962,40 @@ var createVoiceFileTraceSinkDeliveryStore = (options) => {
   };
   return { get, list, remove, set };
 };
+var createVoiceFileAssistantMemoryStore = (options) => {
+  const get = async (input) => {
+    const path = resolveFilePath(options.directory, createMemoryStoreId(input));
+    try {
+      return await readJsonFile(path);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return;
+      }
+      throw error;
+    }
+  };
+  const list = async (input) => {
+    const files = await listJsonFiles(options.directory);
+    const records = await Promise.all(files.map((file) => readJsonFile(file)));
+    return records.filter((record) => record.assistantId === input.assistantId && (input.namespace === undefined || record.namespace === input.namespace)).sort((left, right) => right.updatedAt - left.updatedAt);
+  };
+  const set = async (input) => {
+    const existing = await get(input);
+    const record = createVoiceAssistantMemoryRecord({
+      ...input,
+      createdAt: input.createdAt ?? existing?.createdAt,
+      updatedAt: input.updatedAt
+    });
+    await writeJsonFile(resolveFilePath(options.directory, createMemoryStoreId(record)), record, options);
+    return record;
+  };
+  const remove = async (input) => {
+    await rm(resolveFilePath(options.directory, createMemoryStoreId(input)), {
+      force: true
+    });
+  };
+  return { delete: remove, get, list, set };
+};
 var createVoiceFileRuntimeStorage = (options) => ({
   events: createVoiceFileIntegrationEventStore({
     ...options,
@@ -6841,6 +8005,10 @@ var createVoiceFileRuntimeStorage = (options) => ({
     ...options,
     directory: join(options.directory, "external-objects")
   }),
+  memories: createVoiceFileAssistantMemoryStore({
+    ...options,
+    directory: join(options.directory, "memories")
+  }),
   reviews: createVoiceFileReviewStore({
     ...options,
     directory: join(options.directory, "reviews")
@@ -6873,6 +8041,777 @@ var createStoredVoiceExternalObjectMap = (mapping) => createVoiceExternalObjectM
   sourceId: mapping.sourceId,
   sourceType: mapping.sourceType
 });
+// src/modelAdapters.ts
+var OUTPUT_SCHEMA = {
+  additionalProperties: false,
+  properties: {
+    assistantText: {
+      type: "string"
+    },
+    complete: {
+      type: "boolean"
+    },
+    escalate: {
+      additionalProperties: false,
+      properties: {
+        metadata: {
+          additionalProperties: true,
+          type: "object"
+        },
+        reason: {
+          type: "string"
+        }
+      },
+      required: ["reason"],
+      type: "object"
+    },
+    noAnswer: {
+      additionalProperties: false,
+      properties: {
+        metadata: {
+          additionalProperties: true,
+          type: "object"
+        }
+      },
+      type: "object"
+    },
+    result: {
+      additionalProperties: true,
+      type: "object"
+    },
+    transfer: {
+      additionalProperties: false,
+      properties: {
+        metadata: {
+          additionalProperties: true,
+          type: "object"
+        },
+        reason: {
+          type: "string"
+        },
+        target: {
+          type: "string"
+        }
+      },
+      required: ["target"],
+      type: "object"
+    },
+    voicemail: {
+      additionalProperties: false,
+      properties: {
+        metadata: {
+          additionalProperties: true,
+          type: "object"
+        }
+      },
+      type: "object"
+    }
+  },
+  type: "object"
+};
+var ROUTE_RESULT_INSTRUCTION = "Return only a JSON object with assistantText, complete, transfer, escalate, voicemail, noAnswer, and result when you are not calling tools. Only set transfer, escalate, voicemail, or noAnswer when the user explicitly asks for that lifecycle outcome or a tool result says that exact outcome. Do not infer voicemail from generic words like voice, voice app, or voice integration.";
+var stripJSONCodeFence = (value) => {
+  const trimmed = value.trim();
+  const match = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+  return match?.[1]?.trim() ?? value;
+};
+var parseJSON = (value) => {
+  try {
+    const parsed = JSON.parse(stripJSONCodeFence(value));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {
+      assistantText: value
+    };
+  }
+};
+var parseJSONValue = (value) => {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+};
+var getMessageToolCalls = (message) => {
+  const toolCalls = message.metadata?.toolCalls;
+  return Array.isArray(toolCalls) ? toolCalls.filter((toolCall) => toolCall && typeof toolCall === "object" && typeof toolCall.name === "string") : [];
+};
+var createHTTPError = (provider, response) => new Error(`${provider} voice assistant model failed: HTTP ${response.status}`);
+var sleep4 = (ms) => new Promise((resolve2) => {
+  setTimeout(resolve2, ms);
+});
+var errorMessage = (error) => error instanceof Error ? error.message : String(error);
+var defaultIsRateLimitError = (error) => /(\b429\b|rate limit|quota|too many requests)/i.test(errorMessage(error));
+var normalizeRouteOutput = (output) => {
+  const result = {};
+  if (typeof output.assistantText === "string") {
+    result.assistantText = output.assistantText;
+  }
+  if (typeof output.complete === "boolean") {
+    result.complete = output.complete;
+  }
+  if (output.result !== undefined) {
+    result.result = output.result;
+  }
+  if (output.transfer && typeof output.transfer === "object") {
+    const transfer = output.transfer;
+    if (typeof transfer.target === "string") {
+      result.transfer = {
+        metadata: transfer.metadata && typeof transfer.metadata === "object" ? transfer.metadata : undefined,
+        reason: typeof transfer.reason === "string" ? transfer.reason : undefined,
+        target: transfer.target
+      };
+    }
+  }
+  if (output.escalate && typeof output.escalate === "object") {
+    const escalate = output.escalate;
+    if (typeof escalate.reason === "string") {
+      result.escalate = {
+        metadata: escalate.metadata && typeof escalate.metadata === "object" ? escalate.metadata : undefined,
+        reason: escalate.reason
+      };
+    }
+  }
+  if (output.voicemail && typeof output.voicemail === "object") {
+    const voicemail = output.voicemail;
+    result.voicemail = {
+      metadata: voicemail.metadata && typeof voicemail.metadata === "object" ? voicemail.metadata : undefined
+    };
+  }
+  if (output.noAnswer && typeof output.noAnswer === "object") {
+    const noAnswer = output.noAnswer;
+    result.noAnswer = {
+      metadata: noAnswer.metadata && typeof noAnswer.metadata === "object" ? noAnswer.metadata : undefined
+    };
+  }
+  return result;
+};
+var createJSONVoiceAssistantModel = (options) => ({
+  generate: async (input) => {
+    const output = await options.generate(input);
+    if ("assistantText" in output || "toolCalls" in output || "complete" in output || "transfer" in output || "escalate" in output) {
+      return output;
+    }
+    return options.mapOutput?.(output) ?? normalizeRouteOutput(output);
+  }
+});
+var createVoiceProviderRouter = (options) => {
+  const providerIds = Object.keys(options.providers);
+  const firstProvider = providerIds[0];
+  const policy = typeof options.policy === "string" ? {
+    strategy: options.policy
+  } : options.policy;
+  const strategy = policy?.strategy ?? "prefer-selected";
+  const fallbackMode = policy?.fallbackMode ?? options.fallbackMode ?? "provider-error";
+  const healthOptions = typeof options.providerHealth === "object" ? options.providerHealth : options.providerHealth ? {} : undefined;
+  const healthState = new Map;
+  const now = () => healthOptions?.now?.() ?? Date.now();
+  const failureThreshold = Math.max(1, healthOptions?.failureThreshold ?? 1);
+  const cooldownMs = Math.max(0, healthOptions?.cooldownMs ?? 30000);
+  const rateLimitCooldownMs = Math.max(0, healthOptions?.rateLimitCooldownMs ?? 60000);
+  const getHealth = (provider) => {
+    const existing = healthState.get(provider);
+    if (existing) {
+      return existing;
+    }
+    const next = {
+      consecutiveFailures: 0,
+      provider,
+      status: "healthy"
+    };
+    healthState.set(provider, next);
+    return next;
+  };
+  const cloneHealth = (provider) => {
+    if (!healthOptions) {
+      return;
+    }
+    return {
+      ...getHealth(provider)
+    };
+  };
+  const getSuppressionRemainingMs = (provider) => {
+    if (!healthOptions) {
+      return;
+    }
+    const suppressedUntil = getHealth(provider).suppressedUntil;
+    return typeof suppressedUntil === "number" ? Math.max(0, suppressedUntil - now()) : undefined;
+  };
+  const isSuppressed = (provider) => {
+    if (!healthOptions) {
+      return false;
+    }
+    const health = getHealth(provider);
+    return typeof health.suppressedUntil === "number" && health.suppressedUntil > now();
+  };
+  const recordProviderSuccess = (provider) => {
+    if (!healthOptions) {
+      return;
+    }
+    const health = getHealth(provider);
+    health.consecutiveFailures = 0;
+    health.status = "healthy";
+    health.suppressedUntil = undefined;
+    return cloneHealth(provider);
+  };
+  const recordProviderError = (provider, isProviderError, rateLimited) => {
+    if (!healthOptions || !isProviderError) {
+      return cloneHealth(provider);
+    }
+    const currentTime = now();
+    const health = getHealth(provider);
+    health.consecutiveFailures += 1;
+    health.lastFailureAt = currentTime;
+    if (rateLimited) {
+      health.lastRateLimitedAt = currentTime;
+    }
+    if (rateLimited || health.consecutiveFailures >= failureThreshold) {
+      health.status = "suppressed";
+      health.suppressedUntil = currentTime + (rateLimited ? rateLimitCooldownMs : cooldownMs);
+    }
+    return cloneHealth(provider);
+  };
+  const resolveAllowedProviders = async (input) => {
+    const allowProviders = policy?.allowProviders ?? options.allowProviders;
+    const allowed = typeof allowProviders === "function" ? await allowProviders(input) : allowProviders;
+    return new Set(allowed ?? providerIds);
+  };
+  const sortProviders = (providers) => {
+    if (strategy !== "prefer-cheapest" && strategy !== "prefer-fastest") {
+      return providers;
+    }
+    return [...providers].sort((left, right) => {
+      const leftProfile = options.providerProfiles?.[left];
+      const rightProfile = options.providerProfiles?.[right];
+      const leftValue = strategy === "prefer-cheapest" ? leftProfile?.cost ?? Number.MAX_SAFE_INTEGER : leftProfile?.latencyMs ?? Number.MAX_SAFE_INTEGER;
+      const rightValue = strategy === "prefer-cheapest" ? rightProfile?.cost ?? Number.MAX_SAFE_INTEGER : rightProfile?.latencyMs ?? Number.MAX_SAFE_INTEGER;
+      return leftValue - rightValue || (leftProfile?.priority ?? Number.MAX_SAFE_INTEGER) - (rightProfile?.priority ?? Number.MAX_SAFE_INTEGER);
+    });
+  };
+  const resolveOrder = async (input) => {
+    const selectedProvider = await options.selectProvider?.(input);
+    const allowedProviders = await resolveAllowedProviders(input);
+    const fallbackOrder = typeof options.fallback === "function" ? await options.fallback(input) : options.fallback;
+    const rankedProviders = sortProviders([
+      ...fallbackOrder ?? providerIds
+    ]).filter((provider) => allowedProviders.has(provider));
+    const healthyRankedProviders = healthOptions ? rankedProviders.filter((provider) => !isSuppressed(provider)) : rankedProviders;
+    const candidateRankedProviders = healthyRankedProviders.length ? healthyRankedProviders : rankedProviders;
+    const preferred = selectedProvider && allowedProviders.has(selectedProvider) && (!healthOptions || !isSuppressed(selectedProvider)) ? selectedProvider : candidateRankedProviders[0] ?? firstProvider;
+    const seen = new Set;
+    const order = [];
+    const candidates = strategy === "ordered" ? candidateRankedProviders : [
+      preferred,
+      ...candidateRankedProviders,
+      ...providerIds.filter((provider) => !healthOptions || !isSuppressed(provider))
+    ];
+    for (const provider of candidates) {
+      if (!provider || seen.has(provider) || !allowedProviders.has(provider) || !options.providers[provider]) {
+        continue;
+      }
+      seen.add(provider);
+      order.push(provider);
+    }
+    return {
+      order,
+      selectedProvider: preferred
+    };
+  };
+  const emit = async (event, input) => {
+    await options.onProviderEvent?.(event, input);
+  };
+  return {
+    generate: async (input) => {
+      const { order, selectedProvider } = await resolveOrder(input);
+      if (!selectedProvider || order.length === 0) {
+        throw new Error("Voice provider router has no available providers.");
+      }
+      let lastError;
+      for (const [index, provider] of order.entries()) {
+        const model = options.providers[provider];
+        if (!model) {
+          continue;
+        }
+        const startedAt = Date.now();
+        try {
+          const output = await model.generate(input);
+          const providerHealth = recordProviderSuccess(provider);
+          await emit({
+            at: Date.now(),
+            elapsedMs: Date.now() - startedAt,
+            fallbackProvider: provider === selectedProvider ? undefined : provider,
+            provider,
+            providerHealth,
+            recovered: provider !== selectedProvider,
+            selectedProvider,
+            status: provider === selectedProvider ? "success" : "fallback"
+          }, input);
+          return output;
+        } catch (error) {
+          lastError = error;
+          const hasNextProvider = index < order.length - 1;
+          const isProviderError = options.isProviderError?.(error, provider) ?? true;
+          const rateLimited = options.isRateLimitError?.(error, provider) ?? defaultIsRateLimitError(error);
+          const shouldFallback = fallbackMode === "provider-error" ? isProviderError : fallbackMode === "rate-limit" ? isProviderError && rateLimited : false;
+          const providerHealth = recordProviderError(provider, isProviderError, rateLimited);
+          const nextProvider = hasNextProvider ? order[index + 1] : undefined;
+          await emit({
+            at: Date.now(),
+            elapsedMs: Date.now() - startedAt,
+            error: errorMessage(error),
+            fallbackProvider: shouldFallback ? nextProvider : undefined,
+            provider,
+            providerHealth,
+            rateLimited,
+            selectedProvider,
+            suppressionRemainingMs: getSuppressionRemainingMs(provider),
+            suppressedUntil: providerHealth?.suppressedUntil,
+            status: "error"
+          }, input);
+          if (!hasNextProvider || !shouldFallback) {
+            throw error;
+          }
+        }
+      }
+      throw lastError ?? new Error("Voice provider router did not run a provider.");
+    }
+  };
+};
+var messageToOpenAIInput = (message) => {
+  if (message.role === "tool") {
+    return [
+      {
+        call_id: message.toolCallId ?? message.name ?? crypto.randomUUID(),
+        output: message.content,
+        type: "function_call_output"
+      }
+    ];
+  }
+  const toolCalls = getMessageToolCalls(message);
+  if (message.role === "assistant" && toolCalls.length) {
+    return toolCalls.map((toolCall) => ({
+      arguments: JSON.stringify(toolCall.args),
+      call_id: toolCall.id ?? crypto.randomUUID(),
+      name: toolCall.name,
+      type: "function_call"
+    }));
+  }
+  return [
+    {
+      content: message.content,
+      role: message.role === "system" ? "developer" : message.role
+    }
+  ];
+};
+var messagesToOpenAIInput = (messages) => messages.flatMap(messageToOpenAIInput);
+var messageToAnthropicMessage = (message) => {
+  if (message.role === "system") {
+    return;
+  }
+  if (message.role === "tool") {
+    if (!message.toolCallId) {
+      return {
+        content: `Tool result from ${message.name ?? "tool"}: ${message.content}`,
+        role: "user"
+      };
+    }
+    return {
+      content: [
+        {
+          content: message.content,
+          tool_use_id: message.toolCallId,
+          type: "tool_result"
+        }
+      ],
+      role: "user"
+    };
+  }
+  const toolCalls = getMessageToolCalls(message);
+  if (message.role === "assistant" && toolCalls.length) {
+    return {
+      content: [
+        ...message.content ? [
+          {
+            text: message.content,
+            type: "text"
+          }
+        ] : [],
+        ...toolCalls.map((toolCall) => ({
+          id: toolCall.id ?? crypto.randomUUID(),
+          input: toolCall.args,
+          name: toolCall.name,
+          type: "tool_use"
+        }))
+      ],
+      role: "assistant"
+    };
+  }
+  return {
+    content: message.content,
+    role: message.role
+  };
+};
+var toGeminiSchema = (schema) => {
+  const next = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === "additionalProperties") {
+      continue;
+    }
+    if (key === "type" && typeof value === "string") {
+      next[key] = value.toUpperCase();
+      continue;
+    }
+    if (Array.isArray(value)) {
+      next[key] = value.map((item) => item && typeof item === "object" ? toGeminiSchema(item) : item);
+      continue;
+    }
+    if (value && typeof value === "object") {
+      next[key] = toGeminiSchema(value);
+      continue;
+    }
+    next[key] = value;
+  }
+  return next;
+};
+var messageToGeminiContent = (message) => {
+  if (message.role === "system") {
+    return;
+  }
+  if (message.role === "tool") {
+    return {
+      parts: [
+        {
+          functionResponse: {
+            id: message.toolCallId,
+            name: message.name ?? "tool",
+            response: {
+              result: parseJSONValue(message.content)
+            }
+          }
+        }
+      ],
+      role: "user"
+    };
+  }
+  const toolCalls = getMessageToolCalls(message);
+  if (message.role === "assistant" && toolCalls.length) {
+    return {
+      parts: [
+        ...message.content ? [
+          {
+            text: message.content
+          }
+        ] : [],
+        ...toolCalls.map((toolCall) => ({
+          functionCall: {
+            args: toolCall.args,
+            id: toolCall.id,
+            name: toolCall.name
+          }
+        }))
+      ],
+      role: "model"
+    };
+  }
+  return {
+    parts: [
+      {
+        text: message.content
+      }
+    ],
+    role: message.role === "assistant" ? "model" : "user"
+  };
+};
+var extractText = (response) => {
+  if (typeof response.output_text === "string") {
+    return response.output_text;
+  }
+  const output = Array.isArray(response.output) ? response.output : [];
+  for (const item of output) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const record = item;
+    const content = Array.isArray(record.content) ? record.content : [];
+    for (const contentItem of content) {
+      if (!contentItem || typeof contentItem !== "object") {
+        continue;
+      }
+      const contentRecord = contentItem;
+      if (typeof contentRecord.text === "string") {
+        return contentRecord.text;
+      }
+    }
+  }
+  return "";
+};
+var extractToolCalls = (response) => {
+  const output = Array.isArray(response.output) ? response.output : [];
+  const toolCalls = [];
+  for (const item of output) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const record = item;
+    if (record.type !== "function_call" || typeof record.name !== "string") {
+      continue;
+    }
+    const args = typeof record.arguments === "string" ? parseJSON(record.arguments) : {};
+    toolCalls.push({
+      args,
+      id: typeof record.call_id === "string" ? record.call_id : typeof record.id === "string" ? record.id : undefined,
+      name: record.name
+    });
+  }
+  return toolCalls;
+};
+var createOpenAIVoiceAssistantModel = (options) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const baseUrl = options.baseUrl ?? "https://api.openai.com/v1";
+  const model = options.model ?? "gpt-4.1-mini";
+  return {
+    generate: async (input) => {
+      const response = await fetchImpl(`${baseUrl.replace(/\/$/, "")}/responses`, {
+        body: JSON.stringify({
+          input: messagesToOpenAIInput(input.messages),
+          instructions: [
+            input.system,
+            "Return a JSON object with assistantText, complete, transfer, escalate, voicemail, noAnswer, and result when you are not calling tools."
+          ].filter(Boolean).join(`
+
+`),
+          max_output_tokens: options.maxOutputTokens,
+          model,
+          temperature: options.temperature,
+          text: {
+            format: {
+              name: "voice_route_result",
+              schema: OUTPUT_SCHEMA,
+              strict: false,
+              type: "json_schema"
+            }
+          },
+          tool_choice: input.tools.length ? "auto" : "none",
+          tools: input.tools.map((tool) => ({
+            description: tool.description,
+            name: tool.name,
+            parameters: tool.parameters ?? {
+              additionalProperties: true,
+              type: "object"
+            },
+            strict: false,
+            type: "function"
+          }))
+        }),
+        headers: {
+          authorization: `Bearer ${options.apiKey}`,
+          "content-type": "application/json"
+        },
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw createHTTPError("OpenAI", response);
+      }
+      const body = await response.json();
+      if (body.usage && typeof body.usage === "object") {
+        await options.onUsage?.(body.usage);
+      }
+      const toolCalls = extractToolCalls(body);
+      if (toolCalls.length) {
+        return {
+          toolCalls
+        };
+      }
+      return normalizeRouteOutput(parseJSON(extractText(body)));
+    }
+  };
+};
+var extractAnthropicText = (response) => {
+  const content = Array.isArray(response.content) ? response.content : [];
+  return content.map((item) => item && typeof item === "object" && item.type === "text" && typeof item.text === "string" ? item.text : "").filter(Boolean).join(`
+`);
+};
+var extractAnthropicToolCalls = (response) => {
+  const content = Array.isArray(response.content) ? response.content : [];
+  const toolCalls = [];
+  for (const item of content) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const record = item;
+    if (record.type !== "tool_use" || typeof record.name !== "string") {
+      continue;
+    }
+    toolCalls.push({
+      args: record.input && typeof record.input === "object" ? record.input : {},
+      id: typeof record.id === "string" ? record.id : undefined,
+      name: record.name
+    });
+  }
+  return toolCalls;
+};
+var createAnthropicVoiceAssistantModel = (options) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const baseUrl = options.baseUrl ?? "https://api.anthropic.com/v1";
+  const model = options.model ?? "claude-sonnet-4-5";
+  return {
+    generate: async (input) => {
+      const response = await fetchImpl(`${baseUrl.replace(/\/$/, "")}/messages`, {
+        body: JSON.stringify({
+          max_tokens: options.maxOutputTokens ?? 1024,
+          messages: input.messages.map(messageToAnthropicMessage).filter(Boolean),
+          model,
+          system: [input.system, ROUTE_RESULT_INSTRUCTION].filter(Boolean).join(`
+
+`),
+          temperature: options.temperature,
+          tool_choice: input.tools.length ? { type: "auto" } : { type: "none" },
+          tools: input.tools.map((tool) => ({
+            description: tool.description,
+            input_schema: tool.parameters ?? {
+              additionalProperties: true,
+              type: "object"
+            },
+            name: tool.name
+          }))
+        }),
+        headers: {
+          "anthropic-version": options.version ?? "2023-06-01",
+          "content-type": "application/json",
+          "x-api-key": options.apiKey
+        },
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw createHTTPError("Anthropic", response);
+      }
+      const body = await response.json();
+      if (body.usage && typeof body.usage === "object") {
+        await options.onUsage?.(body.usage);
+      }
+      const toolCalls = extractAnthropicToolCalls(body);
+      if (toolCalls.length) {
+        return {
+          assistantText: extractAnthropicText(body) || undefined,
+          toolCalls
+        };
+      }
+      return normalizeRouteOutput(parseJSON(extractAnthropicText(body)));
+    }
+  };
+};
+var extractGeminiCandidateParts = (response) => {
+  const candidates = Array.isArray(response.candidates) ? response.candidates : [];
+  const first = candidates[0];
+  if (!first || typeof first !== "object") {
+    return [];
+  }
+  const content = first.content;
+  if (!content || typeof content !== "object") {
+    return [];
+  }
+  const parts = content.parts;
+  return Array.isArray(parts) ? parts : [];
+};
+var extractGeminiText = (response) => extractGeminiCandidateParts(response).map((part) => part && typeof part === "object" && typeof part.text === "string" ? part.text : "").filter(Boolean).join(`
+`);
+var extractGeminiToolCalls = (response) => {
+  const toolCalls = [];
+  for (const part of extractGeminiCandidateParts(response)) {
+    if (!part || typeof part !== "object") {
+      continue;
+    }
+    const functionCall = part.functionCall;
+    if (!functionCall || typeof functionCall !== "object") {
+      continue;
+    }
+    const record = functionCall;
+    if (typeof record.name !== "string") {
+      continue;
+    }
+    toolCalls.push({
+      args: record.args && typeof record.args === "object" ? record.args : {},
+      id: typeof record.id === "string" ? record.id : undefined,
+      name: record.name
+    });
+  }
+  return toolCalls;
+};
+var createGeminiVoiceAssistantModel = (options) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const baseUrl = options.baseUrl ?? "https://generativelanguage.googleapis.com/v1beta";
+  const model = options.model ?? "gemini-2.5-flash";
+  const maxRetries = Math.max(0, options.maxRetries ?? 2);
+  return {
+    generate: async (input) => {
+      const endpoint = `${baseUrl.replace(/\/$/, "")}/models/${encodeURIComponent(model)}:generateContent?key=${encodeURIComponent(options.apiKey)}`;
+      let response;
+      for (let attempt = 0;attempt <= maxRetries; attempt += 1) {
+        response = await fetchImpl(endpoint, {
+          body: JSON.stringify({
+            contents: input.messages.map(messageToGeminiContent).filter(Boolean),
+            generationConfig: {
+              maxOutputTokens: options.maxOutputTokens,
+              ...input.tools.length ? {} : {
+                responseMimeType: "application/json",
+                responseSchema: toGeminiSchema(OUTPUT_SCHEMA)
+              },
+              temperature: options.temperature
+            },
+            systemInstruction: {
+              parts: [
+                {
+                  text: [input.system, ROUTE_RESULT_INSTRUCTION].filter(Boolean).join(`
+
+`)
+                }
+              ]
+            },
+            tools: input.tools.length ? [
+              {
+                functionDeclarations: input.tools.map((tool) => ({
+                  description: tool.description,
+                  name: tool.name,
+                  parameters: toGeminiSchema(tool.parameters ?? {
+                    additionalProperties: true,
+                    type: "object"
+                  })
+                }))
+              }
+            ] : undefined
+          }),
+          headers: {
+            "content-type": "application/json"
+          },
+          method: "POST"
+        });
+        if (response.ok || response.status !== 429 && response.status < 500 || attempt === maxRetries) {
+          break;
+        }
+        const retryAfter = Number(response.headers.get("retry-after"));
+        await sleep4(Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter * 1000 : 500 * 2 ** attempt);
+      }
+      if (!response) {
+        throw new Error("Gemini voice assistant model failed: no response");
+      }
+      if (!response.ok) {
+        throw createHTTPError("Gemini", response);
+      }
+      const body = await response.json();
+      if (body.usageMetadata && typeof body.usageMetadata === "object") {
+        await options.onUsage?.(body.usageMetadata);
+      }
+      const toolCalls = extractGeminiToolCalls(body);
+      if (toolCalls.length) {
+        return {
+          assistantText: extractGeminiText(body) || undefined,
+          toolCalls
+        };
+      }
+      return normalizeRouteOutput(parseJSON(extractGeminiText(body)));
+    }
+  };
+};
 // src/sqliteStore.ts
 import { Database } from "bun:sqlite";
 var normalizeTableNameSegment = (value) => value.trim().replace(/[^a-zA-Z0-9_]+/g, "_").replace(/^_+|_+$/g, "") || "voice";
@@ -7354,6 +9293,361 @@ var createVoiceMemoryStore = () => {
   };
   return { get, getOrCreate, list, remove, set };
 };
+// src/opsWebhook.ts
+import { Elysia as Elysia5 } 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 Elysia5().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/handoffHealth.ts
+import { Elysia as Elysia6 } from "elysia";
+var escapeHtml7 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var getString4 = (value) => typeof value === "string" && value.length > 0 ? value : undefined;
+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: getString4(record.adapterId) ?? adapterId,
+    adapterKind: getString4(record.adapterKind),
+    deliveredAt: typeof record.deliveredAt === "number" ? record.deliveredAt : undefined,
+    deliveredTo: getString4(record.deliveredTo),
+    error: getString4(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: getString4(event.payload.action),
+      at: event.at,
+      deliveries,
+      reason: getString4(event.payload.reason),
+      sessionId: event.sessionId,
+      status,
+      target: getString4(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>${escapeHtml7(action)}: ${String(count)}</li>`).join("")}</ul>`,
+    "</article>",
+    "<article><h3>Adapters</h3>",
+    adapters.length === 0 ? "<p>No adapter deliveries yet.</p>" : `<ul>${adapters.map(([adapterId, counts]) => `<li>${escapeHtml7(adapterId)}: ${String(counts.delivered)} delivered / ${String(counts.failed)} failed / ${String(counts.skipped)} skipped</li>`).join("")}</ul>`,
+    "</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="${escapeHtml7(event.status)}">`,
+      '<div class="voice-handoff-health-event-header">',
+      `<strong>${escapeHtml7(event.action ?? "handoff")}</strong>`,
+      `<span>${escapeHtml7(event.status)}</span>`,
+      "</div>",
+      `<p><small>${escapeHtml7(event.sessionId)}</small></p>`,
+      event.target ? `<p>Target: ${escapeHtml7(event.target)}</p>` : "",
+      event.reason ? `<p>Reason: ${escapeHtml7(event.reason)}</p>` : "",
+      event.deliveries.length ? `<ul>${event.deliveries.map((delivery) => [
+        "<li>",
+        `${escapeHtml7(delivery.adapterId)}: ${escapeHtml7(delivery.status)}`,
+        delivery.deliveredTo ? ` to ${escapeHtml7(delivery.deliveredTo)}` : "",
+        delivery.error ? ` (${escapeHtml7(delivery.error)})` : "",
+        "</li>"
+      ].join("")).join("")}</ul>` : "",
+      event.replayHref ? `<p><a href="${escapeHtml7(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/queue.ts
 var releaseLeaseScript = `
 if redis.call("GET", KEYS[1]) == ARGV[1] then
@@ -7425,6 +9719,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) : []);
@@ -7506,6 +9802,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) : []);
@@ -7935,6 +10273,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) => {
@@ -8070,10 +10510,10 @@ var createVoiceOpsTaskProcessorWorker = (options) => ({
         result.completed += 1;
       } catch (error) {
         await options.onError?.(error, task);
-        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorMessage2 = error instanceof Error ? error.message : String(error);
         const failedTask = failVoiceOpsTask(task, {
           actor: task.claimedBy ?? "ops-worker",
-          error: errorMessage
+          error: errorMessage2
         });
         if (shouldDeadLetterTask(failedTask, options.maxFailures)) {
           const deadLetterTask = deadLetterVoiceOpsTask(failedTask, {
@@ -8886,7 +11326,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;
@@ -9082,8 +11522,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);
@@ -9319,15 +11759,22 @@ export {
   withVoiceOpsTaskId,
   withVoiceIntegrationEventId,
   voice,
+  verifyVoiceOpsWebhookSignature,
   transcodeTwilioInboundPayloadToPCM16,
   transcodePCMToTwilioOutboundPayload,
   summarizeVoiceTraceSinkDeliveries,
   summarizeVoiceTrace,
+  summarizeVoiceSessions,
+  summarizeVoiceSessionReplay,
+  summarizeVoiceProviderHealth,
   summarizeVoiceOpsTasks,
   summarizeVoiceOpsTaskQueue,
   summarizeVoiceOpsTaskAnalytics,
   summarizeVoiceIntegrationEvents,
+  summarizeVoiceHandoffHealth,
+  summarizeVoiceHandoffDeliveries,
   summarizeVoiceAssistantRuns,
+  summarizeVoiceAssistantHealth,
   startVoiceOpsTask,
   shapeTelephonyAssistantText,
   selectVoiceTraceEventsForPrune,
@@ -9339,14 +11786,19 @@ export {
   resolveVoiceOpsTaskAssignment,
   resolveVoiceOpsTaskAgeBucket,
   resolveVoiceOpsPreset,
+  resolveVoiceAssistantMemoryNamespace,
   resolveTurnDetectionConfig,
   resolveAudioConditioningConfig,
   requeueVoiceOpsTask,
   reopenVoiceOpsTask,
   renderVoiceTraceMarkdown,
   renderVoiceTraceHTML,
+  renderVoiceSessionsHTML,
+  renderVoiceProviderHealthHTML,
+  renderVoiceHandoffHealthHTML,
   renderVoiceCallReviewMarkdown,
   renderVoiceCallReviewHTML,
+  renderVoiceAssistantHealthHTML,
   redactVoiceTraceText,
   redactVoiceTraceEvents,
   redactVoiceTraceEvent,
@@ -9366,13 +11818,17 @@ export {
   deliverVoiceTraceEventsToSinks,
   deliverVoiceIntegrationEventToSinks,
   deliverVoiceIntegrationEvent,
+  deliverVoiceHandoffDelivery,
+  deliverVoiceHandoff,
   decodeTwilioMulawBase64,
   deadLetterVoiceOpsTask,
   createVoiceZendeskTicketUpdateSink,
   createVoiceZendeskTicketSyncSinks,
   createVoiceZendeskTicketSink,
+  createVoiceWebhookHandoffAdapter,
   createVoiceWebhookDeliveryWorkerLoop,
   createVoiceWebhookDeliveryWorker,
+  createVoiceTwilioRedirectHandoffAdapter,
   createVoiceTraceSinkStore,
   createVoiceTraceSinkDeliveryWorkerLoop,
   createVoiceTraceSinkDeliveryWorker,
@@ -9384,7 +11840,13 @@ export {
   createVoiceTaskUpdatedEvent,
   createVoiceTaskSLABreachedEvent,
   createVoiceTaskCreatedEvent,
+  createVoiceSessionsJSONHandler,
+  createVoiceSessionsHTMLHandler,
+  createVoiceSessionReplayRoutes,
+  createVoiceSessionReplayJSONHandler,
+  createVoiceSessionReplayHTMLHandler,
   createVoiceSessionRecord,
+  createVoiceSessionListRoutes,
   createVoiceSession,
   createVoiceSTTRoutingCorrectionHandler,
   createVoiceSQLiteTraceSinkDeliveryStore,
@@ -9399,6 +11861,10 @@ export {
   createVoiceReviewSavedEvent,
   createVoiceRedisTaskLeaseCoordinator,
   createVoiceRedisIdempotencyStore,
+  createVoiceProviderRouter,
+  createVoiceProviderHealthRoutes,
+  createVoiceProviderHealthJSONHandler,
+  createVoiceProviderHealthHTMLHandler,
   createVoicePostgresTraceSinkDeliveryStore,
   createVoicePostgresTraceEventStore,
   createVoicePostgresTaskStore,
@@ -9407,6 +11873,9 @@ export {
   createVoicePostgresReviewStore,
   createVoicePostgresIntegrationEventStore,
   createVoicePostgresExternalObjectMapStore,
+  createVoiceOpsWebhookSink,
+  createVoiceOpsWebhookReceiverRoutes,
+  createVoiceOpsWebhookEnvelope,
   createVoiceOpsTaskWorker,
   createVoiceOpsTaskProcessorWorkerLoop,
   createVoiceOpsTaskProcessorWorker,
@@ -9414,6 +11883,8 @@ export {
   createVoiceMemoryTraceSinkDeliveryStore,
   createVoiceMemoryTraceEventStore,
   createVoiceMemoryStore,
+  createVoiceMemoryHandoffDeliveryStore,
+  createVoiceMemoryAssistantMemoryStore,
   createVoiceLinearIssueUpdateSink,
   createVoiceLinearIssueSyncSinks,
   createVoiceLinearIssueSink,
@@ -9425,6 +11896,12 @@ export {
   createVoiceHubSpotTaskSyncSinks,
   createVoiceHubSpotTaskSink,
   createVoiceHelpdeskTicketSink,
+  createVoiceHandoffHealthRoutes,
+  createVoiceHandoffHealthJSONHandler,
+  createVoiceHandoffHealthHTMLHandler,
+  createVoiceHandoffDeliveryWorkerLoop,
+  createVoiceHandoffDeliveryWorker,
+  createVoiceHandoffDeliveryRecord,
   createVoiceFileTraceSinkDeliveryStore,
   createVoiceFileTraceEventStore,
   createVoiceFileTaskStore,
@@ -9433,6 +11910,7 @@ export {
   createVoiceFileReviewStore,
   createVoiceFileIntegrationEventStore,
   createVoiceFileExternalObjectMapStore,
+  createVoiceFileAssistantMemoryStore,
   createVoiceExternalObjectMapId,
   createVoiceExternalObjectMap,
   createVoiceExperiment,
@@ -9441,6 +11919,11 @@ export {
   createVoiceCallReviewFromLiveTelephonyReport,
   createVoiceCallCompletedEvent,
   createVoiceCRMActivitySink,
+  createVoiceAssistantMemoryRecord,
+  createVoiceAssistantMemoryHandle,
+  createVoiceAssistantHealthRoutes,
+  createVoiceAssistantHealthJSONHandler,
+  createVoiceAssistantHealthHTMLHandler,
   createVoiceAssistant,
   createVoiceAgentTool,
   createVoiceAgentSquad,
@@ -9453,9 +11936,13 @@ export {
   createStoredVoiceCallReviewArtifact,
   createRiskyTurnCorrectionHandler,
   createPhraseHintCorrectionHandler,
+  createOpenAIVoiceAssistantModel,
+  createJSONVoiceAssistantModel,
   createId,
+  createGeminiVoiceAssistantModel,
   createDomainPhraseHints,
   createDomainLexicon,
+  createAnthropicVoiceAssistantModel,
   conditionAudioChunk,
   completeVoiceOpsTask,
   claimVoiceOpsTask,
@@ -9465,6 +11952,7 @@ export {
   assignVoiceOpsTask,
   applyVoiceOpsTaskPolicy,
   applyVoiceOpsTaskAssignmentRule,
+  applyVoiceHandoffDeliveryResult,
   applyRiskTieredPhraseHintCorrections,
   applyPhraseHintCorrections,
   TURN_PROFILE_DEFAULTS