@runtypelabs/persona 4.2.0 → 4.3.0

package/src/client.test.ts

@@ -469,12 +469,12 @@ describe('AgentWidgetClient - JSON Streaming', () => {
       'data: {"type":"flow_complete","flowId":"flow_01k9pfnztzfag9tfz4t65c9c5q","success":true,"duration":2968,"completedAt":"2025-11-12T23:47:42.234Z","totalTokensUsed":0}'
     ];
 
-    // Route the legacy step_chunk fixtures through the oracle as the 4.0 unified
-    // wire (step_chunk → step_delta → text_delta), exercising the structured
-    // JSON parser on the unified flow path: incremental text extraction, never
+    // Route the legacy step_chunk fixtures through the oracle as the 4.0 wire
+    // (step_chunk → step_delta → text_delta), exercising the structured
+    // JSON parser on the wire flow path: incremental text extraction, never
     // showing raw JSON, with the assembled response reconciled at step_complete.
     global.fetch = createRawStreamFetch(
-      toUnifiedFrames(
+      legacyToWireFrames(
         sseEvents
           .filter((f) => f.startsWith('data:'))
           .map((f) => f.replace('"type":"step_chunk"', '"type":"step_delta"') + '\n\n')
@@ -581,13 +581,13 @@ function sseEvent(eventType: string, data: Record<string, unknown>): string {
 
 /**
  * Re-encode legacy `agent_*` / `flow_*` / `step_*` / `tool_*` SSE frames into the
- * neutral UNIFIED wire the 4.0 API now emits, using the same encoder the API uses
+ * Persona wire the 4.0 API now emits, using the same encoder the API uses
  * (the vendored `createUnifiedEventWrite` oracle). The 4.0 widget only consumes the
- * unified vocabulary, so these handler tests author the rendering intent in the
+ * wire vocabulary, so these handler tests author the rendering intent in the
  * (more readable) legacy frames and inject exactly what the client sees off the
  * wire — the bridge translates it straight back before the dispatch chain renders.
  */
-function toUnifiedFrames(legacyFrames: string[]): string[] {
+function legacyToWireFrames(legacyFrames: string[]): string[] {
   const out: string[] = [];
   const write = createUnifiedEventWrite((chunk) => out.push(chunk));
   for (const frame of legacyFrames) write(frame);
@@ -595,7 +595,7 @@ function toUnifiedFrames(legacyFrames: string[]): string[] {
 }
 
 /** Stream pre-built SSE frames verbatim (no re-encode) — for fixtures already in
- *  the unified vocabulary. */
+ *  the wire vocabulary. */
 function createRawStreamFetch(frames: string[]) {
   return vi.fn().mockImplementation(async (_url?: string, _options?: any) => {
     const encoder = new TextEncoder();
@@ -610,10 +610,10 @@ function createRawStreamFetch(frames: string[]) {
 }
 
 /**
- * Mock fetch that streams the given legacy events as the 4.0 unified wire.
+ * Mock fetch that streams the given legacy events as the 4.0 wire.
  */
 function createAgentStreamFetch(events: string[]) {
-  return createRawStreamFetch(toUnifiedFrames(events));
+  return createRawStreamFetch(legacyToWireFrames(events));
 }
 
 describe('AgentWidgetClient - Agent Mode Detection', () => {
@@ -638,7 +638,199 @@ describe('AgentWidgetClient - Agent Mode Detection', () => {
   });
 });
 
+describe('AgentWidgetClient - target routing', () => {
+  const userMessage = (): AgentWidgetMessage[] => [
+    { id: 'u1', role: 'user', content: 'hi', createdAt: '2025-01-01T00:00:00.000Z' },
+  ];
+
+  it('routes a Runtype agent TypeID target through agent mode', async () => {
+    let captured: any = null;
+    global.fetch = vi.fn().mockImplementation(async (_url: string, options: any) => {
+      captured = JSON.parse(options.body);
+      const encoder = new TextEncoder();
+      return {
+        ok: true,
+        body: new ReadableStream({
+          start(controller) {
+            controller.enqueue(encoder.encode(sseEvent('agent_complete', {
+              executionId: 'exec_1', agentId: 'agent_123', success: true, iterations: 1,
+              completedAt: new Date().toISOString(), seq: 1,
+            })));
+            controller.close();
+          },
+        }),
+      };
+    });
+
+    const client = new AgentWidgetClient({ apiUrl: 'http://localhost:8000', target: 'agent_123' });
+    expect(client.isAgentMode()).toBe(true);
+    await client.dispatch({ messages: userMessage() }, () => {});
+
+    expect(captured.agent).toEqual({ agentId: 'agent_123' });
+  });
+
+  it('routes a Runtype flow TypeID target through flow dispatch', async () => {
+    let captured: any = null;
+    global.fetch = vi.fn().mockImplementation(async (_url: string, options: any) => {
+      captured = JSON.parse(options.body);
+      const encoder = new TextEncoder();
+      return {
+        ok: true,
+        body: new ReadableStream({
+          start(controller) {
+            controller.enqueue(encoder.encode('data: {"type":"flow_complete","success":true}\n\n'));
+            controller.close();
+          },
+        }),
+      };
+    });
+
+    const client = new AgentWidgetClient({ apiUrl: 'http://localhost:8000', target: 'flow_123' });
+    expect(client.isAgentMode()).toBe(false);
+    await client.dispatch({ messages: userMessage() }, () => {});
+
+    expect(captured.flowId).toBe('flow_123');
+    expect(captured.agent).toBeUndefined();
+  });
+
+  it('spreads a custom provider target payload into the proxy dispatch body', async () => {
+    let captured: any = null;
+    global.fetch = vi.fn().mockImplementation(async (_url: string, options: any) => {
+      captured = JSON.parse(options.body);
+      const encoder = new TextEncoder();
+      return {
+        ok: true,
+        body: new ReadableStream({
+          start(controller) {
+            controller.enqueue(encoder.encode('data: {"type":"flow_complete","success":true}\n\n'));
+            controller.close();
+          },
+        }),
+      };
+    });
+
+    const client = new AgentWidgetClient({
+      apiUrl: 'http://localhost:8000',
+      target: 'eve:support',
+      targetProviders: { eve: (id) => ({ payload: { assistant: id } }) },
+    });
+    expect(client.isAgentMode()).toBe(false);
+    await client.dispatch({ messages: userMessage() }, () => {});
+
+    expect(captured.assistant).toBe('support');
+    expect(Array.isArray(captured.messages)).toBe(true);
+  });
+
+  it('throws when target is combined with agentId', () => {
+    expect(
+      () => new AgentWidgetClient({ apiUrl: 'http://localhost:8000', target: 'agent_1', agentId: 'agent_2' }),
+    ).toThrow(/mutually exclusive/i);
+  });
+});
+
 describe('AgentWidgetClient - Agent Payload Building', () => {
+  it('should build a saved agent-id payload from top-level agentId', async () => {
+    let capturedPayload: any = null;
+    global.fetch = vi.fn().mockImplementation(async (_url: string, options: any) => {
+      capturedPayload = JSON.parse(options.body);
+      const encoder = new TextEncoder();
+      const stream = new ReadableStream({
+        start(controller) {
+          controller.enqueue(encoder.encode(sseEvent('agent_complete', {
+            executionId: 'exec_1',
+            agentId: 'agent_123',
+            success: true,
+            iterations: 1,
+            completedAt: new Date().toISOString(),
+            seq: 1,
+          })));
+          controller.close();
+        }
+      });
+      return { ok: true, body: stream };
+    });
+
+    const client = new AgentWidgetClient({
+      apiUrl: 'http://localhost:8000',
+      agentId: 'agent_123',
+    });
+
+    await client.dispatch({
+      messages: [{
+        id: 'usr_1',
+        role: 'user',
+        content: 'Hello saved agent',
+        createdAt: '2025-01-01T00:00:00.000Z',
+      }],
+    }, () => {});
+
+    expect(capturedPayload).toBeDefined();
+    expect(capturedPayload.agent).toEqual({ agentId: 'agent_123' });
+    expect(capturedPayload.flowId).toBeUndefined();
+    expect(capturedPayload.messages).toHaveLength(1);
+    expect(capturedPayload.messages[0].content).toBe('Hello saved agent');
+    expect(capturedPayload.options.streamResponse).toBe(true);
+    expect(capturedPayload.options.recordMode).toBe('virtual');
+  });
+
+  it('uses top-level agentId as the client-token session target', async () => {
+    const requests: Array<{ url: string; body: Record<string, unknown> }> = [];
+    global.fetch = vi.fn().mockImplementation(async (url: string, options: any) => {
+      requests.push({ url, body: JSON.parse(options.body) });
+      if (url.endsWith('/v1/client/init')) {
+        return {
+          ok: true,
+          json: async () => ({
+            sessionId: 'sess_agent',
+            expiresAt: new Date(Date.now() + 5 * 60_000).toISOString(),
+            config: {},
+          }),
+        };
+      }
+      const encoder = new TextEncoder();
+      return {
+        ok: true,
+        body: new ReadableStream({
+          start(controller) {
+            controller.enqueue(encoder.encode(sseEvent('agent_complete', {
+              executionId: 'exec_1',
+              agentId: 'agent_123',
+              success: true,
+              iterations: 1,
+              completedAt: new Date().toISOString(),
+              seq: 1,
+            })));
+            controller.close();
+          },
+        }),
+      };
+    });
+
+    const client = new AgentWidgetClient({
+      apiUrl: 'https://api.runtype.com',
+      clientToken: 'ct_live_demo',
+      agentId: 'agent_123',
+    });
+
+    await client.dispatch({
+      messages: [{
+        id: 'usr_1',
+        role: 'user',
+        content: 'Hello agent token',
+        createdAt: '2025-01-01T00:00:00.000Z',
+      }],
+    }, () => {});
+
+    expect(requests[0]).toMatchObject({
+      url: 'https://api.runtype.com/v1/client/init',
+      body: { token: 'ct_live_demo', flowId: 'agent_123' },
+    });
+    expect(requests[1]).toMatchObject({
+      url: 'https://api.runtype.com/v1/client/chat',
+      body: { sessionId: 'sess_agent' },
+    });
+  });
+
   it('should build agent payload with agent config', async () => {
     let capturedPayload: any = null;
     global.fetch = vi.fn().mockImplementation(async (_url: string, options: any) => {
@@ -1239,7 +1431,7 @@ describe('AgentWidgetClient - Agent Event Streaming', () => {
       }
     }
 
-    // Reflection now folds into a loop-scoped reasoning bubble (unified spec):
+    // Reflection now folds into a loop-scoped reasoning bubble (wire spec):
     // `agent_reflection` → reasoning_start{scope:"loop"} + reasoning_complete{text}.
     const reflectionMessages = Array.from(messagesById.values())
       .filter(m => m.variant === 'reasoning' && m.reasoning?.scope === 'loop');
@@ -1296,7 +1488,7 @@ describe('AgentWidgetClient - Agent Event Streaming', () => {
 });
 
 // ============================================================================
-// Unified Event Name Support (chunk → delta, agent_tool_* → tool_* with agentContext)
+// Wire event name support (chunk → delta, agent_tool_* → tool_* with agentContext)
 // ============================================================================
 
 // ============================================================================
@@ -1590,7 +1782,7 @@ describe('AgentWidgetClient - partId Text/Tool Interleaving', () => {
     expect(assistantTexts.length).toBe(2);
     // First message uses the provided ID
     expect(assistantTexts[0].id).toBe('ast_pre_generated_id');
-    // Second message composes baseId + the unified text block id for traceability
+    // Second message composes baseId + the wire text block id for traceability
     expect(assistantTexts[1].id).toBe('ast_pre_generated_id_text_2');
     // Content is correct per segment
     expect(assistantTexts[0].content).toBe('Before tool.');
@@ -1600,7 +1792,7 @@ describe('AgentWidgetClient - partId Text/Tool Interleaving', () => {
   it('should not overwrite last segment content with the full step response (flow)', async () => {
     const events: AgentWidgetEvent[] = [];
 
-    // Unified wire: two flow text segments split by a tool, each its own block
+    // Wire: two flow text segments split by a tool, each its own block
     // (sealed by text_end → text_complete). The step's full structured response
     // (`step_complete.result.response`) reconciles rawContent without clobbering
     // either sealed bubble's displayed content.
@@ -1715,10 +1907,10 @@ describe('AgentWidgetClient - partId Text/Tool Interleaving', () => {
       };
     };
 
-    // Unified wire (via the oracle): a single flow text block carrying partial
+    // Wire (via the oracle): a single flow text block carrying partial
     // structured JSON, sealed by text_end, then the authoritative final structured
     // response on step_complete. Exercises the async structured-content parser +
-    // sealed-segment reconciliation on the unified flow path.
+    // sealed-segment reconciliation on the wire flow path.
     global.fetch = createAgentStreamFetch([
       sseEvent('flow_start', { flowId: 'f1', flowName: 'Test', totalSteps: 1 }),
       sseEvent('tool_start', { toolId: 'tc_1', name: 'test_tool', toolType: 'custom', startedAt: new Date().toISOString() }),
@@ -1784,9 +1976,137 @@ describe('AgentWidgetClient - partId Text/Tool Interleaving', () => {
   });
 });
 
+describe('AgentWidgetClient - flow continuation stream without execution_start', () => {
+  // A tool-driven `/resume` continues a flow on a brand-new stream that does NOT
+  // re-emit `execution_start` (`flow_start`). Each stream resolves its execution
+  // kind independently and defaults to `"agent"`, so the continuation used to
+  // mis-route the final prompt-step finalization: the streamed text block was
+  // sealed via the agent path (which never records it as the sealed flow bubble),
+  // then `step_complete.result.response` re-rendered the same text as a SECOND
+  // bubble. The client now recovers the flow kind from the leading `step_*`
+  // frame (a `stepType` is flow-only), so the finalization reconciles in place.
+  function collectAssistantTexts(events: AgentWidgetEvent[]) {
+    const messagesById = new Map<string, AgentWidgetMessage>();
+    for (const event of events) {
+      if (event.type === 'message') messagesById.set(event.message.id, event.message);
+    }
+    return Array.from(messagesById.values())
+      .filter(m => m.role === 'assistant' && !m.variant)
+      .sort((a, b) => (a.sequence ?? 0) - (b.sequence ?? 0));
+  }
+
+  it('does not duplicate the final message when a flow resumes without execution_start', async () => {
+    const events: AgentWidgetEvent[] = [];
+
+    // No `flow_start`/`execution_start`: this is exactly the wire a tool-driven
+    // `/resume` continuation delivers.
+    global.fetch = createAgentStreamFetch([
+      sseEvent('step_start', { id: 's1', name: 'Prompt', stepType: 'prompt', index: 0, totalSteps: 1 }),
+      sseEvent('text_start', { messageId: 'msg_s1' }),
+      sseEvent('step_delta', { id: 's1', text: 'Done! Added to your cart.' }),
+      sseEvent('text_end', { messageId: 'msg_s1' }),
+      // The authoritative final response mirrors the streamed text.
+      sseEvent('step_complete', { id: 's1', name: 'Prompt', stepType: 'prompt', success: true, result: { response: 'Done! Added to your cart.' }, executionTime: 500 }),
+      sseEvent('flow_complete', { success: true }),
+    ]);
+
+    const client = new AgentWidgetClient({ apiUrl: 'http://localhost:8000' });
+    await client.dispatch(
+      { messages: [{ id: 'usr_1', role: 'user', content: 'add it to my cart', createdAt: new Date().toISOString() }] },
+      (event) => events.push(event)
+    );
+
+    const assistantTexts = collectAssistantTexts(events);
+
+    // Exactly ONE assistant bubble — not duplicated by the step_complete finalization.
+    expect(assistantTexts.length).toBe(1);
+    expect(assistantTexts[0].content).toBe('Done! Added to your cart.');
+    expect(assistantTexts[0].streaming).toBe(false);
+  });
+
+  it('still reconciles in place when execution_start IS present (initial flow stream)', async () => {
+    const events: AgentWidgetEvent[] = [];
+
+    // Same shape but WITH flow_start — the pre-existing, already-correct path.
+    global.fetch = createAgentStreamFetch([
+      sseEvent('flow_start', { flowId: 'f1', flowName: 'Test', totalSteps: 1, executionId: 'exec_f1' }),
+      sseEvent('step_start', { id: 's1', name: 'Prompt', stepType: 'prompt', index: 0, totalSteps: 1 }),
+      sseEvent('text_start', { messageId: 'msg_s1' }),
+      sseEvent('step_delta', { id: 's1', text: 'Done! Added to your cart.' }),
+      sseEvent('text_end', { messageId: 'msg_s1' }),
+      sseEvent('step_complete', { id: 's1', name: 'Prompt', stepType: 'prompt', success: true, result: { response: 'Done! Added to your cart.' }, executionTime: 500 }),
+      sseEvent('flow_complete', { success: true }),
+    ]);
+
+    const client = new AgentWidgetClient({ apiUrl: 'http://localhost:8000' });
+    await client.dispatch(
+      { messages: [{ id: 'usr_1', role: 'user', content: 'add it to my cart', createdAt: new Date().toISOString() }] },
+      (event) => events.push(event)
+    );
+
+    const assistantTexts = collectAssistantTexts(events);
+    expect(assistantTexts.length).toBe(1);
+    expect(assistantTexts[0].content).toBe('Done! Added to your cart.');
+    expect(assistantTexts[0].streaming).toBe(false);
+  });
+
+  it('does not misclassify an agent stream as a flow (no stepType present)', async () => {
+    const events: AgentWidgetEvent[] = [];
+    const execId = 'exec_a1';
+
+    // Agent loops use `agent_*`/turn_* frames and never carry a `stepType`, so the
+    // flow recovery must not engage. A single streamed turn yields exactly one
+    // bubble (regression guard so the recovery can't over-fire on agents).
+    global.fetch = createAgentStreamFetch([
+      sseEvent('agent_start', {
+        executionId: execId, agentId: 'virtual', agentName: 'Test',
+        maxTurns: 1, startedAt: new Date().toISOString(), seq: 1,
+      }),
+      sseEvent('agent_iteration_start', {
+        executionId: execId, iteration: 1, maxTurns: 1,
+        startedAt: new Date().toISOString(), seq: 2,
+      }),
+      sseEvent('agent_turn_start', {
+        executionId: execId, iteration: 1, turnIndex: 0,
+        role: 'assistant', turnId: 'turn_1', seq: 3,
+      }),
+      sseEvent('agent_turn_delta', {
+        executionId: execId, iteration: 1, delta: 'Hi there!',
+        contentType: 'text', turnId: 'turn_1', seq: 4,
+      }),
+      sseEvent('agent_turn_complete', {
+        executionId: execId, iteration: 1, role: 'assistant',
+        turnId: 'turn_1', completedAt: new Date().toISOString(), seq: 5,
+      }),
+      sseEvent('agent_iteration_complete', {
+        executionId: execId, iteration: 1, toolCallsMade: 0,
+        stopConditionMet: false, completedAt: new Date().toISOString(), seq: 6,
+      }),
+      sseEvent('agent_complete', {
+        executionId: execId, agentId: 'virtual', success: true,
+        iterations: 1, stopReason: 'max_iterations',
+        completedAt: new Date().toISOString(), seq: 7,
+      }),
+    ]);
+
+    const client = new AgentWidgetClient({
+      apiUrl: 'http://localhost:8000',
+      agent: { name: 'Test', model: 'openai:gpt-4o-mini', systemPrompt: 'test' },
+    });
+    await client.dispatch(
+      { messages: [{ id: 'usr_1', role: 'user', content: 'hi', createdAt: new Date().toISOString() }] },
+      (event) => events.push(event)
+    );
+
+    const assistantTexts = collectAssistantTexts(events);
+    expect(assistantTexts.length).toBe(1);
+    expect(assistantTexts[0].content).toBe('Hi there!');
+  });
+});
+
 describe('AgentWidgetClient - nested flow-as-tool (parentToolCallId)', () => {
   // PR #4602: a flow running as a tool enriches its streamed text/reasoning with
-  // toolContext.toolId; the unified wire surfaces it as text_start/reasoning_start
+  // toolContext.toolId; the wire surfaces it as text_start/reasoning_start
   // .parentToolCallId, and the widget routes that block into the parent tool's row.
   it('routes nested flow text into the parent tool row, not the top-level assistant', async () => {
     const events: AgentWidgetEvent[] = [];
@@ -2334,9 +2654,9 @@ describe('AgentWidgetClient - agent_turn text/tool interleaving', () => {
 // ============================================================================
 
 describe('AgentWidgetClient: step_await parsing', () => {
-  // Unified collapses the legacy flow `step_await` (a `local_tool_required` pause)
+  // Wire collapses the legacy flow `step_await` (a `local_tool_required` pause)
   // into the neutral `await` event the native handler consumes.
-  const buildUnifiedAwaitStream = (payload: Record<string, unknown>): ReadableStream<Uint8Array> => {
+  const buildAwaitStream = (payload: Record<string, unknown>): ReadableStream<Uint8Array> => {
     const encoder = new TextEncoder();
     const body = `event: await\ndata: ${JSON.stringify({ type: 'await', ...payload })}\n\n`;
     return new ReadableStream({
@@ -2362,7 +2682,7 @@ describe('AgentWidgetClient: step_await parsing', () => {
   it('emits a complete tool message with awaitingLocalTool=true for local_tool_required', async () => {
     global.fetch = vi.fn().mockResolvedValue({
       ok: true,
-      body: buildUnifiedAwaitStream({
+      body: buildAwaitStream({
         awaitReason: 'local_tool_required',
         id: 'step-1',
         name: 'Test Step',
@@ -2402,7 +2722,7 @@ describe('AgentWidgetClient: step_await parsing', () => {
   it('emits a running tool message for WebMCP local_tool_required until the browser tool resolves', async () => {
     global.fetch = vi.fn().mockResolvedValue({
       ok: true,
-      body: buildUnifiedAwaitStream({
+      body: buildAwaitStream({
         awaitReason: 'local_tool_required',
         id: 'step-1',
         name: 'Test Step',
@@ -2473,7 +2793,7 @@ describe('AgentWidgetClient: step_await parsing', () => {
 // ============================================================================
 
 describe('AgentWidgetClient: agent_await parsing', () => {
-  // Unified collapses the legacy `step_await`/`agent_await` pair into one `await`
+  // Wire collapses the legacy `step_await`/`agent_await` pair into one `await`
   // event; the dispatch origin survives as the `origin` field on the payload.
   const buildAgentAwaitStream = (payload: Record<string, unknown>): ReadableStream<Uint8Array> => {
     const encoder = new TextEncoder();
@@ -2899,7 +3219,7 @@ describe('AgentWidgetClient - agent_media events', () => {
       (e) => events.push(e)
     );
 
-    // Unified streams each media item as its own block (media_start/complete),
+    // Wire streams each media item as its own block (media_start/complete),
     // so each renders as its own synthetic message with a single content part.
     const mediaMessages = collectMediaMessages(events);
     expect(mediaMessages).toHaveLength(3);
@@ -3660,8 +3980,8 @@ describe('AgentWidgetClient - version header', () => {
   });
 });
 
-describe('AgentWidgetClient - Unified event vocabulary (default in 4.0)', () => {
-  const unifiedTextStream = (execId: string) => [
+describe('AgentWidgetClient - Wire event vocabulary (default in 4.0)', () => {
+  const sampleTextStream = (execId: string) => [
     sseEvent('execution_start', { kind: 'agent', executionId: execId, agentId: 'virtual', agentName: 'Test', maxTurns: 1, startedAt: new Date().toISOString(), seq: 1 }),
     sseEvent('turn_start', { executionId: execId, id: 'turn_1', iteration: 1, role: 'assistant', seq: 2 }),
     sseEvent('text_start', { executionId: execId, id: 'text_1', role: 'assistant', seq: 3 }),
@@ -3672,14 +3992,14 @@ describe('AgentWidgetClient - Unified event vocabulary (default in 4.0)', () =>
     sseEvent('execution_complete', { kind: 'agent', executionId: execId, success: true, completedAt: new Date().toISOString(), seq: 8 }),
   ];
 
-  it('does not append an events param to the dispatch URL (unified is the default wire)', async () => {
+  it('does not append an events param to the dispatch URL (the wire is the only format)', async () => {
     let capturedUrl = '';
     global.fetch = vi.fn().mockImplementation(async (url: string) => {
       capturedUrl = url;
       const encoder = new TextEncoder();
       const stream = new ReadableStream({
         start(c) {
-          for (const e of unifiedTextStream('exec_u')) c.enqueue(encoder.encode(e));
+          for (const e of sampleTextStream('exec_u')) c.enqueue(encoder.encode(e));
           c.close();
         },
       });
@@ -3697,10 +4017,10 @@ describe('AgentWidgetClient - Unified event vocabulary (default in 4.0)', () =>
     expect(capturedUrl).not.toContain('events=');
   });
 
-  it('renders a unified stream through the internal handlers with no config flag', async () => {
+  it('renders a wire stream through the internal handlers with no config flag', async () => {
     const events: AgentWidgetEvent[] = [];
     const execId = 'exec_u1';
-    global.fetch = createRawStreamFetch(unifiedTextStream(execId));
+    global.fetch = createRawStreamFetch(sampleTextStream(execId));
 
     const client = new AgentWidgetClient({
       apiUrl: 'http://localhost:8000',