@absolutejs/voice 0.0.22-beta.553 → 0.0.22-beta.555

package/dist/core/modelAdapters.d.ts

@@ -13,6 +13,14 @@ export type OpenAIVoiceAssistantModelOptions = {
     model?: string;
     onUsage?: (usage: Record<string, unknown>) => Promise<void> | void;
     temperature?: number;
+    /**
+     * Hard cap on a single /responses stream. Aborts via AbortController if
+     * the stream doesn't complete in time. Default 60s — generous for typical
+     * gpt-4.1-mini conversational turns (1-3s) but catches infinite hangs
+     * (server-side stream stalls observed on rare complex inputs). On timeout
+     * the agent loop falls through to default-silent-turn-ack.
+     */
+    timeoutMs?: number;
 };
 export type AnthropicVoiceAssistantModelOptions = {
     apiKey: string;

package/dist/core/types.d.ts

@@ -916,6 +916,13 @@ export type CreateVoiceSessionOptions<TContext = unknown, TSession extends Voice
     fillerPhrases?: ReadonlyArray<string>;
     /** Milliseconds after turn-commit before the filler fires. Default 250ms — short enough to feel instant, long enough to skip if the LLM is very fast. */
     fillerDelayMs?: number;
+    /**
+     * Default spoken ack if the model returns ONLY tool calls (no text) and the
+     * turn isn't ending. Without this, the caller hears total silence after
+     * their turn and assumes the line dropped. Default is "Sorry, one moment."
+     * Set to "" to opt out entirely.
+     */
+    defaultSilentTurnAck?: string;
     assistantMode?: import("./assistantMode").VoiceAssistantMode;
     modalities?: ReadonlyArray<"audio" | "text">;
     prosody?: VoiceTTSProsody;

package/dist/index.js

@@ -5303,17 +5303,41 @@ var createVoiceSession = (options) => {
         });
       }, fillerDelayMs);
     }
-    const committedOutput = await options.route.onTurn({
-      api,
-      context: options.context,
-      liveOps: liveOpsControl ? {
-        control: liveOpsControl,
-        injectedInstruction
-      } : undefined,
-      onTextDelta: ttsStreamer?.push,
-      session,
-      turn
-    });
+    let committedOutput;
+    const onTurnStartedAt = Date.now();
+    try {
+      committedOutput = await options.route.onTurn({
+        api,
+        context: options.context,
+        liveOps: liveOpsControl ? {
+          control: liveOpsControl,
+          injectedInstruction
+        } : undefined,
+        onTextDelta: ttsStreamer?.push,
+        session,
+        turn
+      });
+    } catch (error) {
+      const message = toError(error).message;
+      logger.warn("voice route.onTurn failed", {
+        elapsedMs: Date.now() - onTurnStartedAt,
+        error: message,
+        sessionId: options.id,
+        turnId: turn.id
+      });
+      console.error(`[voice] onTurn failed for session ${options.id} turn ${turn.id} after ${Date.now() - onTurnStartedAt}ms:`, message);
+      await appendTrace({
+        payload: {
+          elapsedMs: Date.now() - onTurnStartedAt,
+          error: message,
+          stage: "route.onTurn"
+        },
+        session,
+        turnId: turn.id,
+        type: "session.error"
+      });
+      committedOutput = undefined;
+    }
     const output = {
       assistantText: committedOutput?.assistantText,
       citations: committedOutput?.citations,
@@ -5464,6 +5488,53 @@ var createVoiceSession = (options) => {
         });
       }
     }
+    const audioWasSent = Boolean(streamResult?.streamed) || Boolean(output?.assistantText?.trim());
+    const turnIsEnding = Boolean(output?.complete) || Boolean(output?.transfer) || Boolean(output?.escalate) || Boolean(output?.voicemail) || Boolean(output?.noAnswer);
+    if (!audioWasSent && !turnIsEnding) {
+      const fallback = typeof options.defaultSilentTurnAck === "string" ? options.defaultSilentTurnAck : "Sorry, one moment.";
+      if (fallback.trim() && options.tts) {
+        try {
+          const activeTTSSession = await ensureTTSSession();
+          if (activeTTSSession) {
+            fillerToken += 1;
+            if (fillerTimer) {
+              clearTimeout(fillerTimer);
+              fillerTimer = null;
+            }
+            if (fillerActive) {
+              await cancelActiveTTS("filler-superseded").catch(() => {});
+              fillerActive = false;
+            }
+            activeTTSTurnId = turn.id;
+            await activeTTSSession.send(fallback);
+            await appendTrace({
+              payload: {
+                assistantMode: resolveVoiceAssistantMode(options),
+                fallback: true,
+                realtimeConfigured: Boolean(options.realtime),
+                reason: "model-returned-no-text",
+                text: fallback,
+                ttsConfigured: Boolean(options.tts)
+              },
+              session,
+              turnId: turn.id,
+              type: "turn.assistant"
+            });
+            if (options.costAccountant) {
+              options.costAccountant.recordTTS({
+                characters: fallback.length
+              });
+            }
+          }
+        } catch (error) {
+          logger.warn("voice default-silent-turn-ack fallback send failed", {
+            error: toError(error).message,
+            sessionId: options.id,
+            turnId: turn.id
+          });
+        }
+      }
+    }
     if (output?.result !== undefined) {
       await writeSession((currentSession) => {
         setTurnResult(currentSession, turn.id, {
@@ -24608,6 +24679,7 @@ var createTwilioMediaStreamBridge = (socket, options) => {
       ...options.semanticTurnDetector ? { semanticTurnDetector: options.semanticTurnDetector } : {},
       ...options.fillerPhrases ? { fillerPhrases: options.fillerPhrases } : {},
       ...options.fillerDelayMs !== undefined ? { fillerDelayMs: options.fillerDelayMs } : {},
+      ...options.defaultSilentTurnAck !== undefined ? { defaultSilentTurnAck: options.defaultSilentTurnAck } : {},
       trace: options.trace,
       tts: options.tts,
       turnDetection
@@ -45058,41 +45130,61 @@ 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";
+  const timeoutMs = options.timeoutMs ?? 60000;
   return {
     generate: async (input) => {
-      const response = await fetchImpl(`${baseUrl.replace(/\/$/, "")}/responses`, {
-        body: JSON.stringify({
-          input: messagesToOpenAIInput(input.messages),
-          instructions: [input.system, VOICE_SYSTEM_INSTRUCTIONS].filter(Boolean).join(`
+      const ac = new AbortController;
+      const timer = setTimeout(() => {
+        ac.abort(new Error(`OpenAI /responses timed out after ${timeoutMs}ms (no completion event received)`));
+      }, timeoutMs);
+      let response;
+      try {
+        response = await fetchImpl(`${baseUrl.replace(/\/$/, "")}/responses`, {
+          body: JSON.stringify({
+            input: messagesToOpenAIInput(input.messages),
+            instructions: [input.system, VOICE_SYSTEM_INSTRUCTIONS].filter(Boolean).join(`
 
 `),
-          max_output_tokens: options.maxOutputTokens,
-          model,
-          stream: true,
-          temperature: options.temperature,
-          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: {
-          accept: "text/event-stream",
-          authorization: `Bearer ${options.apiKey}`,
-          "content-type": "application/json"
-        },
-        method: "POST"
-      });
+            max_output_tokens: options.maxOutputTokens,
+            model,
+            stream: true,
+            temperature: options.temperature,
+            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: {
+            accept: "text/event-stream",
+            authorization: `Bearer ${options.apiKey}`,
+            "content-type": "application/json"
+          },
+          method: "POST",
+          signal: ac.signal
+        });
+      } catch (error) {
+        clearTimeout(timer);
+        throw error;
+      }
       if (!response.ok) {
+        clearTimeout(timer);
         throw createHTTPError("OpenAI", response);
       }
-      const { assistantText, toolCalls, usage } = await consumeOpenAIResponsesStream(response, input.onTextDelta);
+      let assistantText;
+      let toolCalls;
+      let usage;
+      try {
+        ({ assistantText, toolCalls, usage } = await consumeOpenAIResponsesStream(response, input.onTextDelta));
+      } finally {
+        clearTimeout(timer);
+      }
       if (usage) {
         await options.onUsage?.(usage);
       }

package/dist/telephony/twilio.d.ts

@@ -132,6 +132,13 @@ export type TwilioMediaStreamBridgeOptions<TContext = unknown, TSession extends
     fillerPhrases?: ReadonlyArray<string>;
     /** Milliseconds after turn-commit before the filler fires. Default 250ms. */
     fillerDelayMs?: number;
+    /**
+     * Default spoken ack if the model returns ONLY tool calls (no text) and
+     * the turn isn't ending. Without this, the caller hears silence and
+     * assumes the line dropped. Default "Sorry, one moment." — set to ""
+     * to opt out. See CreateVoiceSessionOptions for full semantics.
+     */
+    defaultSilentTurnAck?: string;
 };
 export type TwilioMediaStreamBridge = {
     close: (reason?: string) => Promise<void>;

package/dist/testing/index.js

@@ -4600,41 +4600,61 @@ 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";
+  const timeoutMs = options.timeoutMs ?? 60000;
   return {
     generate: async (input) => {
-      const response = await fetchImpl(`${baseUrl.replace(/\/$/, "")}/responses`, {
-        body: JSON.stringify({
-          input: messagesToOpenAIInput(input.messages),
-          instructions: [input.system, VOICE_SYSTEM_INSTRUCTIONS].filter(Boolean).join(`
+      const ac = new AbortController;
+      const timer = setTimeout(() => {
+        ac.abort(new Error(`OpenAI /responses timed out after ${timeoutMs}ms (no completion event received)`));
+      }, timeoutMs);
+      let response;
+      try {
+        response = await fetchImpl(`${baseUrl.replace(/\/$/, "")}/responses`, {
+          body: JSON.stringify({
+            input: messagesToOpenAIInput(input.messages),
+            instructions: [input.system, VOICE_SYSTEM_INSTRUCTIONS].filter(Boolean).join(`
 
 `),
-          max_output_tokens: options.maxOutputTokens,
-          model,
-          stream: true,
-          temperature: options.temperature,
-          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: {
-          accept: "text/event-stream",
-          authorization: `Bearer ${options.apiKey}`,
-          "content-type": "application/json"
-        },
-        method: "POST"
-      });
+            max_output_tokens: options.maxOutputTokens,
+            model,
+            stream: true,
+            temperature: options.temperature,
+            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: {
+            accept: "text/event-stream",
+            authorization: `Bearer ${options.apiKey}`,
+            "content-type": "application/json"
+          },
+          method: "POST",
+          signal: ac.signal
+        });
+      } catch (error) {
+        clearTimeout(timer);
+        throw error;
+      }
       if (!response.ok) {
+        clearTimeout(timer);
         throw createHTTPError("OpenAI", response);
       }
-      const { assistantText, toolCalls, usage } = await consumeOpenAIResponsesStream(response, input.onTextDelta);
+      let assistantText;
+      let toolCalls;
+      let usage;
+      try {
+        ({ assistantText, toolCalls, usage } = await consumeOpenAIResponsesStream(response, input.onTextDelta));
+      } finally {
+        clearTimeout(timer);
+      }
       if (usage) {
         await options.onUsage?.(usage);
       }
@@ -7120,17 +7140,41 @@ var createVoiceSession = (options) => {
         });
       }, fillerDelayMs);
     }
-    const committedOutput = await options.route.onTurn({
-      api,
-      context: options.context,
-      liveOps: liveOpsControl ? {
-        control: liveOpsControl,
-        injectedInstruction
-      } : undefined,
-      onTextDelta: ttsStreamer?.push,
-      session,
-      turn
-    });
+    let committedOutput;
+    const onTurnStartedAt = Date.now();
+    try {
+      committedOutput = await options.route.onTurn({
+        api,
+        context: options.context,
+        liveOps: liveOpsControl ? {
+          control: liveOpsControl,
+          injectedInstruction
+        } : undefined,
+        onTextDelta: ttsStreamer?.push,
+        session,
+        turn
+      });
+    } catch (error) {
+      const message = toError(error).message;
+      logger.warn("voice route.onTurn failed", {
+        elapsedMs: Date.now() - onTurnStartedAt,
+        error: message,
+        sessionId: options.id,
+        turnId: turn.id
+      });
+      console.error(`[voice] onTurn failed for session ${options.id} turn ${turn.id} after ${Date.now() - onTurnStartedAt}ms:`, message);
+      await appendTrace({
+        payload: {
+          elapsedMs: Date.now() - onTurnStartedAt,
+          error: message,
+          stage: "route.onTurn"
+        },
+        session,
+        turnId: turn.id,
+        type: "session.error"
+      });
+      committedOutput = undefined;
+    }
     const output = {
       assistantText: committedOutput?.assistantText,
       citations: committedOutput?.citations,
@@ -7281,6 +7325,53 @@ var createVoiceSession = (options) => {
         });
       }
     }
+    const audioWasSent = Boolean(streamResult?.streamed) || Boolean(output?.assistantText?.trim());
+    const turnIsEnding = Boolean(output?.complete) || Boolean(output?.transfer) || Boolean(output?.escalate) || Boolean(output?.voicemail) || Boolean(output?.noAnswer);
+    if (!audioWasSent && !turnIsEnding) {
+      const fallback = typeof options.defaultSilentTurnAck === "string" ? options.defaultSilentTurnAck : "Sorry, one moment.";
+      if (fallback.trim() && options.tts) {
+        try {
+          const activeTTSSession = await ensureTTSSession();
+          if (activeTTSSession) {
+            fillerToken += 1;
+            if (fillerTimer) {
+              clearTimeout(fillerTimer);
+              fillerTimer = null;
+            }
+            if (fillerActive) {
+              await cancelActiveTTS("filler-superseded").catch(() => {});
+              fillerActive = false;
+            }
+            activeTTSTurnId = turn.id;
+            await activeTTSSession.send(fallback);
+            await appendTrace({
+              payload: {
+                assistantMode: resolveVoiceAssistantMode(options),
+                fallback: true,
+                realtimeConfigured: Boolean(options.realtime),
+                reason: "model-returned-no-text",
+                text: fallback,
+                ttsConfigured: Boolean(options.tts)
+              },
+              session,
+              turnId: turn.id,
+              type: "turn.assistant"
+            });
+            if (options.costAccountant) {
+              options.costAccountant.recordTTS({
+                characters: fallback.length
+              });
+            }
+          }
+        } catch (error) {
+          logger.warn("voice default-silent-turn-ack fallback send failed", {
+            error: toError(error).message,
+            sessionId: options.id,
+            turnId: turn.id
+          });
+        }
+      }
+    }
     if (output?.result !== undefined) {
       await writeSession((currentSession) => {
         setTurnResult(currentSession, turn.id, {
@@ -13144,6 +13235,7 @@ var createTwilioMediaStreamBridge = (socket, options) => {
       ...options.semanticTurnDetector ? { semanticTurnDetector: options.semanticTurnDetector } : {},
       ...options.fillerPhrases ? { fillerPhrases: options.fillerPhrases } : {},
       ...options.fillerDelayMs !== undefined ? { fillerDelayMs: options.fillerDelayMs } : {},
+      ...options.defaultSilentTurnAck !== undefined ? { defaultSilentTurnAck: options.defaultSilentTurnAck } : {},
       trace: options.trace,
       tts: options.tts,
       turnDetection

package/package.json

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