@runtypelabs/persona 4.22.0 → 4.23.0

package/src/ui.typing-indicator.test.ts

@@ -133,3 +133,219 @@ describe("standalone typing indicator bubble", () => {
     destroy();
   });
 });
+
+/**
+ * Regression coverage for hidden tool/reasoning rows. With
+ * `features.showToolCalls: false` the tool row never renders, so it must not
+ * count as "the assistant is already responding" and hide the standalone dots
+ * for the whole tool phase.
+ */
+describe("standalone typing indicator with hidden activity rows", () => {
+  afterEach(() => {
+    document.body.innerHTML = "";
+    if (typeof localStorage !== "undefined") localStorage.clear();
+    vi.restoreAllMocks();
+  });
+
+  const mountStreaming = async (config: Record<string, unknown>) => {
+    global.fetch = vi.fn().mockImplementation(
+      () => new Promise(() => {})
+    ) as unknown as typeof fetch;
+
+    const mount = createMount();
+    const controller = createAgentExperience(mount, {
+      apiUrl: "https://api.example.com/chat",
+      launcher: { enabled: false },
+      ...config,
+    } as unknown as Parameters<typeof createAgentExperience>[1]);
+
+    controller.submitMessage("hello");
+    await Promise.resolve();
+    await Promise.resolve();
+    return { mount, controller };
+  };
+
+  // The session orders by createdAt first, then by its Date.now()-based
+  // sequence, so injected rows need both stamped in the future to sort after
+  // the user message the way real stream rows do.
+  const seq = (n: number) => Date.now() + 60_000 + n;
+  const at = (n: number) => new Date(seq(n)).toISOString();
+
+  const injectTool = (
+    controller: ReturnType<typeof createAgentExperience>,
+    id: string,
+    status: "running" | "complete",
+    sequence: number
+  ) => {
+    controller.injectTestMessage({
+      type: "message",
+      message: {
+        id,
+        role: "assistant",
+        content: "",
+        createdAt: new Date(sequence).toISOString(),
+        sequence,
+        streaming: status !== "complete",
+        variant: "tool",
+        toolCall: { id, name: "lookup", status },
+      },
+    });
+  };
+
+  const injectReasoning = (
+    controller: ReturnType<typeof createAgentExperience>,
+    id: string,
+    status: "streaming" | "complete",
+    sequence: number
+  ) => {
+    controller.injectTestMessage({
+      type: "message",
+      message: {
+        id,
+        role: "assistant",
+        content: "",
+        createdAt: new Date(sequence).toISOString(),
+        sequence,
+        streaming: status !== "complete",
+        variant: "reasoning",
+        reasoning: { id, status, chunks: ["thinking"] },
+      },
+    });
+  };
+
+  const typingIndicator = (mount: HTMLElement) =>
+    mount.querySelector<HTMLElement>('[data-typing-indicator="true"]');
+
+
+  it("keeps the dots while a hidden tool call is running", async () => {
+    const { mount, controller } = await mountStreaming({
+      features: { showToolCalls: false },
+    });
+    expect(typingIndicator(mount)).not.toBeNull();
+
+    injectTool(controller, "tool-1", "running", seq(1));
+    expect(mount.querySelector(".persona-tool-bubble")).toBeNull();
+    expect(typingIndicator(mount)).not.toBeNull();
+
+    controller.destroy();
+  });
+
+  it("keeps the dots after a hidden tool call completes, before the next text", async () => {
+    const { mount, controller } = await mountStreaming({
+      features: { showToolCalls: false },
+    });
+
+    injectTool(controller, "tool-1", "running", seq(1));
+    injectTool(controller, "tool-1", "complete", seq(1));
+    expect(mount.querySelector(".persona-tool-bubble")).toBeNull();
+    expect(typingIndicator(mount)).not.toBeNull();
+
+    controller.destroy();
+  });
+
+  it("keeps the dots when a hidden tool call follows an intermediate assistant text", async () => {
+    const { mount, controller } = await mountStreaming({
+      features: { showToolCalls: false },
+    });
+
+    controller.injectTestMessage({
+      type: "message",
+      message: {
+        id: "text-1",
+        role: "assistant",
+        content: "Let me look that up.",
+        createdAt: at(1),
+        sequence: seq(1),
+        streaming: false,
+      },
+    });
+    injectTool(controller, "tool-1", "complete", seq(2));
+    expect(typingIndicator(mount)).not.toBeNull();
+
+    controller.destroy();
+  });
+
+  it("still hides the dots while a visible tool call renders its own bubble", async () => {
+    const { mount, controller } = await mountStreaming({
+      features: { showToolCalls: true },
+    });
+
+    injectTool(controller, "tool-1", "running", seq(1));
+    expect(mount.querySelector(".persona-tool-bubble")).not.toBeNull();
+    expect(typingIndicator(mount)).toBeNull();
+
+    controller.destroy();
+  });
+
+  it("keeps the dots while hidden reasoning streams", async () => {
+    const { mount, controller } = await mountStreaming({
+      features: { showReasoning: false },
+    });
+
+    injectReasoning(controller, "reason-1", "streaming", seq(1));
+    expect(typingIndicator(mount)).not.toBeNull();
+
+    injectReasoning(controller, "reason-1", "complete", seq(1));
+    expect(typingIndicator(mount)).not.toBeNull();
+
+    controller.destroy();
+  });
+
+  it("keeps the dots after a visible tool call is removed by completedVisibility", async () => {
+    const { mount, controller } = await mountStreaming({
+      features: {
+        showToolCalls: true,
+        toolCallDisplay: { completedVisibility: "removed" },
+      },
+    });
+
+    injectTool(controller, "tool-1", "running", seq(1));
+    expect(mount.querySelector(".persona-tool-bubble")).not.toBeNull();
+    expect(typingIndicator(mount)).toBeNull();
+
+    injectTool(controller, "tool-1", "complete", seq(1));
+    expect(mount.querySelector(".persona-tool-bubble")).toBeNull();
+    expect(typingIndicator(mount)).not.toBeNull();
+
+    controller.destroy();
+  });
+
+  it("keeps the dots after visible reasoning is removed by completedVisibility", async () => {
+    const { mount, controller } = await mountStreaming({
+      features: {
+        showReasoning: true,
+        reasoningDisplay: { completedVisibility: "removed" },
+      },
+    });
+
+    injectReasoning(controller, "reason-1", "streaming", seq(1));
+    expect(typingIndicator(mount)).toBeNull();
+
+    injectReasoning(controller, "reason-1", "complete", seq(1));
+    expect(typingIndicator(mount)).not.toBeNull();
+
+    controller.destroy();
+  });
+
+  it("hides the dots once a real assistant message is streaming", async () => {
+    const { mount, controller } = await mountStreaming({
+      features: { showToolCalls: false },
+    });
+
+    injectTool(controller, "tool-1", "complete", seq(1));
+    controller.injectTestMessage({
+      type: "message",
+      message: {
+        id: "text-1",
+        role: "assistant",
+        content: "Here you go",
+        createdAt: at(2),
+        sequence: seq(2),
+        streaming: true,
+      },
+    });
+    expect(typingIndicator(mount)).toBeNull();
+
+    controller.destroy();
+  });
+});

package/src/ui.voice-custom-provider.test.ts

@@ -0,0 +1,211 @@
+// @vitest-environment jsdom
+
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { createAgentExperience } from "./ui";
+import type { VoiceProvider, VoiceStatus } from "./types";
+
+const controllers: ReturnType<typeof createAgentExperience>[] = [];
+beforeEach(() => { window.scrollTo = vi.fn(); });
+afterEach(() => {
+  for (const controller of controllers.splice(0)) controller.destroy();
+  document.body.innerHTML = "";
+  window.localStorage.clear();
+  vi.unstubAllGlobals();
+});
+
+function fixture(mode: "none" | "cancel" | "barge-in" = "cancel") {
+  let statusCallback: (status: VoiceStatus) => void = () => {};
+  let transcriptCallback: NonNullable<Parameters<NonNullable<VoiceProvider["onTranscript"]>>[0]> = () => {};
+  let active = false;
+  const provider: VoiceProvider = {
+    type: "runtype",
+    connect: vi.fn(async () => {}),
+    disconnect: vi.fn(async () => { active = false; }),
+    startListening: vi.fn(async () => { active = true; statusCallback("listening"); }),
+    stopListening: vi.fn(async () => { active = false; statusCallback("idle"); }),
+    onResult: vi.fn(),
+    onError: vi.fn(),
+    onStatusChange: callback => { statusCallback = callback; },
+    onTranscript: callback => { transcriptCallback = callback; },
+    getInterruptionMode: () => mode,
+    isBargeInActive: () => active,
+    stopPlayback: vi.fn(() => { statusCallback("listening"); }),
+    deactivateBargeIn: vi.fn(async () => { active = false; statusCallback("idle"); }),
+  };
+  const recognition = vi.fn();
+  vi.stubGlobal("SpeechRecognition", recognition);
+  const mount = document.createElement("div");
+  document.body.appendChild(mount);
+  const controller = createAgentExperience(mount, {
+    apiUrl: "https://api.example.test/chat",
+    launcher: { enabled: false }, persistState: false, suggestionChips: [],
+    voiceRecognition: { enabled: true, provider: { type: "custom", custom: () => provider } },
+  });
+  controllers.push(controller);
+  const mic = () => mount.querySelector<HTMLButtonElement>("[data-persona-composer-mic]")!;
+  return { provider, recognition, mic, controller, emit: (status: VoiceStatus) => statusCallback(status),
+    transcript: (role: "user" | "assistant", text: string, final = true, turnId?: string) => transcriptCallback(role, text, final, { turnId }) };
+}
+
+it("starts the custom provider from the microphone and cancels playback without hanging up", async () => {
+  const { provider, recognition, mic, emit } = fixture();
+  mic().click();
+  await vi.waitFor(() => expect(provider.startListening).toHaveBeenCalledOnce());
+  expect(recognition).not.toHaveBeenCalled();
+  emit("speaking");
+  expect(mic().getAttribute("aria-label")).toBe("Stop playback and re-record");
+  mic().click();
+  expect(provider.stopPlayback).toHaveBeenCalledOnce();
+  expect(provider.stopListening).not.toHaveBeenCalled();
+  expect(provider.deactivateBargeIn).not.toHaveBeenCalled();
+});
+
+it("respects none mode and cleans up the custom provider on destroy", async () => {
+  const { provider, mic, emit, controller } = fixture("none");
+  mic().click();
+  await vi.waitFor(() => expect(provider.startListening).toHaveBeenCalledOnce());
+  emit("speaking");
+  mic().click();
+  expect(provider.stopPlayback).not.toHaveBeenCalled();
+  expect(provider.stopListening).not.toHaveBeenCalled();
+  controller.destroy();
+  controllers.splice(controllers.indexOf(controller), 1);
+  expect(provider.disconnect).toHaveBeenCalled();
+});
+
+it("hangs up a barge-in custom call through the microphone control", async () => {
+  const { provider, mic, emit } = fixture("barge-in");
+  mic().click();
+  await vi.waitFor(() => expect(provider.startListening).toHaveBeenCalledOnce());
+  emit("speaking");
+  mic().click();
+  await vi.waitFor(() => expect(provider.deactivateBargeIn).toHaveBeenCalledOnce());
+});
+
+it("routes controller start and stop to the custom provider after a composer update", async () => {
+  const { provider, recognition, controller, mic, emit } = fixture();
+  controller.update({ voiceRecognition: { enabled: false } });
+  controller.update({ voiceRecognition: { enabled: true } });
+  expect(mic()).not.toBeNull();
+  await controller.startVoiceRecognition();
+  await vi.waitFor(() => expect(provider.startListening).toHaveBeenCalledOnce());
+  emit("speaking");
+  await controller.stopVoiceRecognition();
+  expect(provider.deactivateBargeIn).toHaveBeenCalledOnce();
+  expect(recognition).not.toHaveBeenCalled();
+});
+
+it.each(["cancel", "barge-in"] as const)("settles a pending assistant placeholder after %s during thinking", async (mode) => {
+  const { provider, mic, emit, transcript, controller } = fixture(mode);
+  mic().click();
+  await vi.waitFor(() => expect(provider.startListening).toHaveBeenCalledOnce());
+  emit("processing");
+  transcript("user", "Tell me a story");
+  expect(controller.getMessages().some(message => message.streaming)).toBe(true);
+  if (mode === "cancel") mic().click();
+  else emit("listening");
+  expect(controller.getMessages().map(message => message.content)).toEqual(["Tell me a story"]);
+  expect(controller.getMessages().some(message => message.streaming || message.voiceProcessing)).toBe(false);
+  transcript("user", "Next question");
+  transcript("assistant", "Next answer");
+  expect(controller.getMessages().map(message => message.content)).toEqual(["Tell me a story", "Next question", "Next answer"]);
+});
+
+it("preserves partial voice content while clearing its streaming flags on hangup", async () => {
+  const { provider, mic, emit, transcript, controller } = fixture("barge-in");
+  mic().click();
+  await vi.waitFor(() => expect(provider.startListening).toHaveBeenCalledOnce());
+  transcript("user", "Explain");
+  transcript("assistant", "A partial answer", false);
+  emit("speaking");
+  mic().click();
+  expect(controller.getMessages().at(-1)).toMatchObject({ content: "A partial answer", streaming: false, voiceProcessing: false });
+});
+
+it("keeps the current user partial in one bubble when playback returns to listening", async () => {
+  const { provider, mic, emit, transcript, controller } = fixture();
+  mic().click();
+  await vi.waitFor(() => expect(provider.startListening).toHaveBeenCalledOnce());
+  transcript("user", "Hello");
+  transcript("assistant", "Hi");
+  transcript("user", "Next", false);
+  emit("listening");
+  transcript("user", "Next question");
+  transcript("assistant", "Next answer");
+  expect(controller.getMessages().filter(message => message.role === "user").map(message => message.content)).toEqual(["Hello", "Next question"]);
+});
+
+it("drops a cancelled reply arriving after a newer identified turn", async () => {
+  const { provider, mic, emit, transcript, controller } = fixture();
+  mic().click();
+  await vi.waitFor(() => expect(provider.startListening).toHaveBeenCalledOnce());
+  transcript("user", "Old question", true, "old");
+  emit("processing");
+  mic().click();
+  transcript("assistant", "Old partial", false, "old");
+  transcript("user", "New question", true, "new");
+  transcript("assistant", "Cancelled old answer", true, "old");
+  transcript("assistant", "New answer", true, "new");
+  expect(controller.getMessages().map(message => message.content)).toEqual(["Old question", "New question", "New answer"]);
+});
+
+it("ignores untagged cancelled output until the next user final without losing that next answer", async () => {
+  const { provider, mic, emit, transcript, controller } = fixture();
+  mic().click();
+  await vi.waitFor(() => expect(provider.startListening).toHaveBeenCalledOnce());
+  transcript("user", "Old question");
+  emit("processing");
+  mic().click();
+  transcript("assistant", "Cancelled answer");
+  transcript("user", "New question");
+  transcript("assistant", "New answer");
+  expect(controller.getMessages().map(message => message.content)).toEqual(["Old question", "New question", "New answer"]);
+});
+
+it("disconnects the old provider before constructing its replacement and ignores its stale callbacks", async () => {
+  const { provider, mic, controller, transcript, emit } = fixture();
+  mic().click();
+  await vi.waitFor(() => expect(provider.startListening).toHaveBeenCalledOnce());
+  let finishDisconnect!: () => void;
+  vi.mocked(provider.disconnect).mockImplementation(() => new Promise<void>(resolve => { finishDisconnect = resolve; }));
+  const replacement = { ...provider, connect: vi.fn(async () => {}), startListening: vi.fn(async () => {}), disconnect: vi.fn(async () => {}) };
+  const factory = vi.fn(() => replacement);
+  controller.update({ voiceRecognition: { enabled: true, provider: { type: "custom", custom: factory } } });
+  expect(provider.disconnect).toHaveBeenCalledOnce();
+  expect(controller.isVoiceActive()).toBe(false);
+  expect(factory).not.toHaveBeenCalled();
+  transcript("assistant", "Stale reply");
+  emit("speaking");
+  expect(controller.getMessages()).toEqual([]);
+  finishDisconnect();
+  await controller.startVoiceRecognition();
+  await vi.waitFor(() => expect(replacement.startListening).toHaveBeenCalledOnce());
+  expect(factory).toHaveBeenCalledOnce();
+});
+
+it("disconnects a live call when disabled and reinstalls the provider on reenable", async () => {
+  const { provider, mic, controller } = fixture();
+  mic().click();
+  await vi.waitFor(() => expect(provider.startListening).toHaveBeenCalledOnce());
+  controller.update({ voiceRecognition: { enabled: false } });
+  expect(provider.disconnect).toHaveBeenCalledOnce();
+  expect(controller.isVoiceActive()).toBe(false);
+  controller.update({ voiceRecognition: { enabled: true } });
+  await controller.startVoiceRecognition();
+  await vi.waitFor(() => expect(provider.startListening).toHaveBeenCalledTimes(2));
+});
+
+it("sets up custom voice after starting with browser dictation and preserves it for cosmetic updates", async () => {
+  const { provider, controller } = fixture();
+  await controller.startVoiceRecognition();
+  await vi.waitFor(() => expect(provider.startListening).toHaveBeenCalledOnce());
+  controller.update({ voiceRecognition: { provider: { type: "browser" } } });
+  expect(provider.disconnect).toHaveBeenCalledOnce();
+  expect(controller.isVoiceActive()).toBe(false);
+  vi.mocked(provider.startListening).mockClear();
+  controller.update({ voiceRecognition: { provider: { type: "custom", custom: () => provider } } });
+  await controller.startVoiceRecognition();
+  await vi.waitFor(() => expect(provider.startListening).toHaveBeenCalledOnce());
+  controller.update({ voiceRecognition: { iconName: "mic" }, colorScheme: "dark" });
+  expect(provider.disconnect).toHaveBeenCalledOnce();
+});

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