@runtypelabs/persona 4.2.0 → 4.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runtypelabs/persona",
-  "version": "4.2.0",
+  "version": "4.2.1",
   "description": "Themeable, pluggable streaming agent widget for websites, in plain JS with support for voice input and reasoning / tool output.",
   "type": "module",
   "main": "dist/index.cjs",

package/src/client.test.ts

@@ -1784,6 +1784,134 @@ 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

package/src/client.ts

@@ -1969,6 +1969,15 @@ export class AgentWidgetClient {
     // Execution kind, resolved from the leading `execution_start` frame. Drives
     // the agent-vs-flow branches that the single unified vocabulary collapses.
     let executionKind: "agent" | "flow" = "agent";
+    // Whether `executionKind` was set authoritatively by an `execution_start`
+    // frame. Continuation streams (e.g. a tool-driven `/resume`) do NOT re-emit
+    // `execution_start`, so a fresh `streamResponse` for the continuation starts
+    // with the default `"agent"`. For a flow that mis-routes the final
+    // prompt-step finalization and duplicates the last message (the streamed
+    // text block is sealed, then `step_complete.result.response` re-renders it as
+    // a second bubble). When `execution_start` is absent we recover the flow kind
+    // from the first flow `step_*` frame below.
+    let executionKindResolved = false;
     // Open turn id (from `turn_start`). Unified text/reasoning deltas carry their
     // own block id, not the turn id, so the turn id is threaded onto agentMetadata
     // from here.
@@ -1987,6 +1996,21 @@ export class AgentWidgetClient {
         const payloadType = seqReadyQueue[i].payloadType;
         const payload = seqReadyQueue[i].payload;
 
+        // Recover the execution kind on continuation streams that omit
+        // `execution_start` (e.g. a tool-driven `/resume`). Flow `step_*` frames
+        // carry a `stepType`; agent loops never do (they use `turn_*`). Without
+        // this, the continuation defaults to `"agent"` and a flow's final
+        // prompt-step finalization is duplicated. We only infer when no
+        // `execution_start` resolved the kind, so an explicit `agent` is never
+        // overridden.
+        if (
+          !executionKindResolved &&
+          executionKind !== "flow" &&
+          typeof (payload as { stepType?: unknown }).stepType === "string"
+        ) {
+          executionKind = "flow";
+        }
+
         if (payloadType === "reasoning_start") {
           // Nested flow-as-tool thinking (PR #4602): route to the parent tool's row.
           const rStartBlockId = typeof payload.id === "string" ? payload.id : null;
@@ -2543,6 +2567,7 @@ export class AgentWidgetClient {
         // ================================================================
         } else if (payloadType === "execution_start") {
           executionKind = payload.kind === "flow" ? "flow" : "agent";
+          executionKindResolved = true;
           if (executionKind === "agent") {
             agentExecution = {
               executionId: payload.executionId,