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

package/dist/testing/index.js

@@ -2105,6 +2105,11 @@ var serverMessageToAction = (message) => {
         sessionId: message.sessionId,
         type: "complete"
       };
+    case "connection":
+      return {
+        reconnect: message.reconnect,
+        type: "connection"
+      };
     case "call_lifecycle":
       return {
         event: message.event,
@@ -2126,6 +2131,17 @@ var serverMessageToAction = (message) => {
         transcript: message.transcript,
         type: "partial"
       };
+    case "replay":
+      return {
+        assistantTexts: message.assistantTexts,
+        call: message.call,
+        partial: message.partial,
+        scenarioId: message.scenarioId,
+        sessionId: message.sessionId,
+        status: message.status,
+        turns: message.turns,
+        type: "replay"
+      };
     case "session":
       return {
         sessionId: message.sessionId,
@@ -2186,10 +2202,12 @@ var isVoiceServerMessage = (value) => {
     case "assistant":
     case "call_lifecycle":
     case "complete":
+    case "connection":
     case "error":
     case "final":
     case "partial":
     case "pong":
+    case "replay":
     case "session":
     case "turn":
       return true;
@@ -2226,6 +2244,9 @@ var createVoiceConnection = (path, options = {}) => {
     sessionId: options.sessionId ?? createSessionId(),
     ws: null
   };
+  const emitConnection = (reconnect) => {
+    listeners.forEach((listener) => listener(reconnect));
+  };
   const clearTimers = () => {
     if (state.pingInterval) {
       clearInterval(state.pingInterval);
@@ -2248,9 +2269,28 @@ var createVoiceConnection = (path, options = {}) => {
     }
   };
   const scheduleReconnect = () => {
+    const nextAttemptAt = Date.now() + RECONNECT_DELAY_MS;
     state.reconnectAttempts += 1;
+    emitConnection({
+      reconnect: {
+        attempts: state.reconnectAttempts,
+        lastDisconnectAt: Date.now(),
+        maxAttempts: maxReconnectAttempts,
+        nextAttemptAt,
+        status: "reconnecting"
+      },
+      type: "connection"
+    });
     state.reconnectTimeout = setTimeout(() => {
       if (state.reconnectAttempts > maxReconnectAttempts) {
+        emitConnection({
+          reconnect: {
+            attempts: state.reconnectAttempts,
+            maxAttempts: maxReconnectAttempts,
+            status: "exhausted"
+          },
+          type: "connection"
+        });
         return;
       }
       connect();
@@ -2260,9 +2300,21 @@ var createVoiceConnection = (path, options = {}) => {
     const ws = new WebSocket(buildWsUrl(path, state.sessionId, state.scenarioId));
     ws.binaryType = "arraybuffer";
     ws.onopen = () => {
+      const wasReconnecting = state.reconnectAttempts > 0;
       state.isConnected = true;
-      state.reconnectAttempts = 0;
       flushPendingMessages();
+      if (wasReconnecting) {
+        emitConnection({
+          reconnect: {
+            attempts: state.reconnectAttempts,
+            lastResumedAt: Date.now(),
+            maxAttempts: maxReconnectAttempts,
+            status: "resumed"
+          },
+          type: "connection"
+        });
+        state.reconnectAttempts = 0;
+      }
       listeners.forEach((listener) => listener({
         scenarioId: state.scenarioId ?? undefined,
         sessionId: state.sessionId,
@@ -2292,6 +2344,16 @@ var createVoiceConnection = (path, options = {}) => {
       const reconnectable = shouldReconnect && event.code !== WS_NORMAL_CLOSURE && state.reconnectAttempts < maxReconnectAttempts;
       if (reconnectable) {
         scheduleReconnect();
+      } else if (shouldReconnect && event.code !== WS_NORMAL_CLOSURE) {
+        emitConnection({
+          reconnect: {
+            attempts: state.reconnectAttempts,
+            lastDisconnectAt: Date.now(),
+            maxAttempts: maxReconnectAttempts,
+            status: "exhausted"
+          },
+          type: "connection"
+        });
       }
     };
     state.ws = ws;
@@ -2362,6 +2424,11 @@ var createVoiceConnection = (path, options = {}) => {
 };
 
 // src/client/store.ts
+var createInitialReconnectState = () => ({
+  attempts: 0,
+  maxAttempts: 0,
+  status: "idle"
+});
 var createInitialState2 = () => ({
   assistantAudio: [],
   assistantTexts: [],
@@ -2370,6 +2437,7 @@ var createInitialState2 = () => ({
   isConnected: false,
   scenarioId: null,
   partial: "",
+  reconnect: createInitialReconnectState(),
   sessionId: null,
   status: "idle",
   turns: []
@@ -2426,7 +2494,19 @@ var createVoiceStreamStore = () => {
       case "connected":
         state = {
           ...state,
-          isConnected: true
+          isConnected: true,
+          reconnect: state.reconnect.status === "reconnecting" ? {
+            ...state.reconnect,
+            lastResumedAt: Date.now(),
+            nextAttemptAt: undefined,
+            status: "resumed"
+          } : state.reconnect
+        };
+        break;
+      case "connection":
+        state = {
+          ...state,
+          reconnect: action.reconnect
         };
         break;
       case "disconnected":
@@ -2454,6 +2534,26 @@ var createVoiceStreamStore = () => {
           partial: action.transcript.text
         };
         break;
+      case "replay":
+        state = {
+          ...state,
+          assistantTexts: [...action.assistantTexts],
+          call: action.call ?? null,
+          error: null,
+          isConnected: action.status === "active",
+          partial: action.partial,
+          reconnect: state.reconnect.status === "reconnecting" ? {
+            ...state.reconnect,
+            lastResumedAt: Date.now(),
+            nextAttemptAt: undefined,
+            status: "resumed"
+          } : state.reconnect,
+          scenarioId: action.scenarioId ?? state.scenarioId,
+          sessionId: action.sessionId,
+          status: action.status,
+          turns: [...action.turns]
+        };
+        break;
       case "session":
         state = {
           ...state,
@@ -2501,10 +2601,34 @@ var createVoiceStream = (path, options = {}) => {
   const notify = () => {
     subscribers.forEach((subscriber) => subscriber());
   };
+  const reportReconnect = () => {
+    if (!options.reconnectReportPath || typeof fetch === "undefined") {
+      return;
+    }
+    const snapshot = store.getSnapshot();
+    const body = JSON.stringify({
+      at: Date.now(),
+      reconnect: snapshot.reconnect,
+      scenarioId: snapshot.scenarioId,
+      sessionId: connection.getSessionId(),
+      turnIds: snapshot.turns.map((turn) => turn.id)
+    });
+    fetch(options.reconnectReportPath, {
+      body,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      keepalive: true,
+      method: "POST"
+    }).catch(() => {});
+  };
   const unsubscribeConnection = connection.subscribe((message) => {
     const action = serverMessageToAction(message);
     if (action) {
       store.dispatch(action);
+      if (message.type === "connection") {
+        reportReconnect();
+      }
       notify();
     }
   });
@@ -2540,6 +2664,9 @@ var createVoiceStream = (path, options = {}) => {
     get partial() {
       return store.getSnapshot().partial;
     },
+    get reconnect() {
+      return store.getSnapshot().reconnect;
+    },
     get sessionId() {
       return connection.getSessionId();
     },
@@ -2895,6 +3022,7 @@ var createInitialState3 = (stream) => ({
   isConnected: stream.isConnected,
   isRecording: false,
   partial: stream.partial,
+  reconnect: stream.reconnect,
   recordingError: null,
   sessionId: stream.sessionId,
   scenarioId: stream.scenarioId,
@@ -2924,6 +3052,7 @@ var createVoiceController = (path, options = {}) => {
       error: stream.error,
       isConnected: stream.isConnected,
       partial: stream.partial,
+      reconnect: stream.reconnect,
       sessionId: stream.sessionId,
       scenarioId: stream.scenarioId,
       status: stream.status,
@@ -2948,7 +3077,13 @@ var createVoiceController = (path, options = {}) => {
     capture = createMicrophoneCapture({
       channelCount: options.capture?.channelCount ?? preset.capture.channelCount,
       onLevel: options.capture?.onLevel,
-      onAudio: (audio) => stream.sendAudio(audio),
+      onAudio: (audio) => {
+        if (options.capture?.onAudio) {
+          options.capture.onAudio(audio, stream.sendAudio);
+          return;
+        }
+        stream.sendAudio(audio);
+      },
       sampleRateHz: options.capture?.sampleRateHz ?? preset.capture.sampleRateHz
     });
     return capture;
@@ -3018,6 +3153,9 @@ var createVoiceController = (path, options = {}) => {
     get recordingError() {
       return state.recordingError;
     },
+    get reconnect() {
+      return state.reconnect;
+    },
     sendAudio: (audio) => stream.sendAudio(audio),
     get sessionId() {
       return state.sessionId;
@@ -3063,11 +3201,26 @@ var DEFAULT_INTERRUPT_THRESHOLD = 0.08;
 var shouldInterruptForLevel = (level, options = {}) => (options.enabled ?? true) && level >= (options.interruptThreshold ?? DEFAULT_INTERRUPT_THRESHOLD);
 var bindVoiceBargeIn = (controller, player, options = {}) => {
   let lastPartial = controller.partial;
-  const interruptIfPlaying = () => {
+  const interruptIfPlaying = (reason) => {
     if (!player.isPlaying || options.enabled === false) {
+      options.monitor?.recordSkipped({
+        reason,
+        sessionId: controller.sessionId
+      });
       return;
     }
-    player.interrupt();
+    options.monitor?.recordRequested({
+      reason,
+      sessionId: controller.sessionId
+    });
+    player.interrupt().then(() => {
+      options.monitor?.recordStopped({
+        latencyMs: player.lastInterruptLatencyMs,
+        playbackStopLatencyMs: player.lastPlaybackStopLatencyMs,
+        reason,
+        sessionId: controller.sessionId
+      });
+    });
   };
   const unsubscribe = controller.subscribe(() => {
     if (options.interruptOnPartial === false) {
@@ -3075,7 +3228,7 @@ var bindVoiceBargeIn = (controller, player, options = {}) => {
       return;
     }
     if (!lastPartial && controller.partial) {
-      interruptIfPlaying();
+      interruptIfPlaying("partial-transcript");
     }
     lastPartial = controller.partial;
   });
@@ -3085,11 +3238,11 @@ var bindVoiceBargeIn = (controller, player, options = {}) => {
     },
     handleLevel: (level) => {
       if (shouldInterruptForLevel(level, options)) {
-        interruptIfPlaying();
+        interruptIfPlaying("input-level");
       }
     },
     sendAudio: (audio) => {
-      interruptIfPlaying();
+      interruptIfPlaying("manual-audio");
       controller.sendAudio(audio);
     }
   };
@@ -3119,7 +3272,17 @@ var createVoiceDuplexController = (path, options = {}) => {
     audioPlayer,
     close,
     interruptAssistant: async () => {
+      options.bargeIn?.monitor?.recordRequested({
+        reason: "manual-interrupt",
+        sessionId: controller.sessionId
+      });
       await audioPlayer.interrupt();
+      options.bargeIn?.monitor?.recordStopped({
+        latencyMs: audioPlayer.lastInterruptLatencyMs,
+        playbackStopLatencyMs: audioPlayer.lastPlaybackStopLatencyMs,
+        reason: "manual-interrupt",
+        sessionId: controller.sessionId
+      });
     },
     sendAudio: (audio) => {
       bargeInBinding?.sendAudio(audio);
@@ -3510,7 +3673,235 @@ var loadVoiceTestFixtures = async (fixtureDirectory) => {
   }
   return fixtures;
 };
+// src/testing/ioProviderSimulator.ts
+var defaultFailureMessage = (input) => `Simulated ${input.provider} ${input.kind.toUpperCase()} ${input.operation} failure.`;
+var resolveRecoveryElapsedMs = (value, provider) => {
+  if (typeof value === "number") {
+    return value;
+  }
+  return value?.[provider] ?? 25;
+};
+var createHealth = (input) => ({
+  consecutiveFailures: input.status === "healthy" ? 0 : 1,
+  lastFailureAt: input.status === "healthy" ? undefined : input.now,
+  provider: input.provider,
+  status: input.status,
+  suppressedUntil: input.suppressedUntil
+});
+var resolveFallback = async (options, provider) => {
+  const configured = typeof options.fallback === "function" ? await options.fallback(provider) : options.fallback;
+  return (configured ?? options.providers).find((candidate) => candidate !== provider);
+};
+var createVoiceIOProviderFailureSimulator = (options) => {
+  if (options.providers.length === 0) {
+    throw new Error("At least one provider is required.");
+  }
+  const now = options.now ?? Date.now;
+  const operation = options.operation ?? "open";
+  const cooldownMs = Math.max(0, options.cooldownMs ?? 30000);
+  const emit = async (event, input) => {
+    await options.onProviderEvent?.(event, input);
+  };
+  const run = async (provider, mode) => {
+    if (!options.providers.includes(provider)) {
+      throw new Error(`${provider} is not configured for simulation.`);
+    }
+    const startedAt = now();
+    const sessionId = options.sessionId?.({ mode, now: startedAt, provider }) ?? `${options.kind}-provider-sim-${startedAt}`;
+    if (mode === "recovery") {
+      await emit({
+        at: startedAt,
+        attempt: 0,
+        elapsedMs: resolveRecoveryElapsedMs(options.recoveryElapsedMs, provider),
+        kind: options.kind,
+        latencyBudgetMs: options.latencyBudgets?.[provider],
+        operation,
+        provider,
+        providerHealth: createHealth({
+          now: startedAt,
+          provider,
+          status: "healthy"
+        }),
+        selectedProvider: provider,
+        status: "success"
+      }, { mode, provider, sessionId });
+      return {
+        mode,
+        provider,
+        sessionId,
+        status: "simulated"
+      };
+    }
+    const fallbackProvider = await resolveFallback(options, provider);
+    const suppressedUntil = startedAt + cooldownMs;
+    await emit({
+      at: startedAt,
+      attempt: 0,
+      elapsedMs: options.failureElapsedMs ?? 10,
+      error: (options.failureMessage ?? defaultFailureMessage)({
+        kind: options.kind,
+        operation,
+        provider
+      }),
+      fallbackProvider,
+      kind: options.kind,
+      latencyBudgetMs: options.latencyBudgets?.[provider],
+      operation,
+      provider,
+      providerHealth: createHealth({
+        now: startedAt,
+        provider,
+        status: "suppressed",
+        suppressedUntil
+      }),
+      selectedProvider: provider,
+      status: "error",
+      suppressedUntil
+    }, { mode, provider, sessionId });
+    if (fallbackProvider) {
+      await emit({
+        at: startedAt + 1,
+        attempt: 1,
+        elapsedMs: resolveRecoveryElapsedMs(options.recoveryElapsedMs, fallbackProvider),
+        fallbackProvider,
+        kind: options.kind,
+        latencyBudgetMs: options.latencyBudgets?.[fallbackProvider],
+        operation,
+        provider: fallbackProvider,
+        providerHealth: createHealth({
+          now: startedAt + 1,
+          provider: fallbackProvider,
+          status: "healthy"
+        }),
+        selectedProvider: provider,
+        status: "fallback"
+      }, { mode, provider, sessionId });
+    }
+    return {
+      fallbackProvider,
+      mode,
+      provider,
+      sessionId,
+      status: "simulated",
+      suppressedUntil
+    };
+  };
+  return {
+    run
+  };
+};
 // src/modelAdapters.ts
+var isVoiceProviderRoutingPolicyPreset = (value) => value === "balanced" || value === "cost-cap" || value === "cost-first" || value === "latency-first" || value === "quality-first";
+var resolveVoiceProviderRoutingPolicyPreset = (preset, options = {}) => {
+  switch (preset) {
+    case "balanced":
+      return {
+        fallbackMode: "provider-error",
+        strategy: "balanced",
+        weights: {
+          cost: 1,
+          latencyMs: 0.005,
+          priority: 1,
+          quality: 10,
+          ...options.weights
+        },
+        ...options
+      };
+    case "cost-cap":
+      return {
+        fallbackMode: "provider-error",
+        strategy: "prefer-cheapest",
+        ...options
+      };
+    case "cost-first":
+      return {
+        fallbackMode: "provider-error",
+        strategy: "prefer-cheapest",
+        ...options
+      };
+    case "latency-first":
+      return {
+        fallbackMode: "provider-error",
+        strategy: "prefer-fastest",
+        ...options
+      };
+    case "quality-first":
+      return {
+        fallbackMode: "provider-error",
+        strategy: "quality-first",
+        ...options
+      };
+  }
+};
+var resolveVoiceProviderRoutingPolicy = (policy) => {
+  if (!policy) {
+    return;
+  }
+  if (typeof policy === "string") {
+    return isVoiceProviderRoutingPolicyPreset(policy) ? resolveVoiceProviderRoutingPolicyPreset(policy) : {
+      strategy: policy
+    };
+  }
+  return policy;
+};
+var mergeDefinedProviderPolicyFields = (base, surface) => {
+  const next = {
+    ...base ?? {}
+  };
+  if (surface.allowProviders !== undefined) {
+    next.allowProviders = surface.allowProviders;
+  }
+  if (surface.fallbackMode !== undefined) {
+    next.fallbackMode = surface.fallbackMode;
+  }
+  if (surface.maxCost !== undefined) {
+    next.maxCost = surface.maxCost;
+  }
+  if (surface.maxLatencyMs !== undefined) {
+    next.maxLatencyMs = surface.maxLatencyMs;
+  }
+  if (surface.minQuality !== undefined) {
+    next.minQuality = surface.minQuality;
+  }
+  if (surface.strategy !== undefined) {
+    next.strategy = surface.strategy;
+  }
+  if (surface.weights !== undefined) {
+    next.weights = {
+      ...base?.weights ?? {},
+      ...surface.weights
+    };
+  }
+  return next;
+};
+var createVoiceProviderOrchestrationProfile = (options) => {
+  const surfaceNames = Object.keys(options.surfaces);
+  const defaultSurface = options.defaultSurface ?? surfaceNames[0];
+  if (!defaultSurface || !options.surfaces[defaultSurface]) {
+    throw new Error("Voice provider orchestration profile has no surfaces.");
+  }
+  return {
+    defaultSurface,
+    id: options.id,
+    resolve: (surface = defaultSurface) => {
+      const config = options.surfaces[surface];
+      if (!config) {
+        throw new Error(`Voice provider orchestration profile ${options.id} has no surface "${surface}".`);
+      }
+      const policy = mergeDefinedProviderPolicyFields(resolveVoiceProviderRoutingPolicy(config.policy), config);
+      return {
+        allowProviders: config.allowProviders,
+        fallback: config.fallback,
+        fallbackMode: config.fallbackMode,
+        policy,
+        providerHealth: config.providerHealth,
+        providerProfiles: config.providerProfiles,
+        timeoutMs: config.timeoutMs
+      };
+    },
+    surfaces: options.surfaces
+  };
+};
 var OUTPUT_SCHEMA = {
   additionalProperties: false,
   properties: {
@@ -3601,6 +3992,17 @@ var parseJSONValue = (value) => {
     return value;
   }
 };
+
+class VoiceProviderTimeoutError extends Error {
+  provider;
+  timeoutMs;
+  constructor(provider, timeoutMs) {
+    super(`Voice provider ${provider} exceeded ${timeoutMs}ms latency budget.`);
+    this.name = "VoiceProviderTimeoutError";
+    this.provider = provider;
+    this.timeoutMs = timeoutMs;
+  }
+}
 var getMessageToolCalls = (message) => {
   const toolCalls = message.metadata?.toolCalls;
   return Array.isArray(toolCalls) ? toolCalls.filter((toolCall) => toolCall && typeof toolCall === "object" && typeof toolCall.name === "string") : [];
@@ -3667,17 +4069,25 @@ var createJSONVoiceAssistantModel = (options) => ({
 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 orchestrationSurface = options.orchestrationProfile?.resolve(options.orchestrationSurface);
+  const policy = resolveVoiceProviderRoutingPolicy(options.policy) ?? resolveVoiceProviderRoutingPolicy(orchestrationSurface?.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 fallbackMode = policy?.fallbackMode ?? options.fallbackMode ?? orchestrationSurface?.fallbackMode ?? "provider-error";
+  const providerProfiles = {
+    ...orchestrationSurface?.providerProfiles ?? {},
+    ...options.providerProfiles ?? {}
+  };
+  const providerHealthOption = options.providerHealth ?? orchestrationSurface?.providerHealth;
+  const healthOptions = typeof providerHealthOption === "object" ? providerHealthOption : providerHealthOption ? {} : undefined;
   const healthState = new Map;
   const now = () => healthOptions?.now?.() ?? Date.now();
   const failureThreshold = Math.max(1, healthOptions?.failureThreshold ?? 1);
   const cooldownMs = Math.max(0, healthOptions?.cooldownMs ?? 30000);
   const rateLimitCooldownMs = Math.max(0, healthOptions?.rateLimitCooldownMs ?? 60000);
+  const getProviderTimeoutMs = (provider) => {
+    const timeoutMs = providerProfiles[provider]?.timeoutMs ?? options.timeoutMs ?? orchestrationSurface?.timeoutMs;
+    return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined;
+  };
   const getHealth = (provider) => {
     const existing = healthState.get(provider);
     if (existing) {
@@ -3741,17 +4151,44 @@ var createVoiceProviderRouter = (options) => {
     return cloneHealth(provider);
   };
   const resolveAllowedProviders = async (input) => {
-    const allowProviders = policy?.allowProviders ?? options.allowProviders;
+    const allowProviders = policy?.allowProviders ?? options.allowProviders ?? orchestrationSurface?.allowProviders;
     const allowed = typeof allowProviders === "function" ? await allowProviders(input) : allowProviders;
     return new Set(allowed ?? providerIds);
   };
+  const passesBudgetFilters = (provider) => {
+    const profile = providerProfiles[provider];
+    if (typeof policy?.maxCost === "number" && typeof profile?.cost === "number" && profile.cost > policy.maxCost) {
+      return false;
+    }
+    if (typeof policy?.maxLatencyMs === "number" && typeof profile?.latencyMs === "number" && profile.latencyMs > policy.maxLatencyMs) {
+      return false;
+    }
+    if (typeof policy?.minQuality === "number" && typeof profile?.quality === "number" && profile.quality < policy.minQuality) {
+      return false;
+    }
+    return true;
+  };
+  const getBalancedScore = (provider) => {
+    const profile = providerProfiles[provider];
+    if (policy?.scoreProvider) {
+      return policy.scoreProvider(provider, profile);
+    }
+    const weights = policy?.weights ?? {};
+    return (profile?.cost ?? Number.MAX_SAFE_INTEGER) * (weights.cost ?? 1) + (profile?.latencyMs ?? Number.MAX_SAFE_INTEGER) * (weights.latencyMs ?? 0.005) + (profile?.priority ?? 0) * (weights.priority ?? 1) - (profile?.quality ?? 0) * (weights.quality ?? 10);
+  };
   const sortProviders = (providers) => {
-    if (strategy !== "prefer-cheapest" && strategy !== "prefer-fastest") {
+    if (strategy !== "prefer-cheapest" && strategy !== "prefer-fastest" && strategy !== "quality-first" && strategy !== "balanced") {
       return providers;
     }
     return [...providers].sort((left, right) => {
-      const leftProfile = options.providerProfiles?.[left];
-      const rightProfile = options.providerProfiles?.[right];
+      const leftProfile = providerProfiles[left];
+      const rightProfile = providerProfiles[right];
+      if (strategy === "quality-first") {
+        return (rightProfile?.quality ?? Number.MIN_SAFE_INTEGER) - (leftProfile?.quality ?? Number.MIN_SAFE_INTEGER) || (leftProfile?.priority ?? Number.MAX_SAFE_INTEGER) - (rightProfile?.priority ?? Number.MAX_SAFE_INTEGER) || (leftProfile?.latencyMs ?? Number.MAX_SAFE_INTEGER) - (rightProfile?.latencyMs ?? Number.MAX_SAFE_INTEGER) || (leftProfile?.cost ?? Number.MAX_SAFE_INTEGER) - (rightProfile?.cost ?? Number.MAX_SAFE_INTEGER);
+      }
+      if (strategy === "balanced") {
+        return getBalancedScore(left) - getBalancedScore(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);
@@ -3760,13 +4197,15 @@ var createVoiceProviderRouter = (options) => {
   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([
+    const fallbackSource = options.fallback ?? orchestrationSurface?.fallback;
+    const fallbackOrder = typeof fallbackSource === "function" ? await fallbackSource(input) : fallbackSource;
+    const allowedRankedProviders = sortProviders([
       ...fallbackOrder ?? providerIds
     ]).filter((provider) => allowedProviders.has(provider));
+    const rankedProviders = allowedRankedProviders.filter(passesBudgetFilters);
     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 preferred = selectedProvider && allowedProviders.has(selectedProvider) && passesBudgetFilters(selectedProvider) && (!healthOptions || !isSuppressed(selectedProvider)) ? selectedProvider : candidateRankedProviders[0] ?? firstProvider;
     const seen = new Set;
     const order = [];
     const candidates = strategy === "ordered" ? candidateRankedProviders : [
@@ -3789,6 +4228,25 @@ var createVoiceProviderRouter = (options) => {
   const emit = async (event, input) => {
     await options.onProviderEvent?.(event, input);
   };
+  const runProvider = async (provider, model, input) => {
+    const timeoutMs = getProviderTimeoutMs(provider);
+    if (!timeoutMs) {
+      return model.generate(input);
+    }
+    let timeout;
+    try {
+      return await Promise.race([
+        model.generate(input),
+        new Promise((_, reject) => {
+          timeout = setTimeout(() => reject(new VoiceProviderTimeoutError(provider, timeoutMs)), timeoutMs);
+        })
+      ]);
+    } finally {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+    }
+  };
   return {
     generate: async (input) => {
       const { order, selectedProvider } = await resolveOrder(input);
@@ -3803,12 +4261,14 @@ var createVoiceProviderRouter = (options) => {
         }
         const startedAt = Date.now();
         try {
-          const output = await model.generate(input);
+          const output = await runProvider(provider, model, input);
           const providerHealth = recordProviderSuccess(provider);
           await emit({
             at: Date.now(),
+            attempt: index + 1,
             elapsedMs: Date.now() - startedAt,
             fallbackProvider: provider === selectedProvider ? undefined : provider,
+            latencyBudgetMs: getProviderTimeoutMs(provider),
             provider,
             providerHealth,
             recovered: provider !== selectedProvider,
@@ -3820,22 +4280,26 @@ var createVoiceProviderRouter = (options) => {
           lastError = error;
           const hasNextProvider = index < order.length - 1;
           const isProviderError = options.isProviderError?.(error, provider) ?? true;
+          const timedOut = options.isTimeoutError?.(error, provider) ?? error instanceof VoiceProviderTimeoutError;
           const rateLimited = options.isRateLimitError?.(error, provider) ?? defaultIsRateLimitError(error);
           const shouldFallback = fallbackMode === "provider-error" ? isProviderError : fallbackMode === "rate-limit" ? isProviderError && rateLimited : false;
           const providerHealth = recordProviderError(provider, isProviderError, rateLimited);
           const nextProvider = hasNextProvider ? order[index + 1] : undefined;
           await emit({
             at: Date.now(),
+            attempt: index + 1,
             elapsedMs: Date.now() - startedAt,
             error: errorMessage(error),
             fallbackProvider: shouldFallback ? nextProvider : undefined,
+            latencyBudgetMs: getProviderTimeoutMs(provider),
             provider,
             providerHealth,
             rateLimited,
             selectedProvider,
             suppressionRemainingMs: getSuppressionRemainingMs(provider),
             suppressedUntil: providerHealth?.suppressedUntil,
-            status: "error"
+            status: "error",
+            timedOut
           }, input);
           if (!hasNextProvider || !shouldFallback) {
             throw error;
@@ -4457,7 +4921,7 @@ var createVoiceMemoryStore = () => {
 };
 
 // src/session.ts
-import { Buffer } from "buffer";
+import { Buffer as Buffer2 } from "buffer";
 
 // src/handoff.ts
 var toHex = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
@@ -4776,6 +5240,12 @@ var DEFAULT_FORMAT = {
   encoding: "pcm_s16le",
   sampleRateHz: 16000
 };
+var DEFAULT_REALTIME_FORMAT = {
+  channels: 1,
+  container: "raw",
+  encoding: "pcm_s16le",
+  sampleRateHz: 24000
+};
 var toError = (value) => value instanceof Error ? value : new Error(String(value));
 var createEmptyCurrentTurn = () => ({
   finalText: "",
@@ -4788,7 +5258,7 @@ var createEmptyCurrentTurn = () => ({
   transcripts: []
 });
 var cloneTranscript = (transcript) => ({ ...transcript });
-var encodeBase64 = (chunk) => Buffer.from(chunk).toString("base64");
+var encodeBase64 = (chunk) => Buffer2.from(chunk).toString("base64");
 var countWords2 = (text) => text.trim().split(/\s+/).filter(Boolean).length;
 var normalizeText2 = (text) => text.trim().replace(/\s+/g, " ");
 var getAudioChunkDurationMs = (chunk) => chunk.byteLength / (DEFAULT_FORMAT.sampleRateHz * DEFAULT_FORMAT.channels * 2) * 1000;
@@ -4959,7 +5429,7 @@ var createVoiceSession = (options) => {
   } : undefined;
   const appendTrace = async (input) => {
     await options.trace?.append({
-      at: Date.now(),
+      at: input.at ?? Date.now(),
       metadata: input.metadata,
       payload: input.payload,
       scenarioId: input.session?.scenarioId ?? options.scenarioId,
@@ -4968,6 +5438,13 @@ var createVoiceSession = (options) => {
       type: input.type
     });
   };
+  const appendTurnLatencyStage = async (input) => appendTrace({
+    at: input.at,
+    payload: { stage: input.stage },
+    session: input.session,
+    turnId: input.turnId,
+    type: "turn_latency.stage"
+  });
   const phraseHints = options.phraseHints ?? [];
   const lexicon = options.lexicon ?? [];
   let socket = options.socket;
@@ -5046,6 +5523,18 @@ var createVoiceSession = (options) => {
       type: "call_lifecycle"
     });
   };
+  const sendReplay = async (session) => {
+    await send({
+      assistantTexts: session.turns.flatMap((turn) => turn.assistantText ? [turn.assistantText] : []),
+      call: session.call,
+      partial: session.currentTurn.partialText,
+      scenarioId: session.scenarioId,
+      sessionId: options.id,
+      status: session.status,
+      turns: session.turns,
+      type: "replay"
+    });
+  };
   const runHandoff = async (input) => {
     const queuedDelivery = options.handoff?.deliveryQueue ? createVoiceHandoffDeliveryRecord({
       action: input.action,
@@ -5149,6 +5638,23 @@ var createVoiceSession = (options) => {
       });
     }
   };
+  const sendAssistantAudio = async (chunk, input) => {
+    const normalizedChunk = chunk instanceof Uint8Array ? new Uint8Array(chunk) : chunk instanceof ArrayBuffer ? new Uint8Array(chunk.slice(0)) : new Uint8Array(chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength));
+    await send({
+      chunkBase64: encodeBase64(normalizedChunk),
+      format: input.format,
+      receivedAt: input.receivedAt,
+      turnId: activeTTSTurnId,
+      type: "audio"
+    });
+    if (activeTTSTurnId) {
+      await appendTurnLatencyStage({
+        at: input.receivedAt,
+        stage: "assistant_audio_received",
+        turnId: activeTTSTurnId
+      });
+    }
+  };
   const scheduleTurnCommit = (delayMs, reason, reset = true) => {
     if (!reset && silenceTimer) {
       return;
@@ -5850,8 +6356,12 @@ var createVoiceSession = (options) => {
     if (sttSession) {
       return sttSession;
     }
-    const openedSession = await options.stt.open({
-      format: DEFAULT_FORMAT,
+    const inputAdapter = options.realtime ?? options.stt;
+    if (!inputAdapter) {
+      throw new Error("Voice session requires either an stt or realtime adapter.");
+    }
+    const openedSession = await inputAdapter.open({
+      format: options.realtime ? options.realtimeInputFormat ?? DEFAULT_REALTIME_FORMAT : DEFAULT_FORMAT,
       languageStrategy: options.languageStrategy,
       lexicon,
       phraseHints,
@@ -5886,6 +6396,16 @@ var createVoiceSession = (options) => {
     openedSession.on("close", (event) => {
       runAdapterEvent("adapter.close", () => handleClose(event));
     });
+    if (options.realtime) {
+      openedSession.on("audio", ({ chunk, format, receivedAt }) => {
+        runAdapterEvent("adapter.audio", async () => {
+          await sendAssistantAudio(chunk, {
+            format,
+            receivedAt
+          });
+        });
+      });
+    }
     return openedSession;
   };
   const ensureTTSSession = async () => {
@@ -5910,13 +6430,9 @@ var createVoiceSession = (options) => {
           if (ttsSession !== openedSession) {
             return;
           }
-          const normalizedChunk = chunk instanceof Uint8Array ? new Uint8Array(chunk) : chunk instanceof ArrayBuffer ? new Uint8Array(chunk.slice(0)) : new Uint8Array(chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength));
-          await send({
-            chunkBase64: encodeBase64(normalizedChunk),
+          await sendAssistantAudio(chunk, {
             format,
-            receivedAt,
-            turnId: activeTTSTurnId,
-            type: "audio"
+            receivedAt
           });
         });
       });
@@ -5960,9 +6476,32 @@ var createVoiceSession = (options) => {
     });
   };
   const completeTurn = async (session, turn) => {
+    const liveOpsControl = await options.liveOps?.getControl(options.id);
+    if (liveOpsControl?.assistantPaused || liveOpsControl?.operatorTakeover) {
+      await appendTrace({
+        metadata: {
+          source: "voice-live-ops"
+        },
+        payload: {
+          action: "turn.skipped",
+          control: liveOpsControl,
+          reason: liveOpsControl.operatorTakeover ? "operator-takeover" : "assistant-paused",
+          status: "skipped"
+        },
+        session,
+        turnId: turn.id,
+        type: "operator.action"
+      });
+      return;
+    }
+    const injectedInstruction = liveOpsControl?.injectedInstruction?.trim();
     const committedOutput = await options.route.onTurn({
       api,
       context: options.context,
+      liveOps: liveOpsControl ? {
+        control: liveOpsControl,
+        injectedInstruction
+      } : undefined,
       session,
       turn
     });
@@ -5976,6 +6515,7 @@ var createVoiceSession = (options) => {
       voicemail: committedOutput?.voicemail
     };
     if (output?.assistantText) {
+      const assistantTextStartedAt = Date.now();
       await writeSession((currentSession) => {
         setTurnResult(currentSession, turn.id, {
           assistantText: output.assistantText
@@ -5986,10 +6526,17 @@ var createVoiceSession = (options) => {
         turnId: turn.id,
         type: "assistant"
       });
+      await appendTurnLatencyStage({
+        at: assistantTextStartedAt,
+        session,
+        stage: "assistant_text_started",
+        turnId: turn.id
+      });
       await appendTrace({
         payload: {
           text: output.assistantText,
-          ttsConfigured: Boolean(options.tts)
+          ttsConfigured: Boolean(options.tts),
+          realtimeConfigured: Boolean(options.realtime)
         },
         session,
         turnId: turn.id,
@@ -6000,7 +6547,18 @@ var createVoiceSession = (options) => {
         if (activeTTSSession) {
           const ttsStartedAt = Date.now();
           activeTTSTurnId = turn.id;
+          await appendTurnLatencyStage({
+            at: ttsStartedAt,
+            session,
+            stage: "tts_send_started",
+            turnId: turn.id
+          });
           await activeTTSSession.send(output.assistantText);
+          await appendTurnLatencyStage({
+            session,
+            stage: "tts_send_completed",
+            turnId: turn.id
+          });
           await appendTrace({
             payload: {
               elapsedMs: Date.now() - ttsStartedAt,
@@ -6010,9 +6568,35 @@ var createVoiceSession = (options) => {
             turnId: turn.id,
             type: "turn.assistant"
           });
+        } else if (options.realtime) {
+          const activeRealtimeSession = await ensureAdapter();
+          const realtimeStartedAt = Date.now();
+          activeTTSTurnId = turn.id;
+          await appendTurnLatencyStage({
+            at: realtimeStartedAt,
+            session,
+            stage: "tts_send_started",
+            turnId: turn.id
+          });
+          await activeRealtimeSession.send(output.assistantText);
+          await appendTurnLatencyStage({
+            session,
+            stage: "tts_send_completed",
+            turnId: turn.id
+          });
+          await appendTrace({
+            payload: {
+              elapsedMs: Date.now() - realtimeStartedAt,
+              mode: "realtime",
+              status: "sent"
+            },
+            session,
+            turnId: turn.id,
+            type: "turn.assistant"
+          });
         }
       } catch (error) {
-        logger.warn("voice tts send failed", {
+        logger.warn("voice assistant audio send failed", {
           error: toError(error).message,
           sessionId: options.id,
           turnId: turn.id
@@ -6020,7 +6604,7 @@ var createVoiceSession = (options) => {
         await appendTrace({
           payload: {
             error: toError(error).message,
-            status: "tts-send-failed"
+            status: options.realtime ? "realtime-send-failed" : "tts-send-failed"
           },
           session,
           turnId: turn.id,
@@ -6197,11 +6781,35 @@ var createVoiceSession = (options) => {
       turnId: turn.id,
       type: "turn.cost"
     });
+    const firstTranscriptAt = turn.transcripts.map((transcript) => transcript.endedAtMs ?? transcript.startedAtMs).filter((value) => typeof value === "number").sort((left, right) => left - right)[0];
+    const finalTranscriptAt = turn.transcripts.filter((transcript) => transcript.isFinal).map((transcript) => transcript.endedAtMs ?? transcript.startedAtMs).filter((value) => typeof value === "number").sort((left, right) => left - right)[0];
+    if (firstTranscriptAt !== undefined) {
+      await appendTurnLatencyStage({
+        at: firstTranscriptAt,
+        session: updatedSession,
+        stage: "speech_detected",
+        turnId: turn.id
+      });
+    }
+    if (finalTranscriptAt !== undefined) {
+      await appendTurnLatencyStage({
+        at: finalTranscriptAt,
+        session: updatedSession,
+        stage: "final_transcript",
+        turnId: turn.id
+      });
+    }
+    await appendTurnLatencyStage({
+      at: turn.committedAt,
+      session: updatedSession,
+      stage: "turn_committed",
+      turnId: turn.id
+    });
     await send({
       turn,
       type: "turn"
     });
-    if (options.sttLifecycle === "turn-scoped") {
+    if (options.stt && options.sttLifecycle === "turn-scoped") {
       await closeAdapter("turn-commit");
     }
     await completeTurn(updatedSession, turn);
@@ -6264,6 +6872,7 @@ var createVoiceSession = (options) => {
       scenarioId: session.scenarioId,
       type: "session"
     });
+    await sendReplay(session);
     if (shouldFireOnSession) {
       await options.route.onCallStart?.({
         api,
@@ -7640,10 +8249,981 @@ var runVoiceSessionBenchmarkSeries = async (input) => {
   });
 };
 // src/telephony/twilio.ts
-import { Buffer as Buffer2 } from "buffer";
+import { Buffer as Buffer3 } from "buffer";
+import { Elysia as Elysia2 } from "elysia";
+
+// src/telephonyOutcome.ts
+import { Elysia } from "elysia";
+var DEFAULT_COMPLETED_STATUSES = [
+  "answered",
+  "completed",
+  "complete",
+  "connected",
+  "in-progress",
+  "live"
+];
+var DEFAULT_NO_ANSWER_STATUSES = [
+  "busy",
+  "canceled",
+  "cancelled",
+  "failed",
+  "no-answer",
+  "no_answer",
+  "not-answered",
+  "ring-no-answer",
+  "timeout",
+  "unanswered"
+];
+var DEFAULT_VOICEMAIL_STATUSES = [
+  "answering-machine",
+  "machine",
+  "voicemail",
+  "voice-mail"
+];
+var DEFAULT_TRANSFER_STATUSES = ["bridged", "forwarded", "transferred"];
+var DEFAULT_ESCALATION_STATUSES = ["escalated", "human-required", "operator"];
+var DEFAULT_FAILED_STATUSES = ["busy", "failed", "no-answer"];
+var DEFAULT_MACHINE_VOICEMAIL_VALUES = [
+  "answering-machine",
+  "fax",
+  "machine",
+  "machine-end-beep",
+  "machine-end-other",
+  "machine-start",
+  "voicemail"
+];
+var DEFAULT_NO_ANSWER_SIP_CODES = [408, 480, 486, 487, 603];
+var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var uniqueSorted = (values) => Array.from(new Set(values)).sort();
+var findMissing = (values, required) => {
+  if (!required?.length) {
+    return [];
+  }
+  const valueSet = new Set(values);
+  return required.filter((value) => !valueSet.has(value));
+};
+
+class VoiceTelephonyWebhookVerificationError extends Error {
+  result;
+  constructor(result) {
+    super(result.ok ? "telephony webhook verified" : result.reason);
+    this.name = "VoiceTelephonyWebhookVerificationError";
+    this.result = result;
+  }
+}
+var createMemoryVoiceTelephonyWebhookIdempotencyStore = () => {
+  const decisions = new Map;
+  return {
+    get: (key) => decisions.get(key),
+    set: (key, decision) => {
+      decisions.set(key, decision);
+    }
+  };
+};
+var isTelephonyWebhookProvider = (value) => value === "generic" || value === "plivo" || value === "telnyx" || value === "twilio";
+var isTelephonyOutcomeAction = (value) => value === "complete" || value === "escalate" || value === "ignore" || value === "no-answer" || value === "transfer" || value === "voicemail";
+var isCallDisposition = (value) => value === "completed" || value === "escalated" || value === "failed" || value === "no-answer" || value === "transferred" || value === "voicemail";
+var evaluateVoiceTelephonyWebhookNormalizationEvidence = (input = {}) => {
+  const issues = [];
+  const decisions = input.decisions ?? [];
+  const verificationAttempts = input.verificationAttempts ?? [];
+  const actions = uniqueSorted(decisions.map((decision) => decision.decision?.action ?? decision.action).filter(isTelephonyOutcomeAction));
+  const dispositions = uniqueSorted(decisions.map((decision) => decision.decision?.disposition ?? decision.disposition).filter(isCallDisposition));
+  const providers = uniqueSorted(decisions.map((decision) => decision.provider ?? decision.event?.provider).filter(isTelephonyWebhookProvider));
+  const sources = uniqueSorted(decisions.map((decision) => decision.decision?.source ?? decision.source).filter((source) => typeof source === "string"));
+  const applied = decisions.filter((decision) => decision.applied === true).length;
+  const duplicateDecisions = decisions.filter((decision) => decision.duplicate === true);
+  const duplicateProviders = uniqueSorted(duplicateDecisions.map((decision) => decision.provider ?? decision.event?.provider).filter(isTelephonyWebhookProvider));
+  const duplicateIdempotencyKeys = new Set(duplicateDecisions.map((decision) => decision.idempotencyKey).filter((key) => typeof key === "string" && key.length > 0)).size;
+  const duplicateCampaignOutcomesApplied = duplicateDecisions.filter((decision) => isRecord(decision.campaignOutcome) && decision.campaignOutcome.applied === true).length;
+  const duplicateOutcomeReasons = uniqueSorted(duplicateDecisions.map((decision) => isRecord(decision.campaignOutcome) ? decision.campaignOutcome.reason : undefined).filter((reason) => typeof reason === "string"));
+  const routeResults = decisions.filter((decision) => isRecord(decision.routeResult)).length;
+  const missingSessionIds = decisions.filter((decision) => !decision.sessionId).length;
+  const rejectedVerificationAttempts = verificationAttempts.filter((attempt) => attempt.rejected === true || attempt.status === 401 || attempt.verification?.ok === false && attempt.verification.reason === "invalid-signature");
+  const rejectedVerificationProviders = uniqueSorted(rejectedVerificationAttempts.map((attempt) => attempt.provider).filter(isTelephonyWebhookProvider));
+  const replayRejectedVerificationAttempts = rejectedVerificationAttempts.filter((attempt) => attempt.replayRejected === true);
+  const replayRejectedVerificationProviders = uniqueSorted(replayRejectedVerificationAttempts.map((attempt) => attempt.provider).filter(isTelephonyWebhookProvider));
+  const rejectedVerificationSideEffects = rejectedVerificationAttempts.reduce((total, attempt) => total + Math.max(0, attempt.sideEffects ?? 0), 0);
+  if (input.minDecisions !== undefined && decisions.length < input.minDecisions) {
+    issues.push(`Expected at least ${String(input.minDecisions)} telephony webhook decision(s), found ${String(decisions.length)}.`);
+  }
+  if (input.minApplied !== undefined && applied < input.minApplied) {
+    issues.push(`Expected at least ${String(input.minApplied)} applied telephony webhook decision(s), found ${String(applied)}.`);
+  }
+  if (input.minDuplicates !== undefined && duplicateDecisions.length < input.minDuplicates) {
+    issues.push(`Expected at least ${String(input.minDuplicates)} duplicate telephony webhook decision(s), found ${String(duplicateDecisions.length)}.`);
+  }
+  if (input.minDuplicateIdempotencyKeys !== undefined && duplicateIdempotencyKeys < input.minDuplicateIdempotencyKeys) {
+    issues.push(`Expected at least ${String(input.minDuplicateIdempotencyKeys)} duplicate telephony webhook idempotency key(s), found ${String(duplicateIdempotencyKeys)}.`);
+  }
+  if (input.maxDuplicateCampaignOutcomesApplied !== undefined && duplicateCampaignOutcomesApplied > input.maxDuplicateCampaignOutcomesApplied) {
+    issues.push(`Expected at most ${String(input.maxDuplicateCampaignOutcomesApplied)} duplicate telephony webhook campaign outcome application(s), found ${String(duplicateCampaignOutcomesApplied)}.`);
+  }
+  if (input.minRejectedVerificationAttempts !== undefined && rejectedVerificationAttempts.length < input.minRejectedVerificationAttempts) {
+    issues.push(`Expected at least ${String(input.minRejectedVerificationAttempts)} rejected telephony webhook verification attempt(s), found ${String(rejectedVerificationAttempts.length)}.`);
+  }
+  if (input.maxRejectedVerificationSideEffects !== undefined && rejectedVerificationSideEffects > input.maxRejectedVerificationSideEffects) {
+    issues.push(`Expected at most ${String(input.maxRejectedVerificationSideEffects)} rejected telephony webhook side effect(s), found ${String(rejectedVerificationSideEffects)}.`);
+  }
+  if (input.minReplayRejectedVerificationAttempts !== undefined && replayRejectedVerificationAttempts.length < input.minReplayRejectedVerificationAttempts) {
+    issues.push(`Expected at least ${String(input.minReplayRejectedVerificationAttempts)} replay-rejected telephony webhook verification attempt(s), found ${String(replayRejectedVerificationAttempts.length)}.`);
+  }
+  if (input.maxMissingSessionIds !== undefined && missingSessionIds > input.maxMissingSessionIds) {
+    issues.push(`Expected at most ${String(input.maxMissingSessionIds)} telephony webhook decision(s) without sessionId, found ${String(missingSessionIds)}.`);
+  }
+  if (input.requireRouteResults && routeResults < decisions.length) {
+    issues.push(`Expected every telephony webhook decision to include a route result, found ${String(routeResults)} of ${String(decisions.length)}.`);
+  }
+  for (const provider of findMissing(providers, input.requiredProviders)) {
+    issues.push(`Missing telephony webhook provider: ${provider}.`);
+  }
+  for (const provider of findMissing(duplicateProviders, input.requiredDuplicateProviders)) {
+    issues.push(`Missing duplicate telephony webhook provider: ${provider}.`);
+  }
+  for (const provider of findMissing(rejectedVerificationProviders, input.requiredRejectedVerificationProviders)) {
+    issues.push(`Missing rejected telephony webhook verification provider: ${provider}.`);
+  }
+  for (const provider of findMissing(replayRejectedVerificationProviders, input.requiredReplayRejectedVerificationProviders)) {
+    issues.push(`Missing replay-rejected telephony webhook verification provider: ${provider}.`);
+  }
+  for (const action of findMissing(actions, input.requiredActions)) {
+    issues.push(`Missing telephony webhook action: ${action}.`);
+  }
+  for (const disposition of findMissing(dispositions, input.requiredDispositions)) {
+    issues.push(`Missing telephony webhook disposition: ${disposition}.`);
+  }
+  return {
+    actions,
+    applied,
+    decisions: decisions.length,
+    dispositions,
+    duplicateCampaignOutcomesApplied,
+    duplicateIdempotencyKeys,
+    duplicateOutcomeReasons,
+    duplicateProviders,
+    duplicates: duplicateDecisions.length,
+    issues,
+    missingSessionIds,
+    ok: issues.length === 0,
+    providers,
+    rejectedVerificationAttempts: rejectedVerificationAttempts.length,
+    rejectedVerificationProviders,
+    rejectedVerificationSideEffects,
+    replayRejectedVerificationAttempts: replayRejectedVerificationAttempts.length,
+    replayRejectedVerificationProviders,
+    routeResults,
+    sources,
+    verificationAttempts: verificationAttempts.length
+  };
+};
+var assertVoiceTelephonyWebhookNormalizationEvidence = (input = {}) => {
+  const assertion = evaluateVoiceTelephonyWebhookNormalizationEvidence(input);
+  if (!assertion.ok) {
+    throw new Error(`Voice telephony webhook normalization evidence assertion failed: ${assertion.issues.join(" ")}`);
+  }
+  return assertion;
+};
+var normalizeToken = (value) => typeof value === "string" ? value.trim().toLowerCase().replace(/\s+/g, "-").replace(/_+/g, "-") : undefined;
+var firstString = (source, keys) => {
+  for (const key of keys) {
+    const value = source[key];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return String(value);
+    }
+  }
+};
+var firstNumber = (source, keys) => {
+  for (const key of keys) {
+    const value = source[key];
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+    if (typeof value === "string" && value.trim()) {
+      const parsed = Number(value);
+      if (Number.isFinite(parsed)) {
+        return parsed;
+      }
+    }
+  }
+};
+var parseMaybeJSON = (value) => {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return;
+  }
+};
+var flattenPayload = (value) => {
+  if (!isRecord(value)) {
+    return {};
+  }
+  const data = isRecord(value.data) ? value.data : undefined;
+  const payload = isRecord(value.payload) ? value.payload : undefined;
+  const event = isRecord(value.event) ? value.event : undefined;
+  return {
+    ...value,
+    ...payload,
+    ...event,
+    ...data,
+    ...isRecord(data?.payload) ? data.payload : undefined
+  };
+};
+var toBase64 = (bytes) => Buffer.from(new Uint8Array(bytes)).toString("base64");
+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 signHmacSHA1Base64 = async (secret, payload) => {
+  const encoder = new TextEncoder;
+  const key = await crypto.subtle.importKey("raw", encoder.encode(secret), {
+    hash: "SHA-1",
+    name: "HMAC"
+  }, false, ["sign"]);
+  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(payload));
+  return toBase64(signature);
+};
+var sortedParamsForSignature = (body) => Object.entries(flattenPayload(body)).filter(([, value]) => value !== undefined && value !== null).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key}${String(value)}`).join("");
+var normalizeList = (values, fallback) => new Set((values ?? fallback).map(normalizeToken).filter(Boolean));
+var metadataValue = (metadata, keys) => {
+  for (const key of keys) {
+    const value = metadata?.[key];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+};
+var resolveTransferTarget = (event, policy) => {
+  if (typeof event.target === "string" && event.target.trim()) {
+    return event.target.trim();
+  }
+  const metadataTarget = metadataValue(event.metadata, [
+    "transferTarget",
+    "target",
+    "queue",
+    "department"
+  ]);
+  if (metadataTarget) {
+    return metadataTarget;
+  }
+  if (typeof policy.transferTarget === "function") {
+    const target = policy.transferTarget(event);
+    return typeof target === "string" && target.trim() ? target.trim() : undefined;
+  }
+  return typeof policy.transferTarget === "string" && policy.transferTarget.trim() ? policy.transferTarget.trim() : undefined;
+};
+var mergeMetadata = (event, policy) => ({
+  ...policy.includeProviderPayload ? {
+    answeredBy: event.answeredBy,
+    durationMs: event.durationMs,
+    provider: event.provider,
+    reason: event.reason,
+    sipCode: event.sipCode,
+    status: event.status
+  } : undefined,
+  ...policy.metadata,
+  ...event.metadata
+});
+var withDecisionDefaults = (decision, input) => {
+  if (typeof decision === "string") {
+    return buildDecision(decision, input);
+  }
+  return {
+    ...buildDecision(decision.action, input),
+    ...decision,
+    confidence: decision.confidence ?? "high",
+    metadata: {
+      ...mergeMetadata(input.event, input.policy),
+      ...decision.metadata
+    },
+    source: decision.source ?? input.source,
+    target: decision.target ?? (decision.action === "transfer" ? resolveTransferTarget(input.event, input.policy) : undefined)
+  };
+};
+var dispositionForAction = (action) => {
+  switch (action) {
+    case "complete":
+      return "completed";
+    case "escalate":
+      return "escalated";
+    case "no-answer":
+      return "no-answer";
+    case "transfer":
+      return "transferred";
+    case "voicemail":
+      return "voicemail";
+    default:
+      return;
+  }
+};
+var buildDecision = (action, input) => ({
+  action,
+  confidence: action === "ignore" ? "low" : "high",
+  disposition: dispositionForAction(action),
+  metadata: mergeMetadata(input.event, input.policy),
+  reason: input.event.reason,
+  source: input.source,
+  target: action === "transfer" ? resolveTransferTarget(input.event, input.policy) : undefined
+});
+var createVoiceTelephonyOutcomePolicy = (policy = {}) => ({
+  completedStatuses: policy.completedStatuses ?? DEFAULT_COMPLETED_STATUSES,
+  escalationStatuses: policy.escalationStatuses ?? DEFAULT_ESCALATION_STATUSES,
+  failedAsNoAnswer: policy.failedAsNoAnswer ?? true,
+  failedStatuses: policy.failedStatuses ?? DEFAULT_FAILED_STATUSES,
+  includeProviderPayload: policy.includeProviderPayload ?? true,
+  machineDetectionVoicemailValues: policy.machineDetectionVoicemailValues ?? DEFAULT_MACHINE_VOICEMAIL_VALUES,
+  metadata: policy.metadata,
+  minAnsweredDurationMs: policy.minAnsweredDurationMs,
+  noAnswerOnZeroDuration: policy.noAnswerOnZeroDuration ?? true,
+  noAnswerSipCodes: policy.noAnswerSipCodes ?? DEFAULT_NO_ANSWER_SIP_CODES,
+  noAnswerStatuses: policy.noAnswerStatuses ?? DEFAULT_NO_ANSWER_STATUSES,
+  statusMap: policy.statusMap,
+  transferStatuses: policy.transferStatuses ?? DEFAULT_TRANSFER_STATUSES,
+  transferTarget: policy.transferTarget,
+  voicemailStatuses: policy.voicemailStatuses ?? DEFAULT_VOICEMAIL_STATUSES
+});
+var resolveVoiceTelephonyOutcome = (event, policyInput = {}) => {
+  const policy = createVoiceTelephonyOutcomePolicy(policyInput);
+  const status = normalizeToken(event.status);
+  const provider = normalizeToken(event.provider);
+  const answeredBy = normalizeToken(event.answeredBy);
+  const target = resolveTransferTarget(event, policy);
+  if (status) {
+    const mapped = policy.statusMap?.[status] ?? (provider ? policy.statusMap?.[`${provider}:${status}`] : undefined);
+    if (mapped) {
+      return withDecisionDefaults(mapped, {
+        event,
+        policy,
+        source: "policy"
+      });
+    }
+  }
+  if (answeredBy && normalizeList(policy.machineDetectionVoicemailValues, []).has(answeredBy)) {
+    return buildDecision("voicemail", { event, policy, source: "answered-by" });
+  }
+  if (typeof event.sipCode === "number" && policy.noAnswerSipCodes.includes(event.sipCode)) {
+    return buildDecision("no-answer", { event, policy, source: "sip" });
+  }
+  if (target && status && normalizeList(policy.transferStatuses, []).has(status)) {
+    return buildDecision("transfer", { event, policy, source: "status" });
+  }
+  if (status && normalizeList(policy.voicemailStatuses, []).has(status)) {
+    return buildDecision("voicemail", { event, policy, source: "status" });
+  }
+  if (status && normalizeList(policy.escalationStatuses, []).has(status)) {
+    return buildDecision("escalate", { event, policy, source: "status" });
+  }
+  if (status && (policy.failedAsNoAnswer ? normalizeList(policy.noAnswerStatuses, []).has(status) || normalizeList(policy.failedStatuses, []).has(status) : normalizeList(policy.noAnswerStatuses, []).has(status))) {
+    return buildDecision("no-answer", { event, policy, source: "status" });
+  }
+  if (policy.noAnswerOnZeroDuration && typeof event.durationMs === "number" && event.durationMs <= 0) {
+    return buildDecision("no-answer", { event, policy, source: "duration" });
+  }
+  if (typeof policy.minAnsweredDurationMs === "number" && typeof event.durationMs === "number" && event.durationMs < policy.minAnsweredDurationMs) {
+    return {
+      ...buildDecision("no-answer", { event, policy, source: "duration" }),
+      confidence: "medium"
+    };
+  }
+  if (status && normalizeList(policy.completedStatuses, []).has(status)) {
+    return buildDecision("complete", { event, policy, source: "status" });
+  }
+  if (target) {
+    return {
+      ...buildDecision("transfer", { event, policy, source: "explicit-target" }),
+      confidence: "medium"
+    };
+  }
+  return buildDecision("ignore", { event, policy, source: "status" });
+};
+var voiceTelephonyOutcomeToRouteResult = (decision, result) => {
+  switch (decision.action) {
+    case "complete":
+      return { complete: true, result };
+    case "escalate":
+      return {
+        escalate: {
+          metadata: decision.metadata,
+          reason: decision.reason ?? "telephony-escalation"
+        },
+        result
+      };
+    case "no-answer":
+      return {
+        noAnswer: {
+          metadata: decision.metadata
+        },
+        result
+      };
+    case "transfer":
+      if (!decision.target) {
+        return { result };
+      }
+      return {
+        result,
+        transfer: {
+          metadata: decision.metadata,
+          reason: decision.reason,
+          target: decision.target
+        }
+      };
+    case "voicemail":
+      return {
+        result,
+        voicemail: {
+          metadata: decision.metadata
+        }
+      };
+    default:
+      return { result };
+  }
+};
+var applyVoiceTelephonyOutcome = async (api, decision, result) => {
+  switch (decision.action) {
+    case "complete":
+      await api.complete(result);
+      break;
+    case "escalate":
+      await api.escalate({
+        metadata: decision.metadata,
+        reason: decision.reason ?? "telephony-escalation",
+        result
+      });
+      break;
+    case "no-answer":
+      await api.markNoAnswer({
+        metadata: decision.metadata,
+        result
+      });
+      break;
+    case "transfer":
+      if (!decision.target) {
+        return;
+      }
+      await api.transfer({
+        metadata: decision.metadata,
+        reason: decision.reason,
+        result,
+        target: decision.target
+      });
+      break;
+    case "voicemail":
+      await api.markVoicemail({
+        metadata: decision.metadata,
+        result
+      });
+      break;
+    default:
+      break;
+  }
+};
+var parseRequestBodyText = (input) => {
+  const { contentType, text } = input;
+  if (!text) {
+    return {};
+  }
+  if (contentType.includes("application/json")) {
+    return parseMaybeJSON(text) ?? {};
+  }
+  if (contentType.includes("application/x-www-form-urlencoded") || contentType.includes("multipart/form-data")) {
+    return Object.fromEntries(new URLSearchParams(text));
+  }
+  return parseMaybeJSON(text) ?? Object.fromEntries(new URLSearchParams(text));
+};
+var readRequestBody = async (request) => {
+  const contentType = request.headers.get("content-type") ?? "";
+  const text = await request.text();
+  return {
+    body: parseRequestBodyText({ contentType, text }),
+    rawBody: text
+  };
+};
+var signVoiceTwilioWebhook = async (input) => signHmacSHA1Base64(input.authToken, `${input.url}${sortedParamsForSignature(input.body ?? {})}`);
+var verifyVoiceTwilioWebhookSignature = async (input) => {
+  if (!input.authToken) {
+    return { ok: false, reason: "missing-secret" };
+  }
+  const signature = input.headers.get("x-twilio-signature");
+  if (!signature) {
+    return { ok: false, reason: "missing-signature" };
+  }
+  const expected = await signVoiceTwilioWebhook({
+    authToken: input.authToken,
+    body: input.body,
+    url: input.url
+  });
+  return timingSafeEqual(signature, expected) ? { ok: true } : { ok: false, reason: "invalid-signature" };
+};
+var resolveVerificationUrl = (option, input) => typeof option === "function" ? option(input) : option ?? input.request.url;
+var verifyVoiceTelephonyWebhook = async (input) => {
+  if (input.options.verify) {
+    return input.options.verify({
+      body: input.body,
+      headers: input.request.headers,
+      provider: input.provider,
+      query: input.query,
+      rawBody: input.rawBody,
+      request: input.request
+    });
+  }
+  if (!input.options.signingSecret) {
+    return input.options.requireVerification ? { ok: false, reason: "missing-secret" } : { ok: true };
+  }
+  if (input.provider !== "twilio") {
+    return { ok: false, reason: "unsupported-provider" };
+  }
+  return verifyVoiceTwilioWebhookSignature({
+    authToken: input.options.signingSecret,
+    body: input.body,
+    headers: input.request.headers,
+    url: resolveVerificationUrl(input.options.verificationUrl, {
+      query: input.query,
+      request: input.request
+    })
+  });
+};
+var durationMsFromSeconds = (value) => typeof value === "number" ? value * 1000 : undefined;
+var parseVoiceTelephonyWebhookEvent = (input) => {
+  const payload = flattenPayload(input.body);
+  const provider = firstString(payload, ["provider", "Provider"]) ?? input.provider;
+  const status = firstString(payload, [
+    "CallStatus",
+    "call_status",
+    "callStatus",
+    "DialCallStatus",
+    "dial_call_status",
+    "status",
+    "event_type",
+    "type"
+  ]);
+  const durationMs = firstNumber(payload, ["durationMs", "duration_ms"]) ?? durationMsFromSeconds(firstNumber(payload, [
+    "CallDuration",
+    "call_duration",
+    "callDuration",
+    "DialCallDuration",
+    "dial_call_duration",
+    "duration"
+  ]));
+  const sipCode = firstNumber(payload, [
+    "SipResponseCode",
+    "sip_response_code",
+    "sipCode",
+    "sip_code",
+    "hangupCauseCode"
+  ]);
+  const from = firstString(payload, ["From", "from", "caller_id", "callerId"]);
+  const to = firstString(payload, ["To", "to", "called_number", "calledNumber"]);
+  const target = firstString(payload, [
+    "transferTarget",
+    "TransferTarget",
+    "target",
+    "queue",
+    "department"
+  ]);
+  return {
+    answeredBy: firstString(payload, [
+      "AnsweredBy",
+      "answered_by",
+      "answeredBy",
+      "machineDetection",
+      "machine_detection"
+    ]),
+    durationMs,
+    from,
+    metadata: {
+      ...input.query,
+      ...payload
+    },
+    provider,
+    reason: firstString(payload, [
+      "Reason",
+      "reason",
+      "HangupCause",
+      "hangup_cause",
+      "hangupCause"
+    ]),
+    sipCode,
+    status,
+    target,
+    to
+  };
+};
+var defaultSessionId = (input) => {
+  const payload = flattenPayload(input.body);
+  const metadataSessionId = input.event.metadata?.sessionId;
+  return firstString(input.query, ["sessionId", "session_id"]) ?? firstString(payload, [
+    "sessionId",
+    "session_id",
+    "SessionId",
+    "CallSid",
+    "call_sid",
+    "callSid",
+    "CallUUID",
+    "call_uuid",
+    "callControlId",
+    "call_control_id"
+  ]) ?? (typeof metadataSessionId === "string" ? metadataSessionId : undefined);
+};
+var defaultIdempotencyKey = (input) => {
+  const payload = flattenPayload(input.body);
+  const eventId = firstString(payload, [
+    "id",
+    "event_id",
+    "eventId",
+    "EventSid",
+    "event_sid",
+    "MessageSid",
+    "message_sid",
+    "CallSid",
+    "call_sid",
+    "CallUUID",
+    "call_uuid",
+    "callControlId",
+    "call_control_id"
+  ]);
+  const status = normalizeToken(input.event.status) ?? "unknown";
+  if (eventId) {
+    return `${input.provider}:${eventId}:${status}`;
+  }
+  if (input.sessionId) {
+    return `${input.provider}:${input.sessionId}:${status}`;
+  }
+};
+var createVoiceTelephonyWebhookHandler = (options = {}) => async (input) => {
+  const provider = options.provider ?? "generic";
+  const query = input.query ?? {};
+  const { body, rawBody } = await readRequestBody(input.request);
+  const verification = await verifyVoiceTelephonyWebhook({
+    body,
+    options,
+    provider,
+    query,
+    rawBody,
+    request: input.request
+  });
+  if (!verification.ok) {
+    throw new VoiceTelephonyWebhookVerificationError(verification);
+  }
+  const event = options.parse ? await options.parse({
+    body,
+    headers: input.request.headers,
+    provider,
+    query,
+    request: input.request
+  }) : parseVoiceTelephonyWebhookEvent({
+    body,
+    headers: input.request.headers,
+    provider,
+    query,
+    request: input.request
+  });
+  const sessionId = await (options.resolveSessionId?.({
+    body,
+    event,
+    query,
+    request: input.request
+  }) ?? defaultSessionId({ body, event, query }));
+  const idempotencyEnabled = options.idempotency?.enabled !== false;
+  const idempotencyKey = idempotencyEnabled ? await (options.idempotency?.key?.({
+    body,
+    event,
+    provider,
+    query,
+    request: input.request,
+    sessionId
+  }) ?? defaultIdempotencyKey({ body, event, provider, sessionId })) : undefined;
+  const idempotencyStore = options.idempotency?.store;
+  if (idempotencyKey && idempotencyStore) {
+    const existing = await idempotencyStore.get(idempotencyKey);
+    if (existing) {
+      const duplicateDecision = {
+        ...existing,
+        duplicate: true
+      };
+      await options.onDecision?.({
+        ...duplicateDecision,
+        context: options.context,
+        request: input.request
+      });
+      return duplicateDecision;
+    }
+  }
+  const decision = resolveVoiceTelephonyOutcome(event, options.policy);
+  const resultResolver = options.result;
+  const result = typeof resultResolver === "function" ? await resultResolver({
+    decision,
+    event,
+    sessionId
+  }) : resultResolver;
+  const routeResult = voiceTelephonyOutcomeToRouteResult(decision, result);
+  const shouldApply = typeof options.apply === "function" ? options.apply({
+    applied: false,
+    decision,
+    event,
+    routeResult,
+    sessionId
+  }) : options.apply === true;
+  let applied = false;
+  if (shouldApply && decision.action !== "ignore" && options.getSessionHandle) {
+    const api = await options.getSessionHandle({
+      context: options.context,
+      decision,
+      event,
+      request: input.request,
+      sessionId
+    });
+    if (api) {
+      await applyVoiceTelephonyOutcome(api, decision, result);
+      applied = true;
+    }
+  }
+  const webhookDecision = {
+    applied,
+    decision,
+    event,
+    idempotencyKey,
+    routeResult,
+    sessionId
+  };
+  if (idempotencyKey && idempotencyStore) {
+    const now = Date.now();
+    await idempotencyStore.set(idempotencyKey, {
+      ...webhookDecision,
+      createdAt: now,
+      updatedAt: now
+    });
+  }
+  await options.onDecision?.({
+    ...webhookDecision,
+    context: options.context,
+    request: input.request
+  });
+  return webhookDecision;
+};
+var createVoiceTelephonyWebhookRoutes = (options = {}) => {
+  const path = options.path ?? "/api/voice/telephony/webhook";
+  const handler = createVoiceTelephonyWebhookHandler(options);
+  return new Elysia({
+    name: options.name ?? "absolutejs-voice-telephony-webhooks"
+  }).post(path, async ({ query, request }) => {
+    try {
+      return await handler({ query, request });
+    } catch (error) {
+      if (error instanceof VoiceTelephonyWebhookVerificationError) {
+        return new Response(JSON.stringify({ verification: error.result }), {
+          headers: {
+            "content-type": "application/json"
+          },
+          status: 401
+        });
+      }
+      throw error;
+    }
+  }, {
+    parse: "none"
+  });
+};
+
+// src/telephony/twilio.ts
 var TWILIO_MULAW_SAMPLE_RATE = 8000;
 var VOICE_PCM_SAMPLE_RATE = 16000;
 var escapeXml2 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+var resolveRequestOrigin = (request) => {
+  const url = new URL(request.url);
+  const forwardedHost = request.headers.get("x-forwarded-host");
+  const forwardedProto = request.headers.get("x-forwarded-proto");
+  const host = forwardedHost ?? request.headers.get("host") ?? url.host;
+  const protocol = forwardedProto ?? url.protocol.replace(":", "");
+  return `${protocol}://${host}`;
+};
+var resolveTwilioStreamUrl = async (options, input) => {
+  if (typeof options.twiml?.streamUrl === "function") {
+    return options.twiml.streamUrl(input);
+  }
+  if (typeof options.twiml?.streamUrl === "string") {
+    return options.twiml.streamUrl;
+  }
+  const origin = resolveRequestOrigin(input.request);
+  const wsOrigin = origin.replace(/^http:/, "ws:").replace(/^https:/, "wss:");
+  return `${wsOrigin}${input.streamPath}`;
+};
+var resolveTwilioStreamParameters = async (parameters, input) => {
+  if (typeof parameters === "function") {
+    return parameters(input);
+  }
+  return parameters;
+};
+var joinUrlPath = (origin, path) => `${origin.replace(/\/$/, "")}${path.startsWith("/") ? path : `/${path}`}`;
+var escapeHtml2 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&#39;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+var getWebhookVerificationUrl = (webhook, input) => {
+  if (!webhook?.verificationUrl) {
+    return;
+  }
+  if (typeof webhook.verificationUrl === "function") {
+    return webhook.verificationUrl(input);
+  }
+  return webhook.verificationUrl;
+};
+var buildTwilioVoiceSetupStatus = async (options, input) => {
+  const origin = resolveRequestOrigin(input.request);
+  const stream = await resolveTwilioStreamUrl(options, input);
+  const twiml = joinUrlPath(origin, input.twimlPath);
+  const webhook = joinUrlPath(origin, input.webhookPath);
+  const verificationUrl = getWebhookVerificationUrl(options.webhook, input);
+  const missing = Object.entries(options.setup?.requiredEnv ?? {}).filter((entry) => !entry[1]).map(([name]) => name);
+  const signingConfigured = Boolean(options.webhook?.signingSecret || options.webhook?.verify);
+  const warnings = [
+    ...stream.startsWith("wss://") ? [] : ["Twilio media streams should use wss:// in production."],
+    ...signingConfigured ? [] : ["Webhook signature verification is not configured."],
+    ...verificationUrl || !signingConfigured ? [] : ["Webhook signing is configured without an explicit verification URL."]
+  ];
+  return {
+    generatedAt: Date.now(),
+    missing,
+    provider: "twilio",
+    ready: missing.length === 0 && signingConfigured && warnings.length === 0,
+    signing: {
+      configured: signingConfigured,
+      mode: options.webhook?.verify ? "custom" : options.webhook?.signingSecret ? "twilio-signature" : "none",
+      verificationUrl
+    },
+    urls: {
+      stream,
+      twiml,
+      webhook
+    },
+    warnings
+  };
+};
+var renderTwilioVoiceSetupHTML = (status, title) => `<main style="font-family: ui-sans-serif, system-ui; max-width: 860px; margin: 40px auto; padding: 0 20px;">
+<p style="letter-spacing: .12em; text-transform: uppercase; color: #52606d;">Twilio setup</p>
+<h1>${escapeHtml2(title)}</h1>
+<p><strong>Status:</strong> ${status.ready ? "Ready" : "Needs attention"}</p>
+<section>
+<h2>URLs</h2>
+<ul>
+<li><strong>TwiML:</strong> <code>${escapeHtml2(status.urls.twiml)}</code></li>
+<li><strong>Media stream:</strong> <code>${escapeHtml2(status.urls.stream)}</code></li>
+<li><strong>Status webhook:</strong> <code>${escapeHtml2(status.urls.webhook)}</code></li>
+</ul>
+</section>
+<section>
+<h2>Signing</h2>
+<p>Mode: <code>${status.signing.mode}</code></p>
+${status.signing.verificationUrl ? `<p>Verification URL: <code>${escapeHtml2(status.signing.verificationUrl)}</code></p>` : ""}
+</section>
+${status.missing.length ? `<section><h2>Missing env</h2><ul>${status.missing.map((name) => `<li><code>${escapeHtml2(name)}</code></li>`).join("")}</ul></section>` : ""}
+${status.warnings.length ? `<section><h2>Warnings</h2><ul>${status.warnings.map((warning) => `<li>${escapeHtml2(warning)}</li>`).join("")}</ul></section>` : ""}
+</main>`;
+var extractTwilioStreamUrl = (twiml) => twiml.match(/<Stream\b[^>]*\surl="([^"]+)"/i)?.[1]?.replaceAll("&amp;", "&");
+var createSmokeCheck = (name, status, message, details) => ({
+  details,
+  message,
+  name,
+  status
+});
+var renderTwilioVoiceSmokeHTML = (report, title) => `<main style="font-family: ui-sans-serif, system-ui; max-width: 860px; margin: 40px auto; padding: 0 20px;">
+<p style="letter-spacing: .12em; text-transform: uppercase; color: #52606d;">Twilio smoke test</p>
+<h1>${escapeHtml2(title)}</h1>
+<p><strong>Status:</strong> ${report.pass ? "Pass" : "Fail"}</p>
+<section>
+<h2>Checks</h2>
+<ul>
+${report.checks.map((check) => `<li><strong>${escapeHtml2(check.name)}</strong>: ${escapeHtml2(check.status)}${check.message ? ` - ${escapeHtml2(check.message)}` : ""}</li>`).join("")}
+</ul>
+</section>
+<section>
+<h2>Observed URLs</h2>
+<ul>
+<li><strong>TwiML:</strong> <code>${escapeHtml2(report.setup.urls.twiml)}</code></li>
+<li><strong>Stream:</strong> <code>${escapeHtml2(report.twiml?.streamUrl ?? report.setup.urls.stream)}</code></li>
+<li><strong>Webhook:</strong> <code>${escapeHtml2(report.setup.urls.webhook)}</code></li>
+</ul>
+</section>
+</main>`;
+var runTwilioVoiceSmokeTest = async (input) => {
+  const setup = await buildTwilioVoiceSetupStatus(input.options, input);
+  const checks = [];
+  const twimlUrl = new URL(setup.urls.twiml);
+  twimlUrl.searchParams.set("scenarioId", input.options.smoke?.scenarioId ?? "smoke");
+  twimlUrl.searchParams.set("sessionId", input.options.smoke?.sessionId ?? "smoke-session");
+  const twimlResponse = await input.app.handle(new Request(twimlUrl, {
+    headers: input.request.headers
+  }));
+  const twiml = await twimlResponse.text();
+  const streamUrl = extractTwilioStreamUrl(twiml);
+  checks.push(createSmokeCheck("twiml", twimlResponse.ok && Boolean(streamUrl) ? "pass" : "fail", streamUrl ? "TwiML includes a media stream URL." : 'TwiML is missing <Stream url="...">.', {
+    status: twimlResponse.status,
+    streamUrl
+  }));
+  checks.push(createSmokeCheck("stream-url", streamUrl?.startsWith("wss://") ? "pass" : "fail", streamUrl?.startsWith("wss://") ? "Media stream URL uses wss://." : "Media stream URL should use wss:// for Twilio.", {
+    streamUrl
+  }));
+  const webhookBody = {
+    CallSid: input.options.smoke?.callSid ?? "CA_SMOKE_TEST",
+    CallStatus: input.options.smoke?.status ?? "busy",
+    SipResponseCode: String(input.options.smoke?.sipCode ?? 486)
+  };
+  const webhookHeaders = new Headers({
+    "content-type": "application/x-www-form-urlencoded"
+  });
+  const verificationUrl = setup.signing.verificationUrl ?? setup.urls.webhook;
+  if (input.options.webhook?.signingSecret) {
+    webhookHeaders.set("x-twilio-signature", await signVoiceTwilioWebhook({
+      authToken: input.options.webhook.signingSecret,
+      body: webhookBody,
+      url: verificationUrl
+    }));
+  }
+  const webhookResponse = await input.app.handle(new Request(setup.urls.webhook, {
+    body: new URLSearchParams(webhookBody),
+    headers: webhookHeaders,
+    method: "POST"
+  }));
+  const webhookText = await webhookResponse.text();
+  const webhookPayload = (() => {
+    try {
+      return JSON.parse(webhookText);
+    } catch {
+      return webhookText;
+    }
+  })();
+  checks.push(createSmokeCheck("webhook", webhookResponse.ok ? "pass" : "fail", webhookResponse.ok ? "Synthetic Twilio status callback was accepted." : "Synthetic Twilio status callback failed.", {
+    status: webhookResponse.status
+  }));
+  for (const warning of setup.warnings) {
+    checks.push(createSmokeCheck("setup-warning", "warn", warning));
+  }
+  for (const name of setup.missing) {
+    checks.push(createSmokeCheck("missing-env", "fail", `${name} is missing.`));
+  }
+  return {
+    checks,
+    generatedAt: Date.now(),
+    pass: checks.every((check) => check.status !== "fail"),
+    provider: "twilio",
+    setup,
+    twiml: {
+      status: twimlResponse.status,
+      streamUrl
+    },
+    webhook: {
+      body: webhookPayload,
+      status: webhookResponse.status
+    }
+  };
+};
 var normalizeOnTurn = (handler) => {
   if (handler.length > 1) {
     const directHandler = handler;
@@ -7745,7 +9325,7 @@ var bytesToInt16Array = (bytes) => {
   return output;
 };
 var decodeTwilioMulawBase64 = (payload) => {
-  const bytes = Uint8Array.from(Buffer2.from(payload, "base64"));
+  const bytes = Uint8Array.from(Buffer3.from(payload, "base64"));
   const samples = new Int16Array(bytes.length);
   for (let index = 0;index < bytes.length; index += 1) {
     samples[index] = decodeMulawSample(bytes[index] ?? 0);
@@ -7757,7 +9337,7 @@ var encodeTwilioMulawBase64 = (samples) => {
   for (let index = 0;index < samples.length; index += 1) {
     bytes[index] = encodeMulawSample(samples[index] ?? 0);
   }
-  return Buffer2.from(bytes).toString("base64");
+  return Buffer3.from(bytes).toString("base64");
 };
 var transcodeTwilioInboundPayloadToPCM16 = (payload) => {
   const narrowband = decodeTwilioMulawBase64(payload);
@@ -7766,7 +9346,7 @@ var transcodeTwilioInboundPayloadToPCM16 = (payload) => {
 };
 var transcodePCMToTwilioOutboundPayload = (chunk, format) => {
   if (format.container === "raw" && format.encoding === "mulaw" && format.channels === 1 && format.sampleRateHz === TWILIO_MULAW_SAMPLE_RATE) {
-    return Buffer2.from(chunk).toString("base64");
+    return Buffer3.from(chunk).toString("base64");
   }
   if (format.encoding !== "pcm_s16le") {
     throw new Error(`Unsupported outbound telephony audio format: ${format.container}/${format.encoding}`);
@@ -7807,7 +9387,7 @@ var createTwilioSocketAdapter = (socket, getState) => ({
       return;
     }
     if (message.type === "audio") {
-      const payload = transcodePCMToTwilioOutboundPayload(Uint8Array.from(Buffer2.from(message.chunkBase64, "base64")), message.format);
+      const payload = transcodePCMToTwilioOutboundPayload(Uint8Array.from(Buffer3.from(message.chunkBase64, "base64")), message.format);
       state.hasOutboundAudioSinceLastInbound = true;
       state.reviewRecorder?.recordTwilioOutbound({
         bytes: payload.length,
@@ -8020,6 +9600,148 @@ var createTwilioMediaStreamBridge = (socket, options) => {
     }
   };
 };
+var createTwilioVoiceRoutes = (options) => {
+  const streamPath = options.streamPath ?? "/api/voice/twilio/stream";
+  const twimlPath = options.twiml?.path ?? "/api/voice/twilio";
+  const webhookPath = options.webhook?.path ?? "/api/voice/twilio/webhook";
+  const setupPath = options.setup?.path === false ? false : options.setup?.path ?? "/api/voice/twilio/setup";
+  const smokePath = options.smoke?.path === false ? false : options.smoke?.path ?? "/api/voice/twilio/smoke";
+  const bridges = new WeakMap;
+  const webhookPolicy = options.webhook?.policy ?? options.outcomePolicy ?? createVoiceTelephonyOutcomePolicy();
+  const app = new Elysia2({
+    name: options.name ?? "absolutejs-voice-twilio"
+  }).get(twimlPath, async ({ query, request }) => {
+    const streamUrl = await resolveTwilioStreamUrl(options, {
+      query,
+      request,
+      streamPath
+    });
+    const parameters = await resolveTwilioStreamParameters(options.twiml?.parameters, {
+      query,
+      request
+    });
+    return new Response(createTwilioVoiceResponse({
+      parameters,
+      streamName: options.twiml?.streamName,
+      streamUrl,
+      track: options.twiml?.track
+    }), {
+      headers: {
+        "content-type": "text/xml; charset=utf-8"
+      }
+    });
+  }).post(twimlPath, async ({ query, request }) => {
+    const streamUrl = await resolveTwilioStreamUrl(options, {
+      query,
+      request,
+      streamPath
+    });
+    const parameters = await resolveTwilioStreamParameters(options.twiml?.parameters, {
+      query,
+      request
+    });
+    return new Response(createTwilioVoiceResponse({
+      parameters,
+      streamName: options.twiml?.streamName,
+      streamUrl,
+      track: options.twiml?.track
+    }), {
+      headers: {
+        "content-type": "text/xml; charset=utf-8"
+      }
+    });
+  }).ws(streamPath, {
+    close: async (ws, _code, reason) => {
+      const bridge = bridges.get(ws);
+      bridges.delete(ws);
+      await bridge?.close(reason);
+    },
+    message: async (ws, raw) => {
+      let bridge = bridges.get(ws);
+      if (!bridge) {
+        bridge = createTwilioMediaStreamBridge({
+          close: (code, reason) => {
+            ws.close(code, reason);
+          },
+          send: (data) => {
+            ws.send(data);
+          }
+        }, options);
+        bridges.set(ws, bridge);
+      }
+      await bridge.handleMessage(raw);
+    }
+  }).use(createVoiceTelephonyWebhookRoutes({
+    ...options.webhook ?? {},
+    context: options.context,
+    path: webhookPath,
+    policy: webhookPolicy,
+    provider: "twilio"
+  }));
+  if (!setupPath) {
+    if (!smokePath) {
+      return app;
+    }
+    return app.get(smokePath, async ({ query, request }) => {
+      const report = await runTwilioVoiceSmokeTest({
+        app,
+        options,
+        query,
+        request,
+        streamPath,
+        twimlPath,
+        webhookPath
+      });
+      if (query.format === "html") {
+        return new Response(renderTwilioVoiceSmokeHTML(report, options.smoke?.title ?? "AbsoluteJS Twilio Voice Smoke Test"), {
+          headers: {
+            "content-type": "text/html; charset=utf-8"
+          }
+        });
+      }
+      return report;
+    });
+  }
+  const withSetup = app.get(setupPath, async ({ query, request }) => {
+    const status = await buildTwilioVoiceSetupStatus(options, {
+      query,
+      request,
+      streamPath,
+      twimlPath,
+      webhookPath
+    });
+    if (query.format === "html") {
+      return new Response(renderTwilioVoiceSetupHTML(status, options.setup?.title ?? "AbsoluteJS Twilio Voice Setup"), {
+        headers: {
+          "content-type": "text/html; charset=utf-8"
+        }
+      });
+    }
+    return status;
+  });
+  if (!smokePath) {
+    return withSetup;
+  }
+  return withSetup.get(smokePath, async ({ query, request }) => {
+    const report = await runTwilioVoiceSmokeTest({
+      app,
+      options,
+      query,
+      request,
+      streamPath,
+      twimlPath,
+      webhookPath
+    });
+    if (query.format === "html") {
+      return new Response(renderTwilioVoiceSmokeHTML(report, options.smoke?.title ?? "AbsoluteJS Twilio Voice Smoke Test"), {
+        headers: {
+          "content-type": "text/html; charset=utf-8"
+        }
+      });
+    }
+    return report;
+  });
+};
 
 // src/testing/telephony.ts
 var DEFAULT_PCM16_FORMAT = {
@@ -8285,7 +10007,7 @@ var runVoiceTelephonyBenchmark = async (scenarios = getDefaultVoiceTelephonyBenc
   };
 };
 // src/testing/tts.ts
-var DEFAULT_REALTIME_FORMAT = {
+var DEFAULT_REALTIME_FORMAT2 = {
   channels: 1,
   container: "raw",
   encoding: "pcm_s16le",
@@ -8344,7 +10066,7 @@ var runTTSAdapterFixture = async (adapter, fixture, options = {}) => {
   let audioDurationMs = 0;
   let audioChunkCount = 0;
   const session = adapter.kind === "realtime" ? await adapter.open({
-    format: options.realtimeFormat ?? DEFAULT_REALTIME_FORMAT,
+    format: options.realtimeFormat ?? DEFAULT_REALTIME_FORMAT2,
     sessionId: `tts-benchmark:${fixture.id}`,
     ...openOptions ?? {}
   }) : await adapter.open({
@@ -8511,6 +10233,7 @@ export {
   getDefaultTTSBenchmarkFixtures,
   evaluateSTTBenchmarkAcceptance,
   createVoiceProviderFailureSimulator,
+  createVoiceIOProviderFailureSimulator,
   createVoiceCallReviewRecorder,
   createVoiceCallReviewFromLiveTelephonyReport,
   createTelephonyVoiceTestFixtures,