@runtypelabs/persona 4.27.0 → 4.28.0

package/src/voice/runtype-voice-provider.ts

@@ -64,7 +64,25 @@
 // agent as conversation; a user bubble becomes conversation only when it is
 // submitted. With `context` negotiated, one `context{text}` frame (chat history
 // as of call start plus the host's `callContext`) is held until the visitor's
-// first final transcript or first delegation.
+// first final transcript or first delegation; a delegation's frames (deltas
+// and result) wait for it (up to 2 s, then it is dropped).
+//
+// Streaming (`delegation_stream` and `delegation_read_back` both negotiated,
+// with client delegation; the read-back tags are what keep a streamed answer
+// spoken as several utterances folded): while a
+// delegated turn renders, its assistant answer goes out as ordered
+// `delegation_delta{delegationId, text}` pieces (clause-sized, see
+// voice-clause-buffer.ts; approval cards, tool bubbles and captions never
+// stream), all before the delegation's first `delegation_update` or
+// `delegation_result`. That frame then carries `streamedChars`: how many
+// leading characters of its `text` the deltas already sent (an approval
+// script appended after the answer is the unstreamed rest). Absent or 0: none.
+// The server reports each spoken chunk with `delegation_progress{delegationId,
+// text}`; the first one of a spoken phase folds the read-back as
+// `delegation_completed{speak:true}` does (status stays "processing" until
+// completed), and that phase's completion doesn't fold another utterance.
+// Delegated sends carry `voice: { spoken: true }` on the chat request, so the
+// agent answers in speakable sentences.
 
 import type {
   VoiceProvider,
@@ -299,8 +317,13 @@ export class RuntypeVoiceProvider implements VoiceProvider {
   // The released context's send; settles once it went out (or never will).
   #contextSend: { done: Promise<void>; drop: () => void } | null = null;
   #delegations: Promise<void> = Promise.resolve();
-  // Delegations answered ok: their spoken read-back is folded.
+  // Delegations answered ok (or that streamed part of their answer): their
+  // spoken read-back is folded.
   #answered = new Set<string>();
+  // Delegations whose current spoken phase already folded on `delegation_progress`.
+  #progressed = new Set<string>();
+  // The delegation whose read-back `#foldReadback` is waiting for.
+  #foldArmedBy: string | null = null;
   #foldReadback = false;
   #assistantTurns = new Set<string>();
   #foldedTurns = new Set<string>();
@@ -473,7 +496,7 @@ export class RuntypeVoiceProvider implements VoiceProvider {
   #voiceSocketUrl(host: string, agentId: string, attach?: URLSearchParams): string {
     const capabilities = ["partial_transcript", "context"];
     if (this.bridge && this.config?.clientDelegation !== false)
-      capabilities.push("client_delegation", "delegation_update", "delegation_read_back");
+      capabilities.push("client_delegation", "delegation_update", "delegation_read_back", "delegation_stream");
     if (attach) capabilities.unshift("attach");
     const params = new URLSearchParams({
       voiceProtocol: VOICE_PROTOCOL,
@@ -849,6 +872,13 @@ export class RuntypeVoiceProvider implements VoiceProvider {
             const tag = msg.delegationId;
             if (typeof tag === "string" && this.#answered.has(tag) && !this.#assistantTurns.has(turnId)) {
               this.#foldedTurns.add(turnId);
+              this.#foldReadback = false;
+            } else if (this.#foldReadback && !this.#assistantTurns.has(turnId)) {
+              // Armed by `delegation_progress`: the server may leave the
+              // read-back untagged (it continued a filler it cut), so the
+              // first new utterance after it is the read-back.
+              this.#foldedTurns.add(turnId);
+              this.#foldReadback = false;
             }
           } else if (this.#foldReadback && !this.#assistantTurns.has(turnId)) {
             this.#foldedTurns.add(turnId);
@@ -891,8 +921,13 @@ export class RuntypeVoiceProvider implements VoiceProvider {
         } else if (msg.speak !== false && this.#answered.has(delegationId)) {
           // Every spoken phase (the approval ask, the late result) of an answer
           // the chat shows is read back. A refusal of one that never started
-          // here has no chat answer: it renders. `final` may never come.
-          this.#foldReadback = true;
+          // here has no chat answer: it renders. `final` may never come. A
+          // phase whose first `delegation_progress` already armed the fold
+          // ends here without arming it again. With `delegation_read_back`
+          // the tag marks the read-back, so completion arms nothing (only
+          // progress does, for a read-back the server left untagged).
+          if (!this.#progressed.delete(delegationId) && !this.#capabilities.has("delegation_read_back"))
+            this.#armFold(delegationId);
         }
         this.#delegating = msg.type === "delegation_started";
         if (!this.#isSpeaking && !this.#isCancelling()) {
@@ -901,6 +936,23 @@ export class RuntypeVoiceProvider implements VoiceProvider {
         break;
       }
 
+      case "delegation_progress": {
+        // The server handed a spoken chunk of this delegation to the voice
+        // model: its read-back is starting. The first one of a phase folds it,
+        // as `delegation_completed{speak:true}` does; later ones (and that
+        // phase's completion) don't fold another utterance. Still delegating.
+        const delegationId = String(msg.delegationId);
+        if (
+          this.#answered.has(delegationId) &&
+          !this.#progressed.has(delegationId) &&
+          !this.#cancelledDelegations.has(delegationId)
+        ) {
+          this.#progressed.add(delegationId);
+          this.#armFold(delegationId);
+        }
+        break;
+      }
+
       case "delegation_cancelled":
         // The server gave up on it: no more frames for it, and its approval
         // timers stop. The chat turn still renders. Past its deadline (or for
@@ -1021,9 +1073,19 @@ export class RuntypeVoiceProvider implements VoiceProvider {
     if (timedOut) send.drop();
   }
 
+  /** The next new assistant utterance is this delegation's read-back: fold it. */
+  #armFold(delegationId: string): void {
+    this.#foldReadback = true;
+    this.#foldArmedBy = delegationId;
+  }
+
   /** No more frames for this delegation; its chat answer goes back to browser TTS. */
   #dropDelegation(delegationId: string, expired = false): void {
     this.#cancelledDelegations.add(delegationId);
+    // A fold it armed whose read-back never started would hide the next
+    // unrelated utterance: disarm it.
+    if (this.#foldArmedBy === delegationId) this.#foldReadback = false;
+    this.#progressed.delete(delegationId);
     this.bridge?.dropDelegation?.(delegationId, expired);
     this.#followUps.get(delegationId)?.abort();
   }
@@ -1032,28 +1094,46 @@ export class RuntypeVoiceProvider implements VoiceProvider {
   #runDelegation(delegationId: string, request: VoiceDelegationRequest, generation: number): void {
     const bridge = this.bridge!;
     /** Send a frame for this delegation, unless the call or the delegation ended. */
-    const send = (type: "delegation_update" | "delegation_result", status: string, text: string) => {
+    const send = ({ type, ...fields }: Record<string, unknown> & { type: string }) => {
       const ws = this.#ws;
       if (generation !== this.#callGeneration || ws?.readyState !== WebSocket.OPEN) return false;
       if (this.#cancelledDelegations.has(delegationId)) return false;
-      ws.send(JSON.stringify({ type, delegationId, status, text }));
+      ws.send(JSON.stringify({ type, delegationId, ...fields }));
       return true;
     };
+    const answer = (type: "delegation_update" | "delegation_result", status: string, text: string, streamedChars = 0) =>
+      send({ type, status, text, ...(streamedChars > 0 && { streamedChars }) });
     this.#delegations = this.#delegations.then(async () => {
       // Cancelled while queued behind another turn: never start it.
       if (generation !== this.#callGeneration || this.#cancelledDelegations.has(delegationId)) return;
+      // Streaming (`delegation_stream`): the answer goes out as
+      // `delegation_delta` pieces while the chat renders it, after the call
+      // context, and all of them before the result.
+      let deltas: Promise<void> | null = null;
+      // Only with read-back tags: a streamed answer can be spoken as several
+      // utterances, and the tags are what keep all of them folded.
+      const streaming = this.#capabilities.has("delegation_stream") && this.#capabilities.has("delegation_read_back");
+      const stream = (text: string) => {
+        deltas = (deltas ?? this.#awaitContextSend()).then(() => {
+          // The chat shows what was streamed: its read-back is folded.
+          if (send({ type: "delegation_delta", text })) this.#answered.add(delegationId);
+        });
+      };
       const result: VoiceDelegationResult = await bridge
-        .runDelegatedTurn(request)
+        .runDelegatedTurn(streaming ? { ...request, stream } : request)
         .catch(() => ({ status: "failed", text: "" }));
       await this.#awaitContextSend();
+      await deltas;
+      const streamedChars = streaming ? (result.streamedChars ?? 0) : 0;
       // Parked on an approval: ask now (non-terminal), answer once the visitor
       // decides. A server that can't take an update gets the ask as the result.
       const parked = !!result.followUp;
       const update = parked && this.#capabilities.has("delegation_update");
-      const sent = send(
+      const sent = answer(
         update ? "delegation_update" : "delegation_result",
         parked && !update ? "completed" : result.status,
         result.text,
+        streamedChars,
       );
       if (!sent) return;
       if (result.status !== "failed" && result.inChat !== false) this.#answered.add(delegationId);
@@ -1068,12 +1148,12 @@ export class RuntypeVoiceProvider implements VoiceProvider {
           approvalTimeoutMs: this.config?.approvalTimeoutMs && Math.min(this.config.approvalTimeoutMs, APPROVAL_TIMEOUT_MAX_MS),
           readBack: update,
           // Another gated tool in the same turn: another (non-terminal) update.
-          onUpdate: (text) => send("delegation_update", "pending_approval", text),
+          onUpdate: (text) => answer("delegation_update", "pending_approval", text),
         })
         .then((followUp) => {
           this.#followUps.delete(delegationId);
           // Hang-up and cancellation send nothing.
-          if (update && followUp && !abort.signal.aborted) send("delegation_result", followUp.status, followUp.text);
+          if (update && followUp && !abort.signal.aborted) answer("delegation_result", followUp.status, followUp.text);
         });
     });
   }
@@ -1170,6 +1250,8 @@ export class RuntypeVoiceProvider implements VoiceProvider {
     this.#contextSend = null;
     this.#delegations = Promise.resolve();
     this.#answered.clear();
+    this.#progressed.clear();
+    this.#foldArmedBy = null;
     this.#foldReadback = false;
     this.#assistantTurns.clear();
     this.#foldedTurns.clear();

package/src/voice/voice-clause-buffer.test.ts

@@ -0,0 +1,143 @@
+import { describe, expect, it } from "vitest";
+import { CLAUSE_MAX_CHARS, ClauseBuffer } from "./voice-clause-buffer";
+
+/** Push `chunks` one by one, then flush; returns every piece in order. */
+function run(chunks: string[]): string[] {
+  const buffer = new ClauseBuffer();
+  const pieces = chunks.flatMap((chunk) => buffer.push(chunk));
+  return [...pieces, ...buffer.flush()];
+}
+
+/** Push character by character (the worst case for boundary detection). */
+const byChar = (text: string) => run([...text]);
+
+describe("ClauseBuffer", () => {
+  it("emits the first piece at a clause mark, then whole sentences", () => {
+    expect(byChar("Sure, we open at eight. On Sundays we are closed. Anything else?")).toEqual([
+      "Sure, ",
+      "we open at eight. ",
+      "On Sundays we are closed. ",
+      "Anything else?",
+    ]);
+  });
+
+  it("does not split later pieces at clause marks", () => {
+    expect(byChar("Yes. Monday, Tuesday, and Friday work; Sunday doesn't. Done")).toEqual([
+      "Yes. ",
+      "Monday, Tuesday, and Friday work; Sunday doesn't. ",
+      "Done",
+    ]);
+  });
+
+  it("emits the first piece after ~30 characters or 6 words without punctuation", () => {
+    const buffer = new ClauseBuffer();
+    expect(buffer.push("We bake sourdough rye ")).toEqual([]);
+    expect(buffer.push("and a seeded loaf every")).toEqual(["We bake sourdough rye and a seeded loaf "]);
+    expect(buffer.push(" morning")).toEqual([]);
+    expect(buffer.flush()).toEqual(["every morning"]);
+
+    const words = new ClauseBuffer();
+    expect(words.push("a b c d e f ")).toEqual(["a b c d e f "]);
+  });
+
+  it("keeps a whole first sentence together when it arrives before its trailing space", () => {
+    const buffer = new ClauseBuffer();
+    expect(buffer.push("I can place that order for you.")).toEqual([]);
+    expect(buffer.flush()).toEqual(["I can place that order for you."]);
+    expect(run(["I can place that order for you.", " Shall I?"])).toEqual(["I can place that order for you. ", "Shall I?"]);
+  });
+
+  it("keeps abbreviations, initials, decimals and list numbers inside a sentence", () => {
+    expect(
+      byChar("Hi there. Dr. Smith and J. R. Lee arrive at 9 a.m. today, e.g. for 3.5 hours. Then we close."),
+    ).toEqual(["Hi there. ", "Dr. Smith and J. R. Lee arrive at 9 a.m. today, e.g. for 3.5 hours. ", "Then we close."]);
+    expect(byChar("Steps:\n1. Mix the flour.\n2. Bake it.")).toEqual([
+      "Steps:\n",
+      "1. Mix the flour.\n",
+      "2. Bake it.",
+    ]);
+    expect(byChar("Please call 911. It is urgent.")).toEqual(["Please call 911. ", "It is urgent."]);
+  });
+
+  it("treats line breaks (Markdown blocks and list items) as boundaries", () => {
+    expect(byChar("**Opening hours**\n\n- Monday to Friday: 8am to 6pm\n- Sunday: closed")).toEqual([
+      "**Opening hours**\n\n",
+      "- Monday to Friday: 8am to 6pm\n",
+      "- Sunday: closed",
+    ]);
+  });
+
+  it("keeps closing quotes and emphasis with their sentence", () => {
+    expect(byChar('He said "go." Then **we left.** Fine')).toEqual(['He said "go." ', "Then **we left.** ", "Fine"]);
+    expect(byChar("Really?! Yes")).toEqual(["Really?! ", "Yes"]);
+  });
+
+  it("waits for whitespace after a period before cutting", () => {
+    const buffer = new ClauseBuffer();
+    expect(buffer.push("It costs 3.")).toEqual([]);
+    expect(buffer.push("50 dollars. And")).toEqual(["It costs 3.50 dollars. "]);
+  });
+
+  it("caps pieces at the max length, cutting at a clause mark, then a word, then hard", () => {
+    const clauses = `${"word ".repeat(30)}and then, ${"more ".repeat(30)}end.`;
+    const buffer = new ClauseBuffer();
+    expect(buffer.push("Hi. ")).toEqual([]); // the whitespace may still grow
+    const [hi, ...pieces] = [...buffer.push(clauses), ...buffer.flush()];
+    expect(hi).toBe("Hi. ");
+    expect(pieces.every((p) => p.length <= CLAUSE_MAX_CHARS)).toBe(true);
+    expect(pieces[0]).toMatch(/and then, $/);
+    expect(pieces.join("")).toBe(clauses);
+
+    const words = run(["Ok. ", "abcd ".repeat(100)]);
+    expect(words.slice(1).every((p) => p.length <= CLAUSE_MAX_CHARS && /\s$/.test(p))).toBe(true);
+
+    const solid = run(["x".repeat(500)]);
+    expect(solid.map((p) => p.length)).toEqual([CLAUSE_MAX_CHARS, CLAUSE_MAX_CHARS, 60]);
+  });
+
+  it("never cuts inside a surrogate pair", () => {
+    const text = `${"x".repeat(CLAUSE_MAX_CHARS - 1)}😀${"y".repeat(10)}`;
+    const pieces = run([text]);
+    expect(pieces.join("")).toBe(text);
+    expect(pieces[0]).toBe("x".repeat(CLAUSE_MAX_CHARS - 1));
+  });
+
+  it("pieces always concatenate to the input, however it is chunked", () => {
+    const text =
+      "**Opening hours**\n\n- Monday to Friday: 8am to 6pm\n- Saturday: 9am to 4pm\n\nWe're on Main St. near the U.S. post office, e.g. by the park. Call us!  ";
+    for (const size of [1, 2, 3, 7, 13, 40, text.length]) {
+      const chunks: string[] = [];
+      for (let i = 0; i < text.length; i += size) chunks.push(text.slice(i, i + size));
+      const pieces = run(chunks);
+      const joined = pieces.join("");
+      expect(text.startsWith(joined)).toBe(true);
+      expect(joined.trimEnd()).toBe(text.trimEnd());
+      expect(pieces.every((p) => p.trim().length > 0 && p.length <= CLAUSE_MAX_CHARS)).toBe(true);
+    }
+  });
+
+  it("idle() releases held text that ends in a terminator, and nothing else", () => {
+    const buffer = new ClauseBuffer();
+    expect(buffer.push("We're open Monday to Friday from 8am to 6pm.")).toEqual([]);
+    expect(buffer.idle()).toEqual(["We're open Monday to Friday from 8am to 6pm."]);
+    expect(buffer.idle()).toEqual([]);
+    expect(buffer.push(" On Saturdays we open")).toEqual([]);
+    expect(buffer.idle()).toEqual([]); // no terminator: keep waiting
+    expect(buffer.push(" at 9 a.m.")).toEqual([]);
+    expect(buffer.idle()).toEqual([" On Saturdays we open at 9 a.m."]); // no guards on a pause
+    for (const ending of ["Really?!", 'He said "go."', "**Done.**", "Wait…", "Line\n"]) {
+      const b = new ClauseBuffer();
+      b.push(ending);
+      expect(b.idle()).toEqual([ending]);
+    }
+  });
+
+  it("emits nothing for whitespace only, and flush empties the buffer", () => {
+    const buffer = new ClauseBuffer();
+    expect(buffer.push("   ")).toEqual([]);
+    expect(buffer.flush()).toEqual([]);
+    expect(buffer.push("Hello")).toEqual([]);
+    expect(buffer.flush()).toEqual(["Hello"]);
+    expect(buffer.flush()).toEqual([]);
+  });
+});

package/src/voice/voice-clause-buffer.ts

@@ -0,0 +1,187 @@
+/**
+ * Groups a growing answer into speakable pieces for `delegation_delta`
+ * (streaming client delegation): the first piece goes out early (at a clause
+ * mark, or once ~30 characters / 6 words are in), later pieces at sentence ends
+ * or line breaks, and no piece is longer than {@link CLAUSE_MAX_CHARS}.
+ *
+ * Pieces are exact slices of the input: concatenated, they equal everything
+ * pushed so far (whitespace included), so a receiver can count them as a
+ * prefix of the final text.
+ */
+
+/** The longest piece. */
+export const CLAUSE_MAX_CHARS = 220;
+const FIRST_MIN_CHARS = 30;
+const FIRST_MIN_WORDS = 6;
+
+/** Words ending in "." that rarely end a sentence (lowercased, inner dots kept). */
+const ABBREVIATIONS = new Set([
+  "mr",
+  "mrs",
+  "ms",
+  "dr",
+  "prof",
+  "sr",
+  "jr",
+  "st",
+  "mt",
+  "vs",
+  "etc",
+  "approx",
+  "inc",
+  "ltd",
+  "co",
+  "corp",
+  "no",
+  "nos",
+  "fig",
+  "ft",
+  "dept",
+  "est",
+  "min",
+  "max",
+  "e.g",
+  "i.e",
+  "a.m",
+  "p.m",
+  "u.s",
+  "u.k",
+]);
+
+// Punctuation (then closers like quotes, brackets or Markdown emphasis) and the
+// whitespace after it, or a line break.
+const BOUNDARY = /([.!?]+|[,;:])(["'”’)\]*_]*)(\s+)|\n\s*/g;
+
+/** Whether the "." ending `before` belongs to an abbreviation, an initial, or a list number. */
+function dotIsNotSentenceEnd(before: string): boolean {
+  const token = /(\S+)$/.exec(before)?.[1];
+  if (!token) return false;
+  const word = token.replace(/^[("'“‘[*_]+/, "").toLowerCase();
+  if (ABBREVIATIONS.has(word)) return true;
+  // An initial ("J.") or a dotted abbreviation ("U.S", "e.g").
+  if (/^[a-z](?:\.[a-z])*$/.test(word)) return true;
+  // "1. " opening a line is a list marker, not a sentence.
+  if (/^\d+$/.test(token)) {
+    const start = before.length - token.length;
+    return start === 0 || /\n\s*$/.test(before.slice(0, start));
+  }
+  return false;
+}
+
+/**
+ * Ends (after the whitespace) of each boundary in `text` with content before
+ * it. A boundary whose whitespace reaches the end of `text` may still grow
+ * ("\n" then "\n- item"), so it counts only once more text follows.
+ */
+function* boundaryEnds(text: string, clauses: boolean): Generator<number> {
+  const re = new RegExp(BOUNDARY.source, "g");
+  for (let m = re.exec(text); m; m = re.exec(text)) {
+    const mark = m[1];
+    if (!text.slice(0, m.index + (mark?.length ?? 0)).trim()) continue;
+    if (mark !== undefined) {
+      if (/^[,;:]$/.test(mark) && !clauses) continue;
+      if (mark === "." && dotIsNotSentenceEnd(text.slice(0, m.index))) continue;
+    }
+    const end = m.index + m[0].length;
+    if (end < text.length) yield end;
+  }
+}
+
+/** End of the last whitespace run within `limit` that has content before it, or 0. */
+function lastWordEnd(text: string, limit: number): number {
+  const window = text.slice(0, limit);
+  let best = 0;
+  for (const m of window.matchAll(/\s+/g)) {
+    if (window.slice(0, m.index).trim()) best = m.index! + m[0].length;
+  }
+  return best;
+}
+
+/** Where to cut a piece that reached {@link CLAUSE_MAX_CHARS} with no sentence end. */
+function overflowCut(text: string): number {
+  let clause = 0;
+  for (const end of boundaryEnds(text.slice(0, CLAUSE_MAX_CHARS), true)) clause = end;
+  if (clause) return clause;
+  const word = lastWordEnd(text, CLAUSE_MAX_CHARS);
+  if (word) return word;
+  // One unbroken run: cut hard, never inside a surrogate pair.
+  const code = text.charCodeAt(CLAUSE_MAX_CHARS - 1);
+  return code >= 0xd800 && code <= 0xdbff ? CLAUSE_MAX_CHARS - 1 : CLAUSE_MAX_CHARS;
+}
+
+export class ClauseBuffer {
+  #pending = "";
+  #first = true;
+
+  /** Add text; returns the pieces now complete (possibly none). */
+  push(text: string): string[] {
+    this.#pending += text;
+    return this.#drain();
+  }
+
+  /** Everything still held, as the last pieces (whitespace-only remainder is dropped). */
+  flush(): string[] {
+    const pieces = this.#drain();
+    const rest = this.#pending;
+    this.#pending = "";
+    if (rest.trim()) {
+      for (let at = 0; at < rest.length; ) {
+        const tail = rest.slice(at);
+        const cut = tail.length > CLAUSE_MAX_CHARS ? overflowCut(tail) : tail.length;
+        pieces.push(tail.slice(0, cut));
+        at += cut;
+      }
+      this.#first = false;
+    }
+    return pieces;
+  }
+
+  /**
+   * The stream went quiet: if the held text ends in a sentence terminator
+   * (`. ! ? …`, closers allowed) or a line break, release it as if the
+   * boundary were confirmed. No abbreviation guards: a pause is enough.
+   */
+  idle(): string[] {
+    const text = this.#pending;
+    if (!text.trim() || !/(?:[.!?…]["'”’)\]*_]*|\n)\s*$/.test(text)) return [];
+    this.#pending = "";
+    this.#first = false;
+    const pieces: string[] = [];
+    for (let at = 0; at < text.length; ) {
+      const tail = text.slice(at);
+      const cut = tail.length > CLAUSE_MAX_CHARS ? overflowCut(tail) : tail.length;
+      pieces.push(tail.slice(0, cut));
+      at += cut;
+    }
+    return pieces;
+  }
+
+  #drain(): string[] {
+    const pieces: string[] = [];
+    for (let cut = this.#cut(); cut > 0; cut = this.#cut()) {
+      pieces.push(this.#pending.slice(0, cut));
+      this.#pending = this.#pending.slice(cut);
+      this.#first = false;
+    }
+    return pieces;
+  }
+
+  /** Length of the next complete piece, or 0 to keep waiting. */
+  #cut(): number {
+    const text = this.#pending;
+    if (!text.trim()) return 0;
+    const end = boundaryEnds(text, this.#first).next().value ?? 0;
+    if (end && end <= CLAUSE_MAX_CHARS) return end;
+    // Ending on sentence punctuation, the text is most likely a whole sentence
+    // waiting for the space that confirms it: don't split it early.
+    const atSentenceEnd = /[.!?]["'”’)\]*_]*$/.test(text);
+    if (this.#first && !atSentenceEnd) {
+      const words = text.match(/\S+\s+/g)?.length ?? 0;
+      if (text.trim().length >= FIRST_MIN_CHARS || words >= FIRST_MIN_WORDS) {
+        const word = lastWordEnd(text, CLAUSE_MAX_CHARS);
+        if (word) return word;
+      }
+    }
+    return text.length > CLAUSE_MAX_CHARS ? overflowCut(text) : 0;
+  }
+}

package/src/voice/voice-delegation.ts

@@ -7,11 +7,32 @@ import type {
   VoiceSessionBridge,
 } from "../types";
 
+import { ClauseBuffer } from "./voice-clause-buffer";
+
 /**
  * What a delegated turn streamed: its assistant messages, whether it failed,
  * and whether the server dropped its result (then browser TTS may read it).
+ * `onUpdate` runs after each of its assistant messages is stored (the answer
+ * grew), so a streaming bridge can read the new text.
  */
-export type VoiceDelegationCapture = { ids: string[]; failed: boolean; dropped?: boolean };
+export type VoiceDelegationCapture = {
+  ids: string[];
+  failed: boolean;
+  dropped?: boolean;
+  onUpdate?: () => void;
+  /** Stops a streaming answer (its pending idle flush included); set while it streams. */
+  stopStream?: () => void;
+};
+
+/** How long a held sentence end waits for more text before it streams anyway. */
+const STREAM_IDLE_MS = 200;
+
+/** Length of the common prefix of `a` and `b`. */
+const commonPrefix = (a: string, b: string) => {
+  let i = 0;
+  while (i < a.length && i < b.length && a[i] === b[i]) i += 1;
+  return i;
+};
 
 /** The session internals the delegation bridge drives. */
 export interface VoiceDelegationHost {
@@ -199,6 +220,7 @@ export function createVoiceSessionBridge(host: VoiceDelegationHost): VoiceSessio
       const park = expired && parks.find((p) => p.delegationId === delegationId);
       if (park && !park.outcome) settle(park, "timeout", "");
       for (const capture of captures.get(delegationId) ?? []) {
+        capture.stopStream?.();
         capture.dropped = true;
         if (capture.ids.length) host.unspoken(capture.ids);
       }
@@ -208,6 +230,7 @@ export function createVoiceSessionBridge(host: VoiceDelegationHost): VoiceSessio
       delegationId,
       userText,
       userUtteranceIds,
+      stream,
     }: VoiceDelegationRequest): Promise<VoiceDelegationResult> {
       const live = parks.filter((park) => pendingOf(park).length);
       const pendingIds = live.flatMap(pendingOf);
@@ -228,6 +251,48 @@ export function createVoiceSessionBridge(host: VoiceDelegationHost): VoiceSessio
       const before = new Set(host.messages().map((m) => m.id));
       const raised = () => host.messages().filter((m) => !before.has(m.id) && m.variant === "approval");
       const capture: VoiceDelegationCapture = { ids: [], failed: false };
+      // Streaming (`delegation_stream`): the answer goes out in speakable
+      // pieces while it renders. `fed` is the answer text the buffer has seen,
+      // `sent` what went out. An answer rewritten mid-stream (not an extension
+      // of what was fed) stops the stream; the result then says how much of
+      // its text was already sent.
+      const buffer = stream ? new ClauseBuffer() : null;
+      let fed = "";
+      let sent = "";
+      let rewritten = false;
+      const emit = (pieces: string[]) => {
+        for (const piece of pieces) {
+          sent += piece;
+          stream!(piece);
+        }
+      };
+      // A sentence end is confirmed only by the text after it; when the
+      // stream pauses on one, it goes out after STREAM_IDLE_MS anyway.
+      let idleTimer: ReturnType<typeof setTimeout> | undefined;
+      if (buffer) {
+        capture.onUpdate = () => {
+          if (rewritten) return;
+          const now = answerOf(capture.ids);
+          if (!now.startsWith(fed)) {
+            rewritten = true;
+            clearTimeout(idleTimer);
+            return;
+          }
+          if (now.length === fed.length) return;
+          const delta = now.slice(fed.length);
+          fed = now;
+          emit(buffer.push(delta));
+          clearTimeout(idleTimer);
+          idleTimer = setTimeout(() => {
+            if (!rewritten) emit(buffer.idle());
+          }, STREAM_IDLE_MS);
+        };
+        capture.stopStream = () => {
+          clearTimeout(idleTimer);
+          rewritten = true; // nothing more streams
+          capture.onUpdate = undefined;
+        };
+      }
       remember(delegationId, capture);
       active = capture;
       retrack();
@@ -241,6 +306,19 @@ export function createVoiceSessionBridge(host: VoiceDelegationHost): VoiceSessio
         active = null;
         retrack();
       }
+      if (buffer) {
+        // The last of the answer goes out before the result.
+        capture.onUpdate?.();
+        clearTimeout(idleTimer);
+        if (!rewritten) emit(buffer.flush());
+        capture.onUpdate = undefined;
+        capture.stopStream = undefined;
+      }
+      /** `streamedChars` for a result whose `text` starts with the answer. */
+      const streamed = (text: string) => {
+        const chars = commonPrefix(sent, text);
+        return chars > 0 ? { streamedChars: chars } : {};
+      };
       const replies = capture.ids.flatMap((id) => host.messages().find((m) => m.id === id) ?? []);
       let text = answerOf(capture.ids);
       const pending = capture.failed ? [] : raised().filter(isPendingApproval);
@@ -272,10 +350,13 @@ export function createVoiceSessionBridge(host: VoiceDelegationHost): VoiceSessio
         if (cancelled.get(delegationId)) settle(park, "timeout", "");
         // Parked on approvals: answer now, so the voice model asks for the
         // decision, then read the outcome back once the visitor decides.
+        // The streamed answer stays the prefix; the approval script is the
+        // unstreamed suffix.
         text = `${text}\n\n${buildApprovalScript(pending.map((m) => m.approval!))}`.trim();
         return {
           status: "pending_approval",
           text,
+          ...streamed(text),
           followUp: async ({ signal, approvalTimeoutMs = APPROVAL_TTL_MS, readBack = true, onUpdate }) => {
             const follow: VoiceDelegationCapture = { ids: [], failed: false };
             // Called once the ask went out: it carried this turn's reply to the
@@ -372,9 +453,10 @@ export function createVoiceSessionBridge(host: VoiceDelegationHost): VoiceSessio
             !m.toolCall?.name?.startsWith("webmcp:"),
         )
       ) {
-        return { status: capture.failed ? "failed" : "completed", text: `${text}\n\n${WAITING_FOR_INPUT}`.trim() };
+        text = `${text}\n\n${WAITING_FOR_INPUT}`.trim();
+        return { status: capture.failed ? "failed" : "completed", text, ...streamed(text) };
       }
-      return { status: !capture.failed && text ? "completed" : "failed", text };
+      return { status: !capture.failed && text ? "completed" : "failed", text, ...streamed(text) };
     },
   };
 }