@runtypelabs/persona 3.9.2 → 3.10.1

package/src/client.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { AgentWidgetClient } from './client';
+import { AgentWidgetClient, preferFinalStructuredContent } from './client';
 import { AgentWidgetEvent, AgentWidgetMessage } from './types';
 import { createJsonStreamParser } from './utils/formatting';
 
@@ -1838,5 +1838,316 @@ describe('AgentWidgetClient - partId Text/Tool Interleaving', () => {
     // Tool message exists
     expect(toolMsgs.length).toBe(1);
   });
+
+  async function runSealedSegmentReconciliationTest(opts: {
+    parserMatchContent: string;
+    stepCompleteResponse: string;
+    expectedRawContent: string;
+  }) {
+    vi.useFakeTimers();
+    const events: AgentWidgetEvent[] = [];
+
+    const delayedJsonParser = () => {
+      let extractedText: string | null = null;
+      return {
+        processChunk: (accumulatedContent: string) =>
+          new Promise<{ text: string; raw: string } | null>((resolve) => {
+            setTimeout(() => {
+              if (accumulatedContent === opts.parserMatchContent) {
+                extractedText = 'Tool returned a result.';
+                resolve({ text: extractedText, raw: accumulatedContent });
+                return;
+              }
+              resolve(null);
+            }, 0);
+          }),
+        getExtractedText: () => extractedText,
+        close: async () => {}
+      };
+    };
+
+    const encoder = new TextEncoder();
+    global.fetch = vi.fn().mockImplementation(async () => {
+      const stream = new ReadableStream({
+        start(controller) {
+          const e = (eventType: string, data: Record<string, unknown>) =>
+            controller.enqueue(encoder.encode(`event: ${eventType}\ndata: ${JSON.stringify({ type: eventType, ...data })}\n\n`));
+
+          e('flow_start', { flowId: 'f1', flowName: 'Test', totalSteps: 1 });
+          e('tool_start', { toolId: 'tc_1', name: 'test_tool', toolType: 'custom', startedAt: new Date().toISOString() });
+          e('tool_complete', { toolId: 'tc_1', name: 'test_tool', success: true, completedAt: new Date().toISOString(), executionTime: 0 });
+          e('text_start', { partId: 'text_1', messageId: 'msg_s1', seq: 1 });
+          e('step_delta', {
+            id: 's1',
+            text: '{"text":"Tool returned a re',
+            partId: 'text_1',
+            messageId: 'msg_s1',
+            seq: 2
+          });
+          e('text_end', { partId: 'text_1', messageId: 'msg_s1', seq: 3 });
+          e('step_complete', {
+            id: 's1',
+            name: 'Response',
+            stepType: 'prompt',
+            success: true,
+            result: { response: opts.stepCompleteResponse },
+            executionTime: 500
+          });
+          e('flow_complete', { success: true });
+          controller.close();
+        }
+      });
+      return { ok: true, body: stream };
+    });
+
+    const client = new AgentWidgetClient({
+      apiUrl: 'http://localhost:8000',
+      streamParser: delayedJsonParser
+    });
+    await client.dispatch(
+      { messages: [{ id: 'usr_1', role: 'user', content: 'Call tool', createdAt: new Date().toISOString() }] },
+      (event) => events.push(event)
+    );
+    await vi.runAllTimersAsync();
+    vi.useRealTimers();
+
+    const messageEvents = events.filter(e => e.type === 'message');
+    const messagesById = new Map<string, AgentWidgetMessage>();
+    for (const event of messageEvents) {
+      if (event.type === 'message') messagesById.set(event.message.id, event.message);
+    }
+
+    const allMessages = Array.from(messagesById.values());
+    const assistantTexts = allMessages
+      .filter(m => m.role === 'assistant' && !m.variant)
+      .sort((a, b) => (a.sequence ?? 0) - (b.sequence ?? 0));
+    const toolMsgs = allMessages.filter(m => m.variant === 'tool');
+
+    expect(assistantTexts.length).toBe(1);
+    expect(assistantTexts[0].content).toBe('Tool returned a result.');
+    expect(assistantTexts[0].rawContent).toBe(opts.expectedRawContent);
+    expect(assistantTexts[0].streaming).toBe(false);
+    expect(toolMsgs.length).toBe(1);
+  }
+
+  it('should reconcile a sealed text segment with async parser output from step_complete', async () => {
+    await runSealedSegmentReconciliationTest({
+      parserMatchContent: '{"text":"Tool returned a result."',
+      stepCompleteResponse: 'Tool returned a result.',
+      expectedRawContent: '{"text":"Tool returned a re',
+    });
+  });
+
+  it('should prefer the authoritative final structured response when reconciling a sealed segment', async () => {
+    await runSealedSegmentReconciliationTest({
+      parserMatchContent: '{"text":"Tool returned a result."}',
+      stepCompleteResponse: '{"text":"Tool returned a result."}',
+      expectedRawContent: '{"text":"Tool returned a result."}',
+    });
+  });
+});
+
+describe('preferFinalStructuredContent', () => {
+  it('returns finalString when rawBuffer is undefined', () => {
+    expect(preferFinalStructuredContent(undefined, 'hello')).toBe('hello');
+  });
+
+  it('returns finalString when rawBuffer is empty/whitespace', () => {
+    expect(preferFinalStructuredContent('', 'hello')).toBe('hello');
+    expect(preferFinalStructuredContent('   ', 'hello')).toBe('hello');
+  });
+
+  it('returns rawBuffer when finalString is empty/whitespace', () => {
+    expect(preferFinalStructuredContent('{"text":"hi"}', '')).toBe('{"text":"hi"}');
+    expect(preferFinalStructuredContent('{"text":"hi"}', '  ')).toBe('{"text":"hi"}');
+  });
+
+  it('returns rawBuffer when final is plain text (not structured)', () => {
+    expect(preferFinalStructuredContent('{"text":"hi"}', 'plain text')).toBe('{"text":"hi"}');
+  });
+
+  it('returns finalString when raw is plain text but final is structured', () => {
+    expect(preferFinalStructuredContent('partial plain', '{"text":"hi"}')).toBe('{"text":"hi"}');
+  });
+
+  it('returns finalString when both are identical structured content', () => {
+    const json = '{"text":"hello"}';
+    expect(preferFinalStructuredContent(json, json)).toBe(json);
+  });
+
+  it('returns finalString when final is a superset of the raw buffer', () => {
+    expect(preferFinalStructuredContent(
+      '{"text":"hel',
+      '{"text":"hello"}'
+    )).toBe('{"text":"hello"}');
+  });
+
+  it('returns finalString when final is parseable JSON but raw is not', () => {
+    expect(preferFinalStructuredContent(
+      '{"text":"hel',
+      '{"text":"hello"}'
+    )).toBe('{"text":"hello"}');
+  });
+
+  it('returns rawBuffer when both are structured but neither is a prefix of the other and both parse', () => {
+    expect(preferFinalStructuredContent(
+      '{"text":"segment two"}',
+      '{"text":"full response with segment one and two"}'
+    )).toBe('{"text":"segment two"}');
+  });
+
+  it('returns rawBuffer when both are structured, different, and raw parses', () => {
+    expect(preferFinalStructuredContent(
+      '{"text":"short"}',
+      '{"text":"different content"}'
+    )).toBe('{"text":"short"}');
+  });
+
+  it('returns finalString when final parses but raw does not (partial JSON)', () => {
+    expect(preferFinalStructuredContent(
+      '{"text":"incomp',
+      '{"text":"complete"}'
+    )).toBe('{"text":"complete"}');
+  });
+
+  it('handles XML-shaped content as structured', () => {
+    expect(preferFinalStructuredContent(
+      '<response>partial',
+      '<response>full</response>'
+    )).toBe('<response>partial');
+  });
+
+  it('handles array-shaped JSON content as structured', () => {
+    expect(preferFinalStructuredContent(
+      '[{"text":"par',
+      '[{"text":"partial"}]'
+    )).toBe('[{"text":"partial"}]');
+  });
+});
+
+describe('AgentWidgetClient - Out-of-Order Sequence Reordering', () => {
+  it('should reorder step_delta chunks by seq when events arrive out of order', async () => {
+    const events: AgentWidgetEvent[] = [];
+
+    const client = new AgentWidgetClient({ apiUrl: 'http://localhost:8000' });
+
+    global.fetch = vi.fn().mockImplementation(async () => {
+      const encoder = new TextEncoder();
+      const stream = new ReadableStream({
+        start(controller) {
+          const e = (data: any) => {
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}\n\n`));
+          };
+          e({ type: 'flow_start', flowId: 'f1', flowName: 'Test', totalSteps: 1 });
+          e({ type: 'step_start', id: 's1', name: 'Prompt', stepType: 'prompt', index: 1, totalSteps: 1 });
+          // Send chunks out of order (seq 3 before seq 2)
+          e({ type: 'step_delta', id: 's1', text: 'Hello', partId: 'text_0', seq: 1 });
+          e({ type: 'step_delta', id: 's1', text: ' world', partId: 'text_0', seq: 3 });
+          e({ type: 'step_delta', id: 's1', text: ' beautiful', partId: 'text_0', seq: 2 });
+          e({ type: 'step_delta', id: 's1', text: '!', partId: 'text_0', seq: 4 });
+          e({ type: 'step_complete', id: 's1', name: 'Prompt', success: true });
+          e({ type: 'flow_complete', success: true });
+          controller.close();
+        },
+      });
+      return { ok: true, body: stream };
+    });
+
+    await client.dispatch({ messages: [] }, (event) => events.push(event));
+
+    const messageEvents = events.filter(
+      (e): e is AgentWidgetEvent & { type: 'message' } => e.type === 'message'
+    );
+    const finalMessages = messageEvents.filter((e) => !e.message.streaming);
+    expect(finalMessages.length).toBeGreaterThan(0);
+
+    const lastFinal = finalMessages[finalMessages.length - 1];
+    // Content should be in seq order, not arrival order
+    expect(lastFinal.message.content).toBe('Hello beautiful world!');
+  });
+
+  it('should reorder reason_delta chunks by sequenceIndex', async () => {
+    const events: AgentWidgetEvent[] = [];
+
+    const client = new AgentWidgetClient({ apiUrl: 'http://localhost:8000' });
+
+    global.fetch = vi.fn().mockImplementation(async () => {
+      const encoder = new TextEncoder();
+      const stream = new ReadableStream({
+        start(controller) {
+          const e = (data: any) => {
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}\n\n`));
+          };
+          e({ type: 'flow_start', flowId: 'f1', flowName: 'Test', totalSteps: 1 });
+          e({ type: 'step_start', id: 's1', name: 'Prompt', stepType: 'prompt', index: 1, totalSteps: 1 });
+          e({ type: 'reason_start', reasoningId: 'r1', hidden: false, done: false });
+          // Send reasoning chunks out of order
+          e({ type: 'reason_delta', reasoningId: 'r1', reasoningText: 'I ', hidden: false, done: false, sequenceIndex: 1 });
+          e({ type: 'reason_delta', reasoningId: 'r1', reasoningText: 'about', hidden: false, done: false, sequenceIndex: 3 });
+          e({ type: 'reason_delta', reasoningId: 'r1', reasoningText: 'think ', hidden: false, done: false, sequenceIndex: 2 });
+          e({ type: 'reason_delta', reasoningId: 'r1', reasoningText: ' this.', hidden: false, done: false, sequenceIndex: 4 });
+          e({ type: 'reason_complete', reasoningId: 'r1', hidden: false, done: true });
+          e({ type: 'step_delta', id: 's1', text: 'Result', partId: 'text_0' });
+          e({ type: 'step_complete', id: 's1', name: 'Prompt', success: true });
+          e({ type: 'flow_complete', success: true });
+          controller.close();
+        },
+      });
+      return { ok: true, body: stream };
+    });
+
+    await client.dispatch({ messages: [] }, (event) => events.push(event));
+
+    const messageEvents = events.filter(
+      (e): e is AgentWidgetEvent & { type: 'message' } => e.type === 'message'
+    );
+    const reasoningMsgs = messageEvents.filter(
+      (e) => e.message.reasoning && e.message.reasoning.chunks.length > 0
+    );
+    expect(reasoningMsgs.length).toBeGreaterThan(0);
+
+    const lastReasoning = reasoningMsgs[reasoningMsgs.length - 1];
+    // Reasoning chunks should be in sequenceIndex order
+    const fullReasoning = lastReasoning.message.reasoning!.chunks.join('');
+    expect(fullReasoning).toBe('I think about this.');
+  });
+
+  it('should handle step_delta without seq gracefully (no reordering)', async () => {
+    const events: AgentWidgetEvent[] = [];
+
+    const client = new AgentWidgetClient({ apiUrl: 'http://localhost:8000' });
+
+    global.fetch = vi.fn().mockImplementation(async () => {
+      const encoder = new TextEncoder();
+      const stream = new ReadableStream({
+        start(controller) {
+          const e = (data: any) => {
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}\n\n`));
+          };
+          e({ type: 'flow_start', flowId: 'f1', flowName: 'Test', totalSteps: 1 });
+          e({ type: 'step_start', id: 's1', name: 'Prompt', stepType: 'prompt', index: 1, totalSteps: 1 });
+          // No seq field — should append in arrival order
+          e({ type: 'step_delta', id: 's1', text: 'Hello ' });
+          e({ type: 'step_delta', id: 's1', text: 'world' });
+          e({ type: 'step_delta', id: 's1', text: '!' });
+          e({ type: 'step_complete', id: 's1', name: 'Prompt', success: true });
+          e({ type: 'flow_complete', success: true });
+          controller.close();
+        },
+      });
+      return { ok: true, body: stream };
+    });
+
+    await client.dispatch({ messages: [] }, (event) => events.push(event));
+
+    const messageEvents = events.filter(
+      (e): e is AgentWidgetEvent & { type: 'message' } => e.type === 'message'
+    );
+    const finalMessages = messageEvents.filter((e) => !e.message.streaming);
+    expect(finalMessages.length).toBeGreaterThan(0);
+
+    const lastFinal = finalMessages[finalMessages.length - 1];
+    expect(lastFinal.message.content).toBe('Hello world!');
+  });
 });