@absolutejs/voice 0.0.22-beta.545 → 0.0.22-beta.547

package/dist/index.js

@@ -3661,6 +3661,19 @@ 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;
 var getBufferedAudioDurationMs = (chunks) => chunks.reduce((total, chunk) => total + getAudioChunkDurationMs(chunk), 0);
+var STREAM_SENTENCE_BOUNDARY = /[.!?\u2026]['")\]]*\s/;
+var MAX_TTS_CHUNK_CHARS = 220;
+var nextSpeakableBoundary = (buffer) => {
+  const match = STREAM_SENTENCE_BOUNDARY.exec(buffer);
+  return match ? match.index + match[0].length : -1;
+};
+var softCutBoundary = (buffer) => {
+  if (buffer.length < MAX_TTS_CHUNK_CHARS)
+    return -1;
+  const window2 = buffer.slice(0, MAX_TTS_CHUNK_CHARS);
+  const lastSpace = window2.lastIndexOf(" ");
+  return lastSpace > 0 ? lastSpace + 1 : MAX_TTS_CHUNK_CHARS;
+};
 var calculateMeanConfidence = (transcripts) => {
   let sum = 0;
   let total = 0;
@@ -5130,6 +5143,110 @@ var createVoiceSession = (options) => {
       });
     });
   };
+  const createTurnTTSStreamer = (turn, session) => {
+    let buffer = "";
+    let full = "";
+    let charsSent = 0;
+    let started = false;
+    let streamed = false;
+    let sendChain = Promise.resolve();
+    let ttsSessionRequest = null;
+    const ttsStartedAt = Date.now();
+    const ensure = () => {
+      if (!ttsSessionRequest) {
+        ttsSessionRequest = ensureTTSSession().catch((error) => {
+          logger.warn("voice assistant audio send failed", {
+            error: toError(error).message,
+            sessionId: options.id,
+            turnId: turn.id
+          });
+          return null;
+        });
+      }
+      return ttsSessionRequest;
+    };
+    const flush = (text) => {
+      if (!text.trim())
+        return;
+      const previous = sendChain;
+      sendChain = (async () => {
+        await previous;
+        if (started && activeTTSTurnId !== turn.id)
+          return;
+        const ttsSession2 = await ensure();
+        if (!ttsSession2 || started && activeTTSTurnId !== turn.id)
+          return;
+        if (!started) {
+          activeTTSTurnId = turn.id;
+          await appendTurnLatencyStage({
+            at: ttsStartedAt,
+            session,
+            stage: "tts_send_started",
+            turnId: turn.id
+          });
+          started = true;
+        }
+        try {
+          await ttsSession2.send(text);
+          charsSent += text.length;
+        } catch (error) {
+          logger.warn("voice assistant audio send failed", {
+            error: toError(error).message,
+            sessionId: options.id,
+            turnId: turn.id
+          });
+        }
+      })();
+    };
+    return {
+      finish: async () => {
+        if (buffer.trim()) {
+          flush(buffer);
+        }
+        buffer = "";
+        await sendChain;
+        if (started) {
+          if (options.costAccountant) {
+            options.costAccountant.recordTTS({ characters: charsSent });
+          }
+          await appendTurnLatencyStage({
+            session,
+            stage: "tts_send_completed",
+            turnId: turn.id
+          });
+          await appendTrace({
+            payload: {
+              elapsedMs: Date.now() - ttsStartedAt,
+              status: "sent",
+              streamed: true
+            },
+            session,
+            turnId: turn.id,
+            type: "turn.assistant"
+          });
+        }
+        return { fullText: full, streamed };
+      },
+      push: (delta) => {
+        if (!delta)
+          return;
+        streamed = true;
+        full += delta;
+        buffer += delta;
+        let boundary = nextSpeakableBoundary(buffer);
+        while (boundary !== -1) {
+          flush(buffer.slice(0, boundary));
+          buffer = buffer.slice(boundary);
+          boundary = nextSpeakableBoundary(buffer);
+        }
+        const cut = softCutBoundary(buffer);
+        if (cut !== -1) {
+          flush(buffer.slice(0, cut));
+          buffer = buffer.slice(cut);
+        }
+      }
+    };
+  };
   const completeTurn = async (session, turn) => {
     const liveOpsControl = await options.liveOps?.getControl(options.id);
     if (liveOpsControl?.assistantPaused || liveOpsControl?.operatorTakeover) {
@@ -5150,6 +5267,7 @@ var createVoiceSession = (options) => {
       return;
     }
     const injectedInstruction = liveOpsControl?.injectedInstruction?.trim();
+    const ttsStreamer = options.tts ? createTurnTTSStreamer(turn, session) : undefined;
     const committedOutput = await options.route.onTurn({
       api,
       context: options.context,
@@ -5157,6 +5275,7 @@ var createVoiceSession = (options) => {
         control: liveOpsControl,
         injectedInstruction
       } : undefined,
+      onTextDelta: ttsStreamer?.push,
       session,
       turn
     });
@@ -5176,7 +5295,28 @@ var createVoiceSession = (options) => {
         setTurnResult(currentSession, turn.id, { citations: turnCitations });
       });
     }
-    if (output?.assistantText) {
+    const streamResult = ttsStreamer ? await ttsStreamer.finish() : undefined;
+    if (streamResult?.streamed) {
+      output.assistantText = streamResult.fullText || output.assistantText;
+      if (output.assistantText) {
+        const finalText = output.assistantText;
+        await writeSession((currentSession) => {
+          setTurnResult(currentSession, turn.id, { assistantText: finalText });
+        });
+        await send({ text: finalText, turnId: turn.id, type: "assistant" });
+        await appendTrace({
+          payload: {
+            assistantMode: resolveVoiceAssistantMode(options),
+            realtimeConfigured: Boolean(options.realtime),
+            text: finalText,
+            ttsConfigured: Boolean(options.tts)
+          },
+          session,
+          turnId: turn.id,
+          type: "turn.assistant"
+        });
+      }
+    } else if (output?.assistantText) {
       const assistantTextStartedAt = Date.now();
       await writeSession((currentSession) => {
         setTurnResult(currentSession, turn.id, {
@@ -5581,7 +5721,7 @@ var createVoiceSession = (options) => {
     kickCallSilenceWatchdog();
     startAmdEvaluationTimer();
     if (shouldFireOnSession && options.greeting && session.turns.length === 0) {
-      const greetingText = typeof options.greeting === "function" ? await options.greeting() : options.greeting;
+      const greetingText = typeof options.greeting === "function" ? await options.greeting({ session }) : options.greeting;
       const greetingTurnId = createId();
       await send({
         text: greetingText,
@@ -6825,6 +6965,100 @@ var appendVoiceAgentSquadHandoff = async (input) => {
   });
   return handoff;
 };
+var LIFECYCLE_TOOLS = [
+  {
+    description: "Transfer the call to a human agent or phone number. Say a short handoff line to the caller first, then call this.",
+    name: "transfer_call",
+    parameters: {
+      additionalProperties: false,
+      properties: {
+        reason: { description: "Why you are transferring", type: "string" },
+        target: {
+          description: "Agent id or phone number to transfer to",
+          type: "string"
+        }
+      },
+      required: ["target"],
+      type: "object"
+    }
+  },
+  {
+    description: "Escalate to a supervisor or human when you cannot resolve the caller's request.",
+    name: "escalate",
+    parameters: {
+      additionalProperties: false,
+      properties: {
+        reason: { description: "Why you are escalating", type: "string" }
+      },
+      required: ["reason"],
+      type: "object"
+    }
+  },
+  {
+    description: "Record that the call reached voicemail or an answering machine.",
+    name: "leave_voicemail",
+    parameters: { additionalProperties: false, properties: {}, type: "object" }
+  },
+  {
+    description: "Record that no one answered or the call could not proceed to a conversation.",
+    name: "mark_no_answer",
+    parameters: { additionalProperties: false, properties: {}, type: "object" }
+  },
+  {
+    description: "End the conversation once its goal is met. Optionally include a structured result.",
+    name: "complete",
+    parameters: {
+      additionalProperties: true,
+      properties: {
+        result: { description: "Structured outcome of the call, if any" }
+      },
+      type: "object"
+    }
+  }
+];
+var LIFECYCLE_TOOL_NAMES = new Set(LIFECYCLE_TOOLS.map((tool) => tool.name));
+var applyLifecycleToolCall = (output, toolCall) => {
+  const args = toolCall.args ?? {};
+  switch (toolCall.name) {
+    case "transfer_call":
+      output.transfer = {
+        reason: typeof args.reason === "string" ? args.reason : undefined,
+        target: typeof args.target === "string" ? args.target : ""
+      };
+      break;
+    case "escalate":
+      output.escalate = {
+        reason: typeof args.reason === "string" ? args.reason : "escalation requested"
+      };
+      break;
+    case "leave_voicemail":
+      output.voicemail = {};
+      break;
+    case "mark_no_answer":
+      output.noAnswer = {};
+      break;
+    case "complete":
+      output.complete = true;
+      if ("result" in args) {
+        output.result = args.result;
+      }
+      break;
+    default:
+      break;
+  }
+};
+var isLifecycleRequested = (output) => Boolean(output.complete) || Boolean(output.transfer) || Boolean(output.escalate) || Boolean(output.voicemail) || Boolean(output.noAnswer);
+var partitionAppToolCalls = (output, toolCalls) => {
+  const appToolCalls = [];
+  for (const toolCall of toolCalls ?? []) {
+    if (LIFECYCLE_TOOL_NAMES.has(toolCall.name)) {
+      applyLifecycleToolCall(output, toolCall);
+    } else {
+      appToolCalls.push(toolCall);
+    }
+  }
+  return appToolCalls;
+};
 var createVoiceAgent = (options) => {
   const toolMap = new Map(options.tools?.map((tool) => [tool.name, tool]) ?? []);
   const maxToolRounds = Math.max(0, options.maxToolRounds ?? 2);
@@ -6848,9 +7082,10 @@ var createVoiceAgent = (options) => {
           agentId: options.id,
           context: input.context,
           messages,
+          onTextDelta: input.onTextDelta,
           session: input.session,
           system,
-          tools: [...toolMap.values()].map((tool) => ({
+          tools: [...LIFECYCLE_TOOLS, ...toolMap.values()].map((tool) => ({
             description: tool.description,
             name: tool.name,
             parameters: tool.parameters
@@ -6915,10 +7150,11 @@ var createVoiceAgent = (options) => {
           role: "assistant"
         });
       }
-      if (!output.toolCalls?.length || round === maxToolRounds) {
+      const appToolCalls = partitionAppToolCalls(output, output.toolCalls);
+      if (appToolCalls.length === 0 || isLifecycleRequested(output) || round === maxToolRounds) {
         break;
       }
-      for (const toolCall of output.toolCalls) {
+      for (const toolCall of appToolCalls) {
         const tool = toolMap.get(toolCall.name);
         if (!tool) {
           const missingResult = {
@@ -7924,6 +8160,7 @@ var createVoiceAssistant = (options) => {
     }
     const runResult = await runner.run({
       ...input,
+      onTextDelta: input.onTextDelta,
       system: liveOpsInstruction ? `Operator instruction for this turn: ${liveOpsInstruction}` : undefined
     }) ?? {};
     const result = runResult;
@@ -24065,8 +24302,23 @@ var createTwilioSocketAdapter = (socket, getState) => ({
     if (!state.streamSid) {
       return;
     }
+    const clearMessage = { event: "clear", streamSid: state.streamSid };
     state.reviewRecorder?.recordTwilioOutbound({ event: "clear" });
-    await Promise.resolve(socket.send(JSON.stringify({ event: "clear", streamSid: state.streamSid })));
+    await state.trace?.append({
+      at: Date.now(),
+      payload: {
+        callSid: state.callSid ?? undefined,
+        carrier: state.carrier,
+        direction: "outbound",
+        envelope: clearMessage,
+        event: "clear",
+        streamId: state.streamSid
+      },
+      scenarioId: state.scenarioId ?? undefined,
+      sessionId: state.sessionId ?? state.streamSid,
+      type: "client.telephony_media"
+    });
+    await Promise.resolve(socket.send(JSON.stringify(clearMessage)));
   },
   close: async (code, reason) => {
     await Promise.resolve(socket.close(code, reason));
@@ -44164,89 +44416,6 @@ var createVoiceProviderOrchestrationProfile = (options) => {
     }
   };
 };
-var OUTPUT_SCHEMA = {
-  additionalProperties: false,
-  properties: {
-    assistantText: {
-      type: "string"
-    },
-    complete: {
-      type: "boolean"
-    },
-    escalate: {
-      additionalProperties: false,
-      properties: {
-        metadata: {
-          additionalProperties: true,
-          type: "object"
-        },
-        reason: {
-          type: "string"
-        }
-      },
-      required: ["reason"],
-      type: "object"
-    },
-    noAnswer: {
-      additionalProperties: false,
-      properties: {
-        metadata: {
-          additionalProperties: true,
-          type: "object"
-        }
-      },
-      type: "object"
-    },
-    result: {
-      additionalProperties: true,
-      type: "object"
-    },
-    transfer: {
-      additionalProperties: false,
-      properties: {
-        metadata: {
-          additionalProperties: true,
-          type: "object"
-        },
-        reason: {
-          type: "string"
-        },
-        target: {
-          type: "string"
-        }
-      },
-      required: ["target"],
-      type: "object"
-    },
-    voicemail: {
-      additionalProperties: false,
-      properties: {
-        metadata: {
-          additionalProperties: true,
-          type: "object"
-        }
-      },
-      type: "object"
-    }
-  },
-  type: "object"
-};
-var ROUTE_RESULT_INSTRUCTION = "Return only a JSON object with assistantText, complete, transfer, escalate, voicemail, noAnswer, and result when you are not calling tools. Only set transfer, escalate, voicemail, or noAnswer when the user explicitly asks for that lifecycle outcome or a tool result says that exact outcome. Do not infer voicemail from generic words like voice, voice app, or voice integration.";
-var stripJSONCodeFence = (value) => {
-  const trimmed = value.trim();
-  const match = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
-  return match?.[1]?.trim() ?? value;
-};
-var parseJSON = (value) => {
-  try {
-    const parsed = JSON.parse(stripJSONCodeFence(value));
-    return parsed && typeof parsed === "object" ? parsed : {};
-  } catch {
-    return {
-      assistantText: value
-    };
-  }
-};
 var parseJSONValue = (value) => {
   try {
     return JSON.parse(value);
@@ -44717,48 +44886,95 @@ var messageToGeminiContent = (message) => {
     role: message.role === "assistant" ? "model" : "user"
   };
 };
-var extractText = (response) => {
-  if (typeof response.output_text === "string") {
-    return response.output_text;
+var VOICE_SYSTEM_INSTRUCTIONS = "You are on a live phone call. Reply with natural, concise spoken sentences \u2014 no markdown, lists, headings, or emoji. To take an action (transfer the call, escalate, record voicemail/no-answer, or end the call), CALL the matching tool rather than describing it in words. Call the complete tool once the conversation's goal is met.";
+var parseToolArgs = (raw) => {
+  if (!raw.trim()) {
+    return {};
   }
-  const output = Array.isArray(response.output) ? response.output : [];
-  for (const item of output) {
-    if (!item || typeof item !== "object") {
-      continue;
-    }
-    const record = item;
-    const content = Array.isArray(record.content) ? record.content : [];
-    for (const contentItem of content) {
-      if (!contentItem || typeof contentItem !== "object") {
-        continue;
-      }
-      const contentRecord = contentItem;
-      if (typeof contentRecord.text === "string") {
-        return contentRecord.text;
-      }
-    }
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
   }
-  return "";
 };
-var extractToolCalls = (response) => {
-  const output = Array.isArray(response.output) ? response.output : [];
-  const toolCalls = [];
-  for (const item of output) {
-    if (!item || typeof item !== "object") {
-      continue;
+var readServerSentEvents = async (response, onEvent) => {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("streaming response has no body");
+  }
+  const decoder = new TextDecoder;
+  let buffer = "";
+  const drain = (block) => {
+    for (const line of block.split(`
+`)) {
+      const trimmed = line.trimStart();
+      if (!trimmed.startsWith("data:"))
+        continue;
+      const data = trimmed.slice("data:".length).trim();
+      if (!data || data === "[DONE]")
+        continue;
+      try {
+        onEvent(JSON.parse(data));
+      } catch {}
     }
-    const record = item;
-    if (record.type !== "function_call" || typeof record.name !== "string") {
-      continue;
+  };
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    buffer += decoder.decode(value, { stream: true });
+    let separator = buffer.indexOf(`
+
+`);
+    while (separator !== -1) {
+      drain(buffer.slice(0, separator));
+      buffer = buffer.slice(separator + 2);
+      separator = buffer.indexOf(`
+
+`);
     }
-    const args = typeof record.arguments === "string" ? parseJSON(record.arguments) : {};
-    toolCalls.push({
-      args,
-      id: typeof record.call_id === "string" ? record.call_id : typeof record.id === "string" ? record.id : undefined,
-      name: record.name
-    });
   }
-  return toolCalls;
+  if (buffer.trim())
+    drain(buffer);
+};
+var finalizeToolCalls = (calls) => [...calls.values()].filter((call) => call.name).map((call) => ({
+  args: parseToolArgs(call.args),
+  id: call.id,
+  name: call.name
+}));
+var consumeOpenAIResponsesStream = async (response, onTextDelta) => {
+  let assistantText = "";
+  let usage;
+  const calls = new Map;
+  await readServerSentEvents(response, (event) => {
+    const type = typeof event.type === "string" ? event.type : "";
+    const item = event.item;
+    if (type === "response.output_text.delta" && typeof event.delta === "string") {
+      assistantText += event.delta;
+      onTextDelta?.(event.delta);
+    } else if (type === "response.output_item.added" && item?.type === "function_call") {
+      calls.set(String(item.id ?? item.call_id ?? ""), {
+        args: typeof item.arguments === "string" ? item.arguments : "",
+        id: typeof item.call_id === "string" ? item.call_id : item.id,
+        name: typeof item.name === "string" ? item.name : ""
+      });
+    } else if (type === "response.function_call_arguments.delta" && typeof event.delta === "string") {
+      const entry = calls.get(String(event.item_id ?? ""));
+      if (entry)
+        entry.args += event.delta;
+    } else if (type === "response.output_item.done" && item?.type === "function_call" && typeof item.arguments === "string" && item.arguments) {
+      const entry = calls.get(String(item.id ?? item.call_id ?? ""));
+      if (entry)
+        entry.args = item.arguments;
+    } else if (type === "response.completed") {
+      const completed = event.response;
+      if (completed?.usage && typeof completed.usage === "object") {
+        usage = completed.usage;
+      }
+    }
+  });
+  return { assistantText, toolCalls: finalizeToolCalls(calls), usage };
 };
 var createOpenAIVoiceAssistantModel = (options) => {
   const fetchImpl = options.fetch ?? globalThis.fetch;
@@ -44769,23 +44985,13 @@ var createOpenAIVoiceAssistantModel = (options) => {
       const response = await fetchImpl(`${baseUrl.replace(/\/$/, "")}/responses`, {
         body: JSON.stringify({
           input: messagesToOpenAIInput(input.messages),
-          instructions: [
-            input.system,
-            "Return a JSON object with assistantText, complete, transfer, escalate, voicemail, noAnswer, and result when you are not calling tools."
-          ].filter(Boolean).join(`
+          instructions: [input.system, VOICE_SYSTEM_INSTRUCTIONS].filter(Boolean).join(`
 
 `),
           max_output_tokens: options.maxOutputTokens,
           model,
+          stream: true,
           temperature: options.temperature,
-          text: {
-            format: {
-              name: "voice_route_result",
-              schema: OUTPUT_SCHEMA,
-              strict: false,
-              type: "json_schema"
-            }
-          },
           tool_choice: input.tools.length ? "auto" : "none",
           tools: input.tools.map((tool) => ({
             description: tool.description,
@@ -44799,6 +45005,7 @@ var createOpenAIVoiceAssistantModel = (options) => {
           }))
         }),
         headers: {
+          accept: "text/event-stream",
           authorization: `Bearer ${options.apiKey}`,
           "content-type": "application/json"
         },
@@ -44807,43 +45014,52 @@ var createOpenAIVoiceAssistantModel = (options) => {
       if (!response.ok) {
         throw createHTTPError("OpenAI", response);
       }
-      const body = await response.json();
-      if (body.usage && typeof body.usage === "object") {
-        await options.onUsage?.(body.usage);
-      }
-      const toolCalls = extractToolCalls(body);
-      if (toolCalls.length) {
-        return {
-          toolCalls
-        };
+      const { assistantText, toolCalls, usage } = await consumeOpenAIResponsesStream(response, input.onTextDelta);
+      if (usage) {
+        await options.onUsage?.(usage);
       }
-      return normalizeRouteOutput(parseJSON(extractText(body)));
+      return {
+        ...assistantText ? { assistantText } : {},
+        ...toolCalls.length ? { toolCalls } : {}
+      };
     }
   };
 };
-var extractAnthropicText = (response) => {
-  const content = Array.isArray(response.content) ? response.content : [];
-  return content.map((item) => item && typeof item === "object" && item.type === "text" && typeof item.text === "string" ? item.text : "").filter(Boolean).join(`
-`);
-};
-var extractAnthropicToolCalls = (response) => {
-  const content = Array.isArray(response.content) ? response.content : [];
-  const toolCalls = [];
-  for (const item of content) {
-    if (!item || typeof item !== "object") {
-      continue;
-    }
-    const record = item;
-    if (record.type !== "tool_use" || typeof record.name !== "string") {
-      continue;
+var consumeAnthropicStream = async (response, onTextDelta) => {
+  let assistantText = "";
+  let usage;
+  const calls = new Map;
+  await readServerSentEvents(response, (event) => {
+    const type = typeof event.type === "string" ? event.type : "";
+    const delta = event.delta;
+    if (type === "content_block_delta" && delta?.type === "text_delta") {
+      if (typeof delta.text === "string") {
+        assistantText += delta.text;
+        onTextDelta?.(delta.text);
+      }
+    } else if (type === "content_block_delta" && delta?.type === "input_json_delta" && typeof delta.partial_json === "string") {
+      const entry = calls.get(String(event.index ?? ""));
+      if (entry)
+        entry.args += delta.partial_json;
+    } else if (type === "content_block_start") {
+      const block = event.content_block;
+      if (block?.type === "tool_use") {
+        calls.set(String(event.index ?? ""), {
+          args: "",
+          id: typeof block.id === "string" ? block.id : undefined,
+          name: typeof block.name === "string" ? block.name : ""
+        });
+      }
+    } else if (type === "message_start") {
+      const message = event.message;
+      if (message?.usage && typeof message.usage === "object") {
+        usage = message.usage;
+      }
+    } else if (type === "message_delta" && event.usage && typeof event.usage === "object") {
+      usage = { ...usage, ...event.usage };
     }
-    toolCalls.push({
-      args: record.input && typeof record.input === "object" ? record.input : {},
-      id: typeof record.id === "string" ? record.id : undefined,
-      name: record.name
-    });
-  }
-  return toolCalls;
+  });
+  return { assistantText, toolCalls: finalizeToolCalls(calls), usage };
 };
 var createAnthropicVoiceAssistantModel = (options) => {
   const fetchImpl = options.fetch ?? globalThis.fetch;
@@ -44856,7 +45072,8 @@ var createAnthropicVoiceAssistantModel = (options) => {
           max_tokens: options.maxOutputTokens ?? 1024,
           messages: input.messages.map(messageToAnthropicMessage).filter(Boolean),
           model,
-          system: [input.system, ROUTE_RESULT_INSTRUCTION].filter(Boolean).join(`
+          stream: true,
+          system: [input.system, VOICE_SYSTEM_INSTRUCTIONS].filter(Boolean).join(`
 
 `),
           temperature: options.temperature,
@@ -44880,57 +45097,55 @@ var createAnthropicVoiceAssistantModel = (options) => {
       if (!response.ok) {
         throw createHTTPError("Anthropic", response);
       }
-      const body = await response.json();
-      if (body.usage && typeof body.usage === "object") {
-        await options.onUsage?.(body.usage);
-      }
-      const toolCalls = extractAnthropicToolCalls(body);
-      if (toolCalls.length) {
-        return {
-          assistantText: extractAnthropicText(body) || undefined,
-          toolCalls
-        };
+      const { assistantText, toolCalls, usage } = await consumeAnthropicStream(response, input.onTextDelta);
+      if (usage) {
+        await options.onUsage?.(usage);
       }
-      return normalizeRouteOutput(parseJSON(extractAnthropicText(body)));
+      return {
+        ...assistantText ? { assistantText } : {},
+        ...toolCalls.length ? { toolCalls } : {}
+      };
     }
   };
 };
-var extractGeminiCandidateParts = (response) => {
-  const candidates = Array.isArray(response.candidates) ? response.candidates : [];
-  const first = candidates[0];
-  if (!first || typeof first !== "object") {
-    return [];
+var handleGeminiPart = (part, collect) => {
+  if (!part || typeof part !== "object")
+    return "";
+  const record = part;
+  if (typeof record.text === "string" && record.text) {
+    collect.onTextDelta?.(record.text);
+    return record.text;
   }
-  const { content } = first;
-  if (!content || typeof content !== "object") {
-    return [];
+  const { functionCall } = record;
+  if (functionCall && typeof functionCall === "object") {
+    const fn = functionCall;
+    if (typeof fn.name === "string") {
+      collect.toolCalls.push({
+        args: fn.args && typeof fn.args === "object" ? fn.args : {},
+        id: typeof fn.id === "string" ? fn.id : undefined,
+        name: fn.name
+      });
+    }
   }
-  const { parts } = content;
-  return Array.isArray(parts) ? parts : [];
+  return "";
 };
-var extractGeminiText = (response) => extractGeminiCandidateParts(response).map((part) => part && typeof part === "object" && typeof part.text === "string" ? part.text : "").filter(Boolean).join(`
-`);
-var extractGeminiToolCalls = (response) => {
+var consumeGeminiStream = async (response, onTextDelta) => {
+  let assistantText = "";
+  let usage;
   const toolCalls = [];
-  for (const part of extractGeminiCandidateParts(response)) {
-    if (!part || typeof part !== "object") {
-      continue;
-    }
-    const { functionCall } = part;
-    if (!functionCall || typeof functionCall !== "object") {
-      continue;
+  await readServerSentEvents(response, (event) => {
+    if (event.usageMetadata && typeof event.usageMetadata === "object") {
+      usage = event.usageMetadata;
     }
-    const record = functionCall;
-    if (typeof record.name !== "string") {
-      continue;
+    const candidates = Array.isArray(event.candidates) ? event.candidates : [];
+    const first = candidates[0];
+    const content = first?.content;
+    const parts = Array.isArray(content?.parts) ? content.parts : [];
+    for (const part of parts) {
+      assistantText += handleGeminiPart(part, { onTextDelta, toolCalls });
     }
-    toolCalls.push({
-      args: record.args && typeof record.args === "object" ? record.args : {},
-      id: typeof record.id === "string" ? record.id : undefined,
-      name: record.name
-    });
-  }
-  return toolCalls;
+  });
+  return { assistantText, toolCalls, usage };
 };
 var createGeminiVoiceAssistantModel = (options) => {
   const fetchImpl = options.fetch ?? globalThis.fetch;
@@ -44939,7 +45154,7 @@ var createGeminiVoiceAssistantModel = (options) => {
   const maxRetries = Math.max(0, options.maxRetries ?? 2);
   return {
     generate: async (input) => {
-      const endpoint = `${baseUrl.replace(/\/$/, "")}/models/${encodeURIComponent(model)}:generateContent?key=${encodeURIComponent(options.apiKey)}`;
+      const endpoint = `${baseUrl.replace(/\/$/, "")}/models/${encodeURIComponent(model)}:streamGenerateContent?alt=sse&key=${encodeURIComponent(options.apiKey)}`;
       let response;
       for (let attempt = 0;attempt <= maxRetries; attempt += 1) {
         response = await fetchImpl(endpoint, {
@@ -44947,16 +45162,12 @@ var createGeminiVoiceAssistantModel = (options) => {
             contents: input.messages.map(messageToGeminiContent).filter(Boolean),
             generationConfig: {
               maxOutputTokens: options.maxOutputTokens,
-              ...input.tools.length ? {} : {
-                responseMimeType: "application/json",
-                responseSchema: toGeminiSchema(OUTPUT_SCHEMA)
-              },
               temperature: options.temperature
             },
             systemInstruction: {
               parts: [
                 {
-                  text: [input.system, ROUTE_RESULT_INSTRUCTION].filter(Boolean).join(`
+                  text: [input.system, VOICE_SYSTEM_INSTRUCTIONS].filter(Boolean).join(`
 
 `)
                 }
@@ -44992,18 +45203,14 @@ var createGeminiVoiceAssistantModel = (options) => {
       if (!response.ok) {
         throw createHTTPError("Gemini", response);
       }
-      const body = await response.json();
-      if (body.usageMetadata && typeof body.usageMetadata === "object") {
-        await options.onUsage?.(body.usageMetadata);
+      const { assistantText, toolCalls, usage } = await consumeGeminiStream(response, input.onTextDelta);
+      if (usage) {
+        await options.onUsage?.(usage);
       }
-      const toolCalls = extractGeminiToolCalls(body);
-      if (toolCalls.length) {
-        return {
-          assistantText: extractGeminiText(body) || undefined,
-          toolCalls
-        };
-      }
-      return normalizeRouteOutput(parseJSON(extractGeminiText(body)));
+      return {
+        ...assistantText ? { assistantText } : {},
+        ...toolCalls.length ? { toolCalls } : {}
+      };
     }
   };
 };
@@ -48413,14 +48620,14 @@ var DEFAULT_VOICE_PROMPT_INJECTION_RULES = [
     severity: "low"
   }
 ];
-var extractText2 = (input) => typeof input === "string" ? input : input.text;
+var extractText = (input) => typeof input === "string" ? input : input.text;
 var createVoicePromptInjectionGuard = (options = {}) => {
   const rules = options.rules ?? DEFAULT_VOICE_PROMPT_INJECTION_RULES;
   const replacement = options.sanitizedReplacement ?? "[REDACTED:INJECTION]";
   return {
     rules,
     evaluate: (input) => {
-      const text = extractText2(input);
+      const text = extractText(input);
       const matches = [];
       for (const rule of rules) {
         rule.pattern.lastIndex = 0;