@runtypelabs/persona 4.22.0 → 4.23.0

package/src/utils/throughput-tracker.test.ts

@@ -40,9 +40,9 @@ describe("ThroughputTracker: live estimate", () => {
     const h = makeTracker();
 
     // First delta: lazily starts the run. Duration is 0 so no rate yet.
-    h.at(1000).processEvent("step_delta", {
-      type: "step_delta",
-      text: text(40),
+    h.at(1000).processEvent("text_delta", {
+      type: "text_delta",
+      delta: text(40),
     });
     let m = h.metric();
     expect(m.status).toBe("running");
@@ -51,7 +51,7 @@ describe("ThroughputTracker: live estimate", () => {
     expect(m.tokensPerSecond).toBeUndefined();
 
     // Second delta 1s later via a different visible event type.
-    h.at(2000).processEvent("chunk", { type: "chunk", text: text(40) });
+    h.at(2000).processEvent("text_delta", { type: "text_delta", delta: text(40) });
     m = h.metric();
     expect(m.outputTokens).toBe(20);
     expect(m.durationMs).toBe(1000);
@@ -59,17 +59,15 @@ describe("ThroughputTracker: live estimate", () => {
     expect(m.tokensPerSecond).toBeCloseTo(20);
   });
 
-  it("counts agent_turn_delta text deltas as visible output", () => {
+  it("counts text_delta text deltas as visible output", () => {
     const h = makeTracker();
-    h.at(0).processEvent("agent_turn_delta", {
-      type: "agent_turn_delta",
-      contentType: "text",
-      text: text(40),
+    h.at(0).processEvent("text_delta", {
+      type: "text_delta",
+      delta: text(40),
     });
-    h.at(1000).processEvent("agent_turn_delta", {
-      type: "agent_turn_delta",
-      contentType: "text",
-      text: text(40),
+    h.at(1000).processEvent("text_delta", {
+      type: "text_delta",
+      delta: text(40),
     });
     const m = h.metric();
     expect(m.status).toBe("running");
@@ -77,22 +75,11 @@ describe("ThroughputTracker: live estimate", () => {
     expect(m.tokensPerSecond).toBeCloseTo(20);
   });
 
-  it("ignores agent_turn_delta with a missing contentType (matches client)", () => {
+  it("ignores text_delta without a string delta", () => {
     const h = makeTracker();
-    // The client only renders agent text when contentType === "text"; a delta
-    // without a contentType is not visible output, so it must not be counted.
-    h.at(0).processEvent("agent_turn_delta", {
-      type: "agent_turn_delta",
-      text: text(400),
-    });
+    h.at(0).processEvent("text_delta", { type: "text_delta", text: text(400) });
     expect(h.metric().status).toBe("idle");
-
-    // An explicit text delta is still counted.
-    h.at(1000).processEvent("agent_turn_delta", {
-      type: "agent_turn_delta",
-      contentType: "text",
-      text: text(40),
-    });
+    h.at(1000).processEvent("text_delta", { type: "text_delta", delta: text(40) });
     expect(h.metric().outputTokens).toBe(10);
   });
 });
@@ -100,17 +87,16 @@ describe("ThroughputTracker: live estimate", () => {
 describe("ThroughputTracker: exact usage finalization", () => {
   it("prefers exact output tokens from the terminal event over the estimate", () => {
     const h = makeTracker();
-    h.at(1000).processEvent("step_delta", { type: "step_delta", text: text(40) });
-    h.at(2000).processEvent("agent_turn_delta", {
-      type: "agent_turn_delta",
-      contentType: "text",
-      text: text(40),
+    h.at(1000).processEvent("text_delta", { type: "text_delta", delta: text(40) });
+    h.at(2000).processEvent("text_delta", {
+      type: "text_delta",
+      delta: text(40),
     });
 
     // estimate so far would be 20 tokens; terminal usage overrides it.
-    h.at(2000).processEvent("flow_complete", {
-      type: "flow_complete",
-      usage: { outputTokens: 123 },
+    h.at(2000).processEvent("execution_complete", {
+      type: "execution_complete",
+      totalTokens: { input: 0, output: 123 },
     });
 
     const m = h.metric();
@@ -123,18 +109,18 @@ describe("ThroughputTracker: exact usage finalization", () => {
 
   it("accumulates exact usage from intermediate completes and uses it on terminal", () => {
     const h = makeTracker();
-    h.at(1000).processEvent("step_delta", { type: "step_delta", text: text(40) });
-    h.at(1500).processEvent("step_complete", {
-      type: "step_complete",
-      result: { tokens: { output: 50 } },
+    h.at(1000).processEvent("text_delta", { type: "text_delta", delta: text(40) });
+    h.at(1500).processEvent("turn_complete", {
+      type: "turn_complete",
+      tokens: { input: 0, output: 50 },
     });
-    h.at(2000).processEvent("agent_turn_complete", {
-      type: "agent_turn_complete",
-      usage: { outputTokens: 30 },
+    h.at(2000).processEvent("turn_complete", {
+      type: "turn_complete",
+      tokens: { input: 0, output: 30 },
     });
 
     // Terminal carries no usage of its own → fall back to accumulated 80.
-    h.at(2000).processEvent("agent_complete", { type: "agent_complete" });
+    h.at(2000).processEvent("execution_complete", { type: "execution_complete" });
 
     const m = h.metric();
     expect(m.status).toBe("complete");
@@ -144,12 +130,12 @@ describe("ThroughputTracker: exact usage finalization", () => {
 
   it("falls back to provider execution time when the streamed window is too short", () => {
     const h = makeTracker();
-    h.at(1000).processEvent("flow_start", { type: "flow_start" });
-    h.at(1100).processEvent("step_delta", { type: "step_delta", text: text(40) });
-    // streamed window = 50ms (< 250ms threshold) → use executionTime.
-    h.at(1150).processEvent("flow_complete", {
-      type: "flow_complete",
-      executionTime: 5000,
+    h.at(1000).processEvent("execution_start", { type: "execution_start" });
+    h.at(1100).processEvent("text_delta", { type: "text_delta", delta: text(40) });
+    // streamed window = 50ms (< 250ms threshold) → use durationMs.
+    h.at(1150).processEvent("execution_complete", {
+      type: "execution_complete",
+      durationMs: 5000,
     });
 
     const m = h.metric();
@@ -161,72 +147,22 @@ describe("ThroughputTracker: exact usage finalization", () => {
 });
 
 describe("ThroughputTracker: non-visible deltas ignored", () => {
-  it("ignores agent thinking and tool_input deltas", () => {
-    const h = makeTracker();
-
-    h.at(1000).processEvent("agent_turn_delta", {
-      type: "agent_turn_delta",
-      contentType: "thinking",
-      text: text(400),
-    });
-    expect(h.metric().status).toBe("idle");
-
-    h.at(1000).processEvent("agent_turn_delta", {
-      type: "agent_turn_delta",
-      contentType: "tool_input",
-      text: text(400),
-    });
-    expect(h.metric().status).toBe("idle");
-
-    // Only the visible text delta is counted.
-    h.at(1000).processEvent("agent_turn_delta", {
-      type: "agent_turn_delta",
-      contentType: "text",
-      text: text(40),
-    });
-    h.at(2000).processEvent("agent_turn_delta", {
-      type: "agent_turn_delta",
-      contentType: "thinking",
-      text: text(400),
-    });
-
-    const m = h.metric();
-    expect(m.status).toBe("running");
-    expect(m.outputTokens).toBe(10); // thinking text excluded
-  });
-
-  it("ignores tool and context step deltas", () => {
-    const h = makeTracker();
-
-    h.at(1000).processEvent("step_delta", {
-      type: "step_delta",
-      stepType: "tool",
-      text: text(400),
-    });
-    expect(h.metric().status).toBe("idle");
-
-    h.at(1000).processEvent("step_delta", {
-      type: "step_delta",
-      executionType: "context",
-      text: text(400),
-    });
-    expect(h.metric().status).toBe("idle");
-
-    // A prompt-step delta is counted.
-    h.at(1000).processEvent("step_delta", {
-      type: "step_delta",
-      stepType: "prompt",
-      text: text(40),
-    });
-    expect(h.metric().status).toBe("running");
-    expect(h.metric().outputTokens).toBe(10);
-  });
+  it.each(["reasoning_delta", "tool_input_delta", "tool_output_delta", "media_delta"])(
+    "does not count %s as visible text", (type) => {
+      const h = makeTracker();
+      h.at(1000).processEvent(type, { type, delta: text(400) });
+      expect(h.metric().status).toBe("idle");
+      h.at(1500).processEvent("text_delta", { type: "text_delta", delta: text(40) });
+      h.at(2000).processEvent(type, { type, delta: text(400) });
+      expect(h.metric().outputTokens).toBe(10);
+    }
+  );
 });
 
 describe("ThroughputTracker: intermediate completes do not finalize", () => {
-  it("keeps the run running across step_complete / agent_turn_complete", () => {
+  it("keeps the run running across step_complete / turn_complete", () => {
     const h = makeTracker();
-    h.at(1000).processEvent("step_delta", { type: "step_delta", text: text(40) });
+    h.at(1000).processEvent("text_delta", { type: "text_delta", delta: text(40) });
 
     h.at(1500).processEvent("step_complete", {
       type: "step_complete",
@@ -234,29 +170,29 @@ describe("ThroughputTracker: intermediate completes do not finalize", () => {
     });
     expect(h.metric().status).toBe("running");
 
-    h.at(1800).processEvent("agent_turn_complete", {
-      type: "agent_turn_complete",
-      usage: { outputTokens: 5 },
+    h.at(1800).processEvent("turn_complete", {
+      type: "turn_complete",
+      tokens: { input: 0, output: 5 },
     });
     expect(h.metric().status).toBe("running");
 
-    h.at(2000).processEvent("flow_complete", { type: "flow_complete" });
+    h.at(2000).processEvent("execution_complete", { type: "execution_complete" });
     expect(h.metric().status).toBe("complete");
   });
 });
 
 describe("ThroughputTracker: error handling", () => {
-  it.each(["step_error", "flow_error", "agent_error", "error"])(
+  it.each(["execution_error", "error"])(
     "marks the metric unavailable on %s",
     (errorType: string) => {
       const h = makeTracker();
-      h.at(1000).processEvent("step_delta", {
-        type: "step_delta",
-        text: text(40),
+      h.at(1000).processEvent("text_delta", {
+        type: "text_delta",
+        delta: text(40),
       });
       expect(h.metric().status).toBe("running");
 
-      h.at(1500).processEvent(errorType, { type: errorType });
+      h.at(1500).processEvent(errorType, { type: errorType, recoverable: false });
       expect(h.metric().status).toBe("error");
       expect(h.metric().tokensPerSecond).toBeUndefined();
     }
@@ -264,16 +200,26 @@ describe("ThroughputTracker: error handling", () => {
 
   it("treats a bare non-object error payload as an error", () => {
     const h = makeTracker();
-    h.at(1000).processEvent("step_delta", { type: "step_delta", text: text(40) });
-    h.at(1500).processEvent("error", "boom");
+    h.at(1000).processEvent("text_delta", { type: "text_delta", delta: text(40) });
+    h.at(1500).processEvent("execution_error", "boom");
     expect(h.metric().status).toBe("error");
   });
 
+  it.each([undefined, true])("keeps running after a recoverable error (%s)", (recoverable) => {
+    const h = makeTracker();
+    h.at(1000).processEvent("text_delta", { delta: text(40) });
+    h.at(1200).processEvent("error", { error: "Retrying", recoverable });
+    expect(h.metric().status).toBe("running");
+    h.at(1500).processEvent("text_delta", { delta: text(40) });
+    h.at(2000).processEvent("execution_complete", { totalTokens: { input: 0, output: 25 } });
+    expect(h.metric()).toMatchObject({ status: "complete", outputTokens: 25 });
+  });
+
   it("ignores terminal/error events when no run is active", () => {
     const h = makeTracker();
-    h.at(1000).processEvent("flow_complete", { type: "flow_complete" });
+    h.at(1000).processEvent("execution_complete", { type: "execution_complete" });
     expect(h.metric().status).toBe("idle");
-    h.at(1000).processEvent("flow_error", { type: "flow_error" });
+    h.at(1000).processEvent("execution_error", { type: "execution_error" });
     expect(h.metric().status).toBe("idle");
   });
 });
@@ -281,19 +227,19 @@ describe("ThroughputTracker: error handling", () => {
 describe("ThroughputTracker: reset & re-run", () => {
   it("reset() returns to idle", () => {
     const h = makeTracker();
-    h.at(1000).processEvent("step_delta", { type: "step_delta", text: text(40) });
+    h.at(1000).processEvent("text_delta", { type: "text_delta", delta: text(40) });
     h.tracker.reset();
     expect(h.metric()).toEqual({ status: "idle" });
   });
 
   it("starts a fresh run after a completed one", () => {
     const h = makeTracker();
-    h.at(1000).processEvent("step_delta", { type: "step_delta", text: text(80) });
-    h.at(2000).processEvent("flow_complete", { type: "flow_complete" });
+    h.at(1000).processEvent("text_delta", { type: "text_delta", delta: text(80) });
+    h.at(2000).processEvent("execution_complete", { type: "execution_complete" });
     expect(h.metric().status).toBe("complete");
 
     // New stream → accumulation resets, does not carry the prior 20 tokens.
-    h.at(3000).processEvent("step_delta", { type: "step_delta", text: text(40) });
+    h.at(3000).processEvent("text_delta", { type: "text_delta", delta: text(40) });
     const m = h.metric();
     expect(m.status).toBe("running");
     expect(m.outputTokens).toBe(10);
@@ -302,15 +248,15 @@ describe("ThroughputTracker: reset & re-run", () => {
   it("resets a stale run on the next request's start event (no bleed)", () => {
     const h = makeTracker();
     // First request streams visible output but never terminates (e.g. the
-    // user cancels mid-stream: no flow_complete / error frame is emitted).
-    h.at(1000).processEvent("step_delta", { type: "step_delta", text: text(120) });
+    // user cancels mid-stream: no execution_complete / error frame is emitted).
+    h.at(1000).processEvent("text_delta", { type: "text_delta", delta: text(120) });
     expect(h.metric().outputTokens).toBe(30);
     expect(h.metric().status).toBe("running");
 
-    // Next request begins. Its flow_start must discard the stale run so the
+    // Next request begins. Its execution_start must discard the stale run so the
     // prior request's 30 tokens don't bleed into this one.
-    h.at(5000).processEvent("flow_start", { type: "flow_start" });
-    h.at(5200).processEvent("step_delta", { type: "step_delta", text: text(40) });
+    h.at(5000).processEvent("execution_start", { type: "execution_start" });
+    h.at(5200).processEvent("text_delta", { type: "text_delta", delta: text(40) });
     const m = h.metric();
     expect(m.status).toBe("running");
     expect(m.outputTokens).toBe(10); // only the new request's text
@@ -318,12 +264,12 @@ describe("ThroughputTracker: reset & re-run", () => {
 
   it("does not reset between per-step starts within one request", () => {
     const h = makeTracker();
-    h.at(1000).processEvent("flow_start", { type: "flow_start" });
+    h.at(1000).processEvent("execution_start", { type: "execution_start" });
     h.at(1100).processEvent("step_start", { type: "step_start" });
-    h.at(1200).processEvent("step_delta", { type: "step_delta", text: text(40) });
+    h.at(1200).processEvent("text_delta", { type: "text_delta", delta: text(40) });
     // A second step within the same request must not restart accumulation.
     h.at(1300).processEvent("step_start", { type: "step_start" });
-    h.at(1400).processEvent("step_delta", { type: "step_delta", text: text(40) });
+    h.at(1400).processEvent("text_delta", { type: "text_delta", delta: text(40) });
     expect(h.metric().outputTokens).toBe(20);
   });
 });
@@ -331,12 +277,12 @@ describe("ThroughputTracker: reset & re-run", () => {
 describe("ThroughputTracker: exact usage never drops mid-run", () => {
   it("keeps exact tokens as a floor when later steps stream more text", () => {
     const h = makeTracker();
-    h.at(1000).processEvent("step_delta", { type: "step_delta", text: text(40) });
+    h.at(1000).processEvent("text_delta", { type: "text_delta", delta: text(40) });
 
     // Step 1 reports exact usage; the running total switches to it.
-    h.at(1500).processEvent("step_complete", {
-      type: "step_complete",
-      result: { tokens: { output: 50 } },
+    h.at(1500).processEvent("turn_complete", {
+      type: "turn_complete",
+      tokens: { input: 0, output: 50 },
     });
     let m = h.metric();
     expect(m.outputTokens).toBe(50);
@@ -344,7 +290,7 @@ describe("ThroughputTracker: exact usage never drops mid-run", () => {
 
     // Step 2 streams more visible text: the total must grow from 50, not
     // collapse back to a bare 10-token estimate of the new text.
-    h.at(2000).processEvent("step_delta", { type: "step_delta", text: text(40) });
+    h.at(2000).processEvent("text_delta", { type: "text_delta", delta: text(40) });
     m = h.metric();
     expect(m.outputTokens).toBe(60); // 50 exact + 10 estimated
     expect(m.source).toBe("usage");
@@ -354,7 +300,7 @@ describe("ThroughputTracker: exact usage never drops mid-run", () => {
 describe("ThroughputTracker: live rate decays while paused", () => {
   it("recomputes duration/tok-s from the clock between events", () => {
     const h = makeTracker();
-    h.at(1000).processEvent("step_delta", { type: "step_delta", text: text(400) });
+    h.at(1000).processEvent("text_delta", { type: "text_delta", delta: text(400) });
     // 100 tokens over a 1s window read at t=2000 → ~100 tok/s.
     h.at(2000);
     expect(h.metric().tokensPerSecond).toBeCloseTo(100);
@@ -364,3 +310,15 @@ describe("ThroughputTracker: live rate decays while paused", () => {
     expect(h.metric().tokensPerSecond).toBeCloseTo(25);
   });
 });
+
+
+it("does not mistake total token counts or user result data for output usage", () => {
+  const h = makeTracker();
+  h.at(1000).processEvent("text_delta", { type: "text_delta", delta: text(40) });
+  h.at(1500).processEvent("step_complete", {
+    type: "step_complete", tokensUsed: 900,
+    result: { tokens: { output: 500 }, usage: { outputTokens: 500 } },
+  });
+  h.at(2000).processEvent("execution_complete", { type: "execution_complete", totalTokensUsed: 900 });
+  expect(h.metric()).toMatchObject({ outputTokens: 10, source: "estimate" });
+});

package/src/utils/throughput-tracker.ts

@@ -12,7 +12,7 @@
 // then prefers exact provider usage (output tokens) when terminal events carry
 // it. A run starts when the stream starts (or lazily on the first visible
 // delta), stays "running" across intermediate step/turn completions, and only
-// finalizes on terminal `flow_complete` / `agent_complete`. Stream errors mark
+// finalizes on terminal `execution_complete`. Stream errors mark
 // the metric unavailable rather than leaving it stuck "running".
 
 export type ThroughputMetricStatus = "idle" | "running" | "complete" | "error";
@@ -47,47 +47,10 @@ interface ThroughputRunStats {
 // execution time or whole-request duration instead.
 const THROUGHPUT_MIN_DURATION_MS = 250;
 
-// Request-level lifecycle events: each marks the beginning of a NEW request.
-// The SSE tap fires for every payload type regardless of whether the client has
-// a handler for it, so any of these that the server emits starts the run with
-// an accurate `startedAt` (capturing time-to-first-token). These RESET any run
-// already in progress, so a prior stream that ended without a terminal/error
-// frame (e.g. `session.cancel()`) doesn't bleed its tokens into the next one.
-const REQUEST_START_EVENTS = new Set([
-  "flow_start",
-  "flow_run_start",
-  "agent_start",
-  "dispatch_start",
-  "run_start",
-]);
-
-// Per-step markers that fire repeatedly WITHIN a single request (a flow emits
-// one per step). These only lazily begin a run: they must never reset, or a
-// multi-step response would restart the metric between steps. If no request- or
-// step-start event is emitted, the first visible delta lazily starts the run.
-const STEP_START_EVENTS = new Set(["step_start", "execution_start"]);
-
-const VISIBLE_DELTA_EVENTS = new Set([
-  "step_delta",
-  "step_chunk",
-  "chunk",
-  "agent_turn_delta",
-]);
-
-const INTERMEDIATE_COMPLETE_EVENTS = new Set([
-  "step_complete",
-  "agent_turn_complete",
-]);
-
-const TERMINAL_COMPLETE_EVENTS = new Set(["flow_complete", "agent_complete"]);
-
-const ERROR_EVENTS = new Set([
-  "step_error",
-  "flow_error",
-  "agent_error",
-  "dispatch_error",
-  "error",
-]);
+// Execution starts reset a stale/cancelled run; step and turn starts only
+// lazily initialize it, since they can repeat within the same execution.
+const STEP_START_EVENTS = new Set(["step_start", "turn_start"]);
+const INTERMEDIATE_COMPLETE_EVENTS = new Set(["step_complete", "turn_complete"]);
 
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === "object" && value !== null && !Array.isArray(value);
@@ -134,91 +97,15 @@ function resolveEventType(
   return typeof payload.type === "string" ? payload.type : eventType;
 }
 
-function getTextDelta(payload: Record<string, unknown>): string {
-  if (typeof payload.text === "string") return payload.text;
-  if (typeof payload.delta === "string") return payload.delta;
-  if (typeof payload.content === "string") return payload.content;
-  if (typeof payload.chunk === "string") return payload.chunk;
-  return "";
-}
-
-/**
- * Only count visible model output.
- *
- * For `agent_turn_delta`, count only a contentType of exactly `text` as
- * visible, matching the client renderer (which appends streaming assistant
- * text only when `contentType === "text"`); `thinking`, `tool_input`, any
- * other value, and a missing contentType are ignored so throughput never
- * includes deltas the chat UI doesn't render.
- *
- * For `step_delta` / `step_chunk`, skip tool and context steps: those carry
- * tool I/O, not model-visible text: mirroring the widget's own renderer.
- */
-function isVisibleTextDelta(
-  type: string,
-  payload: Record<string, unknown>
-): boolean {
-  if (type === "step_delta" || type === "step_chunk") {
-    return payload.stepType !== "tool" && payload.executionType !== "context";
-  }
-
-  if (type !== "agent_turn_delta") return true;
-
-  const contentType =
-    typeof payload.contentType === "string"
-      ? payload.contentType
-      : typeof payload.content_type === "string"
-        ? payload.content_type
-        : undefined;
-
-  return contentType === "text";
-}
-
-/** Extract exact output tokens from a variety of usage payload shapes. */
+/** Exact output counts are carried by turn and execution completions. */
 function getOutputTokens(payload: Record<string, unknown>): number | undefined {
-  const result = getRecord(payload, "result");
-  const candidates = [
-    getRecord(payload, "tokens"),
-    getRecord(payload, "totalTokens"),
-    result ? getRecord(result, "tokens") : undefined,
-    getRecord(payload, "usage"),
-    result ? getRecord(result, "usage") : undefined,
-  ];
-
-  for (const candidate of candidates) {
-    if (!candidate) continue;
-    const outputTokens =
-      toFiniteNumber(candidate.output) ??
-      toFiniteNumber(candidate.outputTokens) ??
-      toFiniteNumber(candidate.completionTokens);
-    if (outputTokens !== undefined) return outputTokens;
-  }
-
-  return (
-    toFiniteNumber(payload.outputTokens) ??
-    toFiniteNumber(payload.completionTokens) ??
-    (result
-      ? (toFiniteNumber(result.outputTokens) ??
-        toFiniteNumber(result.completionTokens))
-      : undefined)
-  );
+  const tokens = getRecord(payload, "tokens") ?? getRecord(payload, "totalTokens");
+  return tokens ? toFiniteNumber(tokens.output) : undefined;
 }
 
-/** Extract provider execution time (ms) from a variety of payload shapes. */
-function getExecutionTimeMs(
-  payload: Record<string, unknown>
-): number | undefined {
-  const result = getRecord(payload, "result");
-  return (
-    toFiniteNumber(payload.executionTime) ??
-    toFiniteNumber(payload.executionTimeMs) ??
-    toFiniteNumber(payload.execution_time) ??
-    toFiniteNumber(payload.duration) ??
-    (result
-      ? (toFiniteNumber(result.executionTime) ??
-        toFiniteNumber(result.executionTimeMs))
-      : undefined)
-  );
+/** Current step/execution completions report elapsed milliseconds as durationMs. */
+function getExecutionTimeMs(payload: Record<string, unknown>): number | undefined {
+  return toFiniteNumber(payload.durationMs);
 }
 
 function defaultClock(): number {
@@ -286,8 +173,8 @@ export class ThroughputTracker {
 
   processEvent(eventType: string, payload: unknown): void {
     if (!isRecord(payload)) {
-      // Non-object payloads can still signal lifecycle (e.g. bare "error").
-      if (ERROR_EVENTS.has(eventType) && this.run) {
+      // Non-object payloads can still signal lifecycle (e.g. bare "execution_error").
+      if (eventType === "execution_error" && this.run) {
         this.run = null;
         this.metric = { status: "error" };
       }
@@ -297,7 +184,7 @@ export class ThroughputTracker {
     const type = resolveEventType(eventType, payload);
     const now = this.now();
 
-    if (REQUEST_START_EVENTS.has(type)) {
+    if (type === "execution_start") {
       // New request: start fresh, discarding any incomplete prior run.
       this.startRun(now);
       return;
@@ -309,9 +196,8 @@ export class ThroughputTracker {
       return;
     }
 
-    if (VISIBLE_DELTA_EVENTS.has(type)) {
-      if (!isVisibleTextDelta(type, payload)) return;
-      const text = getTextDelta(payload);
+    if (type === "text_delta") {
+      const text = typeof payload.delta === "string" ? payload.delta : "";
       if (!text) return;
 
       // Lazily start a run if the stream began without a recognized start event.
@@ -367,7 +253,7 @@ export class ThroughputTracker {
       return;
     }
 
-    if (TERMINAL_COMPLETE_EVENTS.has(type)) {
+    if (type === "execution_complete") {
       if (!this.run) return;
       const stats = this.run;
       // Prefer exact output tokens from this terminal event, else accumulated
@@ -396,7 +282,7 @@ export class ThroughputTracker {
       return;
     }
 
-    if (ERROR_EVENTS.has(type)) {
+    if (type === "execution_error" || (type === "error" && payload.recoverable === false)) {
       if (!this.run) return;
       this.run = null;
       this.metric = { status: "error" };

package/src/utils/voice-support.ts

@@ -1,4 +1,21 @@
-import type { VoiceConfig } from "../types";
+import type { AgentWidgetConfig, VoiceConfig } from "../types";
+
+/** Changes that require replacing a session's capture and playback provider. */
+export function voiceConnectionChanged(previous: AgentWidgetConfig, next: AgentWidgetConfig): boolean {
+  const before = previous.voiceRecognition;
+  const after = next.voiceRecognition;
+  return (before?.enabled === true) !== (after?.enabled === true) ||
+    before?.provider?.type !== after?.provider?.type ||
+    before?.provider?.custom !== after?.provider?.custom ||
+    before?.provider?.runtype?.createPlaybackEngine !== after?.provider?.runtype?.createPlaybackEngine ||
+    JSON.stringify(before?.provider?.runtype) !== JSON.stringify(after?.provider?.runtype) ||
+    previous.agentId !== next.agentId || previous.clientToken !== next.clientToken || previous.apiUrl !== next.apiUrl;
+}
+
+/** Providers whose microphone lifecycle is owned by ChatSession instead of browser dictation. */
+export function usesSessionVoice(config?: Partial<VoiceConfig>): boolean {
+  return config?.type === "runtype" || config?.type === "custom";
+}
 
 /**
  * Eager, construction-free replica of the voice factory's `isVoiceSupported`

package/src/voice/voice-turn-tracker.ts

@@ -0,0 +1,18 @@
+/** Correlate provider transcripts across cancellation and overlapping turns. */
+export class VoiceTurnTracker {
+  private turnId?: string;
+  private cancelled = false;
+
+  start(turnId?: string): void {
+    this.turnId = turnId;
+    this.cancelled = false;
+  }
+
+  cancel(): void {
+    this.cancelled = true;
+  }
+
+  accepts(turnId?: string): boolean {
+    return !this.cancelled && (!turnId || !this.turnId || turnId === this.turnId);
+  }
+}