@runtypelabs/persona 4.21.1 → 4.22.1

package/src/utils/event-stream-buffer.test.ts

@@ -37,7 +37,7 @@ describe("EventStreamBuffer", () => {
 
   it("should push and retrieve events", () => {
     const buf = new EventStreamBuffer(10);
-    const evt = makeEvent("step_chunk", 1);
+    const evt = makeEvent("text_delta", 1);
     buf.push(evt);
     expect(buf.getSize()).toBe(1);
     expect(buf.getAll()).toEqual([evt]);
@@ -85,30 +85,30 @@ describe("EventStreamBuffer", () => {
 
   it("should track unique event types", () => {
     const buf = new EventStreamBuffer(10);
-    buf.push(makeEvent("step_chunk", 1));
-    buf.push(makeEvent("flow_complete", 2));
-    buf.push(makeEvent("step_chunk", 3));
+    buf.push(makeEvent("text_delta", 1));
+    buf.push(makeEvent("execution_complete", 2));
+    buf.push(makeEvent("text_delta", 3));
     const types = buf.getEventTypes();
-    expect(types).toContain("step_chunk");
-    expect(types).toContain("flow_complete");
+    expect(types).toContain("text_delta");
+    expect(types).toContain("execution_complete");
     expect(types).toHaveLength(2);
   });
 
   it("should preserve event types after eviction", () => {
     const buf = new EventStreamBuffer(3);
-    buf.push(makeEvent("step_chunk", 1));
+    buf.push(makeEvent("text_delta", 1));
     buf.push(makeEvent("tool_start", 2));
-    buf.push(makeEvent("flow_complete", 3));
-    // Evict the step_chunk event
+    buf.push(makeEvent("execution_complete", 3));
+    // Evict the text_delta event
     buf.push(makeEvent("tool_end", 4));
     buf.push(makeEvent("tool_end", 5));
-    // step_chunk is evicted from the buffer but still tracked in types
+    // text_delta is evicted from the buffer but still tracked in types
     const all = buf.getAll();
-    expect(all.every(e => e.type !== "step_chunk")).toBe(true);
+    expect(all.every(e => e.type !== "text_delta")).toBe(true);
     const types = buf.getEventTypes();
-    expect(types).toContain("step_chunk");
+    expect(types).toContain("text_delta");
     expect(types).toContain("tool_start");
-    expect(types).toContain("flow_complete");
+    expect(types).toContain("execution_complete");
     expect(types).toContain("tool_end");
     expect(types).toHaveLength(4);
   });

package/src/utils/event-stream-capture.test.ts

@@ -45,10 +45,10 @@ describe("Event Capture Pipeline - onSSEEvent callback", () => {
     });
   });
 
-  it("should fire onSSEEvent for step_chunk events", async () => {
+  it("should fire onSSEEvent for text_delta events", async () => {
     global.fetch = createMockFetch([
       sseData({
-        type: "step_chunk",
+        type: "text_delta",
         id: "step_1",
         name: "Prompt 1",
         executionType: "prompt",
@@ -56,7 +56,7 @@ describe("Event Capture Pipeline - onSSEEvent callback", () => {
         text: "Hello world"
       }),
       sseData({
-        type: "flow_complete",
+        type: "execution_complete",
         flowId: "flow_1",
         success: true,
         duration: 100
@@ -79,11 +79,11 @@ describe("Event Capture Pipeline - onSSEEvent callback", () => {
 
     // Should capture both events
     const stepChunkEvents = capturedSSEEvents.filter(
-      (e) => e.eventType === "step_chunk"
+      (e) => e.eventType === "text_delta"
     );
     expect(stepChunkEvents).toHaveLength(1);
     expect(stepChunkEvents[0].payload).toMatchObject({
-      type: "step_chunk",
+      type: "text_delta",
       text: "Hello world"
     });
   });
@@ -106,7 +106,7 @@ describe("Event Capture Pipeline - onSSEEvent callback", () => {
         completedAt: "2025-01-01T00:00:01.000Z"
       }),
       sseData({
-        type: "flow_complete",
+        type: "execution_complete",
         flowId: "flow_1",
         success: true,
         duration: 200
@@ -148,10 +148,10 @@ describe("Event Capture Pipeline - onSSEEvent callback", () => {
     });
   });
 
-  it("should fire onSSEEvent for flow_complete events", async () => {
+  it("should fire onSSEEvent for execution_complete events", async () => {
     global.fetch = createMockFetch([
       sseData({
-        type: "flow_complete",
+        type: "execution_complete",
         flowId: "flow_1",
         success: true,
         duration: 500,
@@ -175,11 +175,11 @@ describe("Event Capture Pipeline - onSSEEvent callback", () => {
     );
 
     const flowCompleteEvents = capturedSSEEvents.filter(
-      (e) => e.eventType === "flow_complete"
+      (e) => e.eventType === "execution_complete"
     );
     expect(flowCompleteEvents).toHaveLength(1);
     expect(flowCompleteEvents[0].payload).toMatchObject({
-      type: "flow_complete",
+      type: "execution_complete",
       flowId: "flow_1",
       success: true,
       duration: 500
@@ -189,7 +189,7 @@ describe("Event Capture Pipeline - onSSEEvent callback", () => {
   it("should fire onSSEEvent for every event in a multi-event stream", async () => {
     global.fetch = createMockFetch([
       sseData({
-        type: "step_chunk",
+        type: "text_delta",
         id: "step_1",
         name: "Prompt 1",
         executionType: "prompt",
@@ -197,7 +197,7 @@ describe("Event Capture Pipeline - onSSEEvent callback", () => {
         text: "Hello"
       }),
       sseData({
-        type: "step_chunk",
+        type: "text_delta",
         id: "step_1",
         name: "Prompt 1",
         executionType: "prompt",
@@ -218,7 +218,7 @@ describe("Event Capture Pipeline - onSSEEvent callback", () => {
         duration: 50
       }),
       sseData({
-        type: "flow_complete",
+        type: "execution_complete",
         flowId: "flow_1",
         success: true,
         duration: 300
@@ -244,11 +244,11 @@ describe("Event Capture Pipeline - onSSEEvent callback", () => {
 
     const types = capturedSSEEvents.map((e) => e.eventType);
     expect(types).toEqual([
-      "step_chunk",
-      "step_chunk",
+      "text_delta",
+      "text_delta",
       "tool_start",
       "tool_complete",
-      "flow_complete"
+      "execution_complete"
     ]);
   });
 
@@ -257,11 +257,11 @@ describe("Event Capture Pipeline - onSSEEvent callback", () => {
     // When SSE has no event prefix, payloadType = payload.type
     global.fetch = createMockFetch([
       sseData({
-        type: "step_chunk",
+        type: "text_delta",
         text: "chunk1"
       }),
       sseData({
-        type: "flow_complete",
+        type: "execution_complete",
         success: true
       })
     ]);
@@ -281,8 +281,8 @@ describe("Event Capture Pipeline - onSSEEvent callback", () => {
     );
 
     // Event types should be resolved from payload.type
-    expect(capturedSSEEvents[0].eventType).toBe("step_chunk");
-    expect(capturedSSEEvents[1].eventType).toBe("flow_complete");
+    expect(capturedSSEEvents[0].eventType).toBe("text_delta");
+    expect(capturedSSEEvents[1].eventType).toBe("execution_complete");
   });
 });
 

package/src/utils/formatting.ts

@@ -52,6 +52,28 @@ export const describeReasonStatus = (reasoning: AgentWidgetReasoning) => {
   return "";
 };
 
+/** Defaults for `features.reasoningDisplay.shortThinkThreshold`. */
+export const DEFAULT_SHORT_THINK_DURATION_MS = 15_000;
+export const DEFAULT_SHORT_THINK_CHARS = 1_200;
+
+/**
+ * A completed reasoning trace is short when its duration is under the
+ * threshold, or (with no reported duration) its streamed text is under the
+ * character threshold. Duration is preferred when available.
+ */
+export const isShortReasoning = (
+  reasoning: AgentWidgetReasoning,
+  threshold?: { durationMs?: number; chars?: number }
+): boolean => {
+  const durationThreshold = threshold?.durationMs ?? DEFAULT_SHORT_THINK_DURATION_MS;
+  const charsThreshold = threshold?.chars ?? DEFAULT_SHORT_THINK_CHARS;
+  if (typeof reasoning.durationMs === "number") {
+    return reasoning.durationMs < durationThreshold;
+  }
+  const chars = (reasoning.chunks ?? []).join("").length;
+  return chars < charsThreshold;
+};
+
 export const formatToolDuration = (tool: AgentWidgetToolCall) => {
   const durationMs =
     typeof tool.duration === "number"

package/src/utils/theme.ts

@@ -128,6 +128,22 @@ const DARK_COMPONENTS: DeepPartial<PersonaTheme> = {
         foreground: 'palette.colors.primary.300',
       },
     },
+    // Event-stream badge chips flip to a 900-tone fill with a 300-tone text
+    // (primary is the inverted dark ramp, so 800/200 lands the same way).
+    // The light defaults are 100-tone fills that read as glowing swatches on
+    // a dark panel; every pair here keeps >=4.5:1 text contrast (locked by
+    // event-stream-badge-theming.test.ts).
+    eventStream: {
+      badge: {
+        flow: { background: 'palette.colors.success.900', foreground: 'palette.colors.success.300' },
+        step: { background: 'palette.colors.primary.800', foreground: 'palette.colors.primary.200' },
+        reasoning: { background: 'palette.colors.warning.900', foreground: 'palette.colors.warning.300' },
+        tool: { background: 'palette.colors.purple.900', foreground: 'palette.colors.purple.300' },
+        agent: { background: 'palette.colors.teal.900', foreground: 'palette.colors.teal.300' },
+        error: { background: 'palette.colors.error.900', foreground: 'palette.colors.error.300' },
+        default: { background: 'palette.colors.gray.800', foreground: 'palette.colors.gray.300' },
+      },
+    },
     history: {
       // error-400: the light-surface error-600 red lands ~3:1 on dark
       // surfaces, under the 4.5:1 AA floor for the 14px destructive labels.

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" });
+});