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

package/dist/testing/index.js

@@ -4036,89 +4036,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);
@@ -4589,48 +4506,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;
@@ -4641,23 +4605,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,
@@ -4671,6 +4625,7 @@ var createOpenAIVoiceAssistantModel = (options) => {
           }))
         }),
         headers: {
+          accept: "text/event-stream",
           authorization: `Bearer ${options.apiKey}`,
           "content-type": "application/json"
         },
@@ -4679,43 +4634,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;
@@ -4728,7 +4692,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,
@@ -4752,57 +4717,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 [];
-  }
-  const { content } = first;
-  if (!content || typeof content !== "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 { 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;
+  await readServerSentEvents(response, (event) => {
+    if (event.usageMetadata && typeof event.usageMetadata === "object") {
+      usage = event.usageMetadata;
     }
-    const { functionCall } = part;
-    if (!functionCall || typeof functionCall !== "object") {
-      continue;
-    }
-    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;
@@ -4811,7 +4774,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, {
@@ -4819,16 +4782,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(`
 
 `)
                 }
@@ -4864,18 +4823,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 toolCalls = extractGeminiToolCalls(body);
-      if (toolCalls.length) {
-        return {
-          assistantText: extractGeminiText(body) || undefined,
-          toolCalls
-        };
+      const { assistantText, toolCalls, usage } = await consumeGeminiStream(response, input.onTextDelta);
+      if (usage) {
+        await options.onUsage?.(usage);
       }
-      return normalizeRouteOutput(parseJSON(extractGeminiText(body)));
+      return {
+        ...assistantText ? { assistantText } : {},
+        ...toolCalls.length ? { toolCalls } : {}
+      };
     }
   };
 };
@@ -5523,6 +5478,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;
@@ -6992,6 +6960,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) {
@@ -7012,6 +7084,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,
@@ -7019,6 +7092,7 @@ var createVoiceSession = (options) => {
         control: liveOpsControl,
         injectedInstruction
       } : undefined,
+      onTextDelta: ttsStreamer?.push,
       session,
       turn
     });
@@ -7038,7 +7112,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, {
@@ -7443,7 +7538,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,
@@ -12743,8 +12838,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));
@@ -13266,7 +13376,7 @@ var createFakeSTTAdapter = (inputSpy, sttDelayMs) => ({
       final: new Set,
       partial: new Set
     };
-    let delivered = false;
+    let sendCount = 0;
     return {
       close: async () => {
         for (const handler of listeners.close) {
@@ -13281,31 +13391,44 @@ var createFakeSTTAdapter = (inputSpy, sttDelayMs) => ({
       },
       send: async (audio) => {
         inputSpy.push(toUint8Array2(audio));
-        if (delivered) {
+        sendCount += 1;
+        if (sendCount === 1) {
+          if (sttDelayMs > 0) {
+            await Bun.sleep(sttDelayMs);
+          }
+          const receivedAt = Date.now();
+          for (const handler of listeners.final) {
+            handler({
+              receivedAt,
+              transcript: {
+                id: "telephony-benchmark-final",
+                isFinal: true,
+                text: "hello from twilio"
+              },
+              type: "final"
+            });
+          }
+          for (const handler of listeners.endOfTurn) {
+            handler({
+              reason: "vendor",
+              receivedAt,
+              type: "endOfTurn"
+            });
+          }
           return;
         }
-        delivered = true;
-        if (sttDelayMs > 0) {
-          await Bun.sleep(sttDelayMs);
-        }
-        const receivedAt = Date.now();
-        for (const handler of listeners.final) {
-          handler({
-            receivedAt,
-            transcript: {
-              id: "telephony-benchmark-final",
-              isFinal: true,
-              text: "hello from twilio"
-            },
-            type: "final"
-          });
-        }
-        for (const handler of listeners.endOfTurn) {
-          handler({
-            reason: "vendor",
-            receivedAt,
-            type: "endOfTurn"
-          });
+        if (sendCount === 2) {
+          for (const handler of listeners.partial) {
+            handler({
+              receivedAt: Date.now(),
+              transcript: {
+                id: "telephony-benchmark-partial",
+                isFinal: false,
+                text: "actually wait"
+              },
+              type: "partial"
+            });
+          }
         }
       }
     };