@runtypelabs/persona 4.6.1 → 4.8.0

package/src/client.test.ts

@@ -1,10 +1,90 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { AgentWidgetClient, preferFinalStructuredContent } from './client';
-import { AgentWidgetEvent, AgentWidgetMessage } from './types';
+import { AgentWidgetEvent, AgentWidgetMessage, AgentWidgetArtifactsFeature } from './types';
 import { createJsonStreamParser } from './utils/formatting';
 import { VERSION } from './version';
 import { createUnifiedEventWrite } from './utils/__fixtures__/unified-translator.oracle';
 
+describe('AgentWidgetClient - dispatch abort signals', () => {
+  const message = {
+    id: 'usr_abort',
+    role: 'user' as const,
+    content: 'stop',
+    createdAt: '2026-07-11T00:00:00.000Z',
+  };
+
+  it.each([
+    ['proxy', { apiUrl: 'https://api.example.com/chat' }],
+    [
+      'agent',
+      {
+        apiUrl: 'https://api.example.com/agents',
+        agent: { name: 'Test', model: 'openai:gpt-4o-mini', systemPrompt: 'test' },
+      },
+    ],
+    [
+      'client token',
+      { apiUrl: 'https://api.runtype.com', clientToken: 'ct_live_demo' },
+    ],
+  ] as const)(
+    'rejects a pre-aborted signal before starting %s dispatch work',
+    async (_mode, config) => {
+      const getHeaders = vi.fn(() => ({ Authorization: 'test' }));
+      const contextProvider = vi.fn(async () => ({ page: 'context' }));
+      const client = new AgentWidgetClient({
+        ...config,
+        getHeaders,
+        contextProviders: [contextProvider],
+      });
+      const fetchSpy = vi.fn();
+      global.fetch = fetchSpy;
+      const events: AgentWidgetEvent[] = [];
+      const abortController = new AbortController();
+      abortController.abort();
+
+      await expect(
+        client.dispatch(
+          { messages: [message], signal: abortController.signal },
+          (event) => events.push(event)
+        )
+      ).rejects.toMatchObject({ name: 'AbortError' });
+
+      expect(fetchSpy).not.toHaveBeenCalled();
+      expect(getHeaders).not.toHaveBeenCalled();
+      expect(contextProvider).not.toHaveBeenCalled();
+      expect(events).toEqual([]);
+    }
+  );
+
+  it('still forwards an abort that occurs after dispatch starts', async () => {
+    const abortController = new AbortController();
+    let requestSignal: AbortSignal | undefined;
+    let markFetchStarted!: () => void;
+    const fetchStarted = new Promise<void>((resolve) => {
+      markFetchStarted = resolve;
+    });
+    global.fetch = vi.fn((_url: string | URL | Request, init?: RequestInit) => {
+      requestSignal = init?.signal ?? undefined;
+      markFetchStarted();
+      return new Promise<Response>((_resolve, reject) => {
+        requestSignal?.addEventListener('abort', () => reject(requestSignal?.reason));
+      });
+    });
+    const client = new AgentWidgetClient({ apiUrl: 'https://api.example.com/chat' });
+    const dispatch = client.dispatch(
+      { messages: [message], signal: abortController.signal },
+      () => undefined
+    );
+
+    await fetchStarted;
+    abortController.abort();
+
+    await expect(dispatch).rejects.toMatchObject({ name: 'AbortError' });
+    expect(requestSignal).toBe(abortController.signal);
+    expect(requestSignal?.aborted).toBe(true);
+  });
+});
+
 describe('AgentWidgetClient - Empty Message Filtering', () => {
   let client: AgentWidgetClient;
   let events: AgentWidgetEvent[] = [];
@@ -3845,6 +3925,240 @@ describe('AgentWidgetClient - diff-only clientTools (client-token)', () => {
   });
 });
 
+// ============================================================================
+// Mid-run clientTools refresh on resume (client-token mode, core#5361)
+// ============================================================================
+
+describe('AgentWidgetClient - resumeFlow clientTools refresh (client-token)', () => {
+  const TOOLS = [
+    { name: 'add_to_cart', description: 'Add to cart', origin: 'webmcp' as const },
+  ];
+
+  function sse(): Response {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+      start(c) {
+        c.enqueue(encoder.encode('data: {"type":"done"}\n\n'));
+        c.close();
+      },
+    });
+    return new Response(stream, { headers: { 'Content-Type': 'text/event-stream' } });
+  }
+
+  // A client-token client with a live session (so initSession short-circuits)
+  // and a stubbed bridge whose snapshot is read lazily via `tools()`.
+  function makeClient(tools: () => unknown[]) {
+    const client = new AgentWidgetClient({
+      clientToken: 'ct_live_demo',
+      apiUrl: 'https://api.runtype.com',
+    });
+    (client as unknown as { clientSession: { sessionId: string; expiresAt: Date } }).clientSession = {
+      sessionId: 'cs_resume_1',
+      expiresAt: new Date(Date.now() + 600_000),
+    };
+    (client as unknown as { webMcpBridge: { snapshotForDispatch: () => unknown[] } | null }).webMcpBridge = {
+      snapshotForDispatch: () => tools(),
+    };
+    return client;
+  }
+
+  const userMsg = () => ({
+    messages: [{ id: 'u1', role: 'user' as const, content: 'hi', createdAt: new Date().toISOString() }],
+    assistantMessageId: 'a1',
+  });
+
+  let chatBodies: Array<Record<string, unknown>>;
+  let resumeBodies: Array<Record<string, unknown>>;
+  beforeEach(() => {
+    chatBodies = [];
+    resumeBodies = [];
+  });
+
+  // Records chat/resume bodies; `onResume` (keyed by 1-based resume call
+  // index) can override the response for a given resume call.
+  function captureFetch(onResume?: Record<number, () => Response>) {
+    let resumeCall = 0;
+    return vi.fn().mockImplementation(async (url: string, init: { body: string }) => {
+      if (url.includes('/client/chat')) chatBodies.push(JSON.parse(init.body));
+      if (url.includes('/client/resume')) {
+        resumeBodies.push(JSON.parse(init.body));
+        resumeCall += 1;
+        const override = onResume?.[resumeCall];
+        if (override) return override();
+      }
+      return sse();
+    });
+  }
+
+  it('first send of a session ships the full tool list AND a fingerprint on resume', async () => {
+    global.fetch = captureFetch();
+    const client = makeClient(() => TOOLS);
+
+    const response = await client.resumeFlow('exec_1', { call_1: 'ok' });
+
+    expect(response.ok).toBe(true);
+    expect(resumeBodies).toHaveLength(1);
+    expect(resumeBodies[0]!.executionId).toBe('exec_1');
+    expect(resumeBodies[0]!.toolOutputs).toEqual({ call_1: 'ok' });
+    expect(resumeBodies[0]!.clientTools).toEqual(TOOLS);
+    expect(typeof resumeBodies[0]!.clientToolsFingerprint).toBe('string');
+  });
+
+  it('resume after an unchanged chat send is fingerprint-only', async () => {
+    global.fetch = captureFetch();
+    const client = makeClient(() => TOOLS);
+
+    await client.dispatch(userMsg(), () => undefined);
+    await client.resumeFlow('exec_1', { call_1: 'ok' });
+
+    expect(resumeBodies).toHaveLength(1);
+    expect(resumeBodies[0]!.clientTools).toBeUndefined();
+    expect(resumeBodies[0]!.clientToolsFingerprint).toBe(chatBodies[0]!.clientToolsFingerprint);
+  });
+
+  it('a successful resume full-send commits the shared cache: the next chat turn is fingerprint-only', async () => {
+    global.fetch = captureFetch();
+    const client = makeClient(() => TOOLS);
+
+    await client.resumeFlow('exec_1', { call_1: 'ok' });
+    await client.dispatch(userMsg(), () => undefined);
+
+    expect(resumeBodies[0]!.clientTools).toEqual(TOOLS);
+    expect(chatBodies).toHaveLength(1);
+    expect(chatBodies[0]!.clientTools).toBeUndefined();
+    expect(chatBodies[0]!.clientToolsFingerprint).toBe(resumeBodies[0]!.clientToolsFingerprint);
+  });
+
+  it('a changed registry (mid-run navigation) resends the full list on resume', async () => {
+    global.fetch = captureFetch();
+    let live = [...TOOLS];
+    const client = makeClient(() => live);
+
+    await client.dispatch(userMsg(), () => undefined);
+    live = [...TOOLS, { name: 'checkout', description: 'Checkout', origin: 'webmcp' as const }];
+    await client.resumeFlow('exec_1', { call_1: 'ok' });
+
+    expect(resumeBodies[0]!.clientTools).toEqual(live);
+    expect(resumeBodies[0]!.clientToolsFingerprint).not.toBe(chatBodies[0]!.clientToolsFingerprint);
+  });
+
+  it('a 409 client_tools_resend_required on resume retries exactly once with the full list', async () => {
+    global.fetch = captureFetch({
+      1: () =>
+        new Response(JSON.stringify({ error: 'client_tools_resend_required' }), {
+          status: 409,
+          headers: { 'Content-Type': 'application/json' },
+        }),
+    });
+    const client = makeClient(() => TOOLS);
+
+    await client.dispatch(userMsg(), () => undefined); // commits the fingerprint
+    const response = await client.resumeFlow('exec_1', { call_1: 'ok' });
+
+    expect(response.ok).toBe(true);
+    expect(resumeBodies).toHaveLength(2);
+    expect(resumeBodies[0]!.clientTools).toBeUndefined(); // fingerprint-only first
+    expect(resumeBodies[1]!.clientTools).toEqual(TOOLS); // retry carries the full list
+    // ...with the SAME executionId + toolOutputs (no double resume).
+    expect(resumeBodies[1]!.executionId).toBe(resumeBodies[0]!.executionId);
+    expect(resumeBodies[1]!.toolOutputs).toEqual(resumeBodies[0]!.toolOutputs);
+  });
+
+  it('any other 409 is returned once, body still readable (no retry, no consumed stream)', async () => {
+    global.fetch = captureFetch({
+      1: () =>
+        new Response(JSON.stringify({ error: 'execution_conflict' }), {
+          status: 409,
+          headers: { 'Content-Type': 'application/json' },
+        }),
+    });
+    const client = makeClient(() => TOOLS);
+
+    const response = await client.resumeFlow('exec_1', { call_1: 'ok' });
+
+    expect(response.status).toBe(409);
+    expect(resumeBodies).toHaveLength(1);
+    // The 409 probe used a clone, so callers can still parse the error body.
+    await expect(response.json()).resolves.toEqual({ error: 'execution_conflict' });
+  });
+
+  it('a failed resume does not commit the cache: the next chat turn resends full', async () => {
+    global.fetch = captureFetch({
+      1: () => new Response(JSON.stringify({ error: 'boom' }), { status: 500 }),
+    });
+    const client = makeClient(() => TOOLS);
+
+    const response = await client.resumeFlow('exec_1', { call_1: 'ok' });
+    expect(response.status).toBe(500);
+    await client.dispatch(userMsg(), () => undefined);
+
+    expect(chatBodies[0]!.clientTools).toEqual(TOOLS); // full, not fingerprint-only
+  });
+
+  it('registry vanished after a non-empty send: resume ships an explicit clientTools: []', async () => {
+    global.fetch = captureFetch();
+    let live: unknown[] = [...TOOLS];
+    const client = makeClient(() => live);
+
+    await client.dispatch(userMsg(), () => undefined); // non-empty send committed
+    live = []; // navigation landed on a page with no registry
+    await client.resumeFlow('exec_1', { call_1: 'ok' });
+
+    expect(resumeBodies[0]!.clientTools).toEqual([]);
+    expect(resumeBodies[0]!.clientToolsFingerprint).toBeUndefined();
+  });
+
+  it('an interleaved empty-tool chat turn does not lose the pending clear (Greptile P1)', async () => {
+    // Chat with tools (persisted server-side) → chat with an empty registry
+    // (omits both fields, so the paused execution's persisted tools survive)
+    // → resume must STILL send the explicit [] replace.
+    global.fetch = captureFetch();
+    let live: unknown[] = [...TOOLS];
+    const client = makeClient(() => live);
+
+    await client.dispatch(userMsg(), () => undefined); // non-empty send committed
+    live = [];
+    await client.dispatch(userMsg(), () => undefined); // empty chat: omits fields
+    expect(chatBodies[1]!.clientTools).toBeUndefined();
+    await client.resumeFlow('exec_1', { call_1: 'ok' });
+
+    expect(resumeBodies[0]!.clientTools).toEqual([]);
+    expect(resumeBodies[0]!.clientToolsFingerprint).toBeUndefined();
+
+    // The confirmed [] replace clears the flag: a second empty resume omits.
+    await client.resumeFlow('exec_1', { call_2: 'ok' });
+    expect(resumeBodies[1]!.clientTools).toBeUndefined();
+  });
+
+  it('empty registry with no prior send omits both fields', async () => {
+    global.fetch = captureFetch();
+    const client = makeClient(() => []);
+
+    await client.resumeFlow('exec_1', { call_1: 'ok' });
+
+    expect(resumeBodies[0]!.clientTools).toBeUndefined();
+    expect(resumeBodies[0]!.clientToolsFingerprint).toBeUndefined();
+  });
+
+  it('proxy-mode resume never adds clientTools fields (route does not accept them)', async () => {
+    const bodies: Array<Record<string, unknown>> = [];
+    global.fetch = vi.fn().mockImplementation(async (_url: string, init: { body: string }) => {
+      bodies.push(JSON.parse(init.body));
+      return sse();
+    });
+    const client = new AgentWidgetClient({ apiUrl: 'http://localhost:8000/api/chat/dispatch' });
+    (client as unknown as { webMcpBridge: { snapshotForDispatch: () => unknown[] } | null }).webMcpBridge = {
+      snapshotForDispatch: () => TOOLS,
+    };
+
+    await client.resumeFlow('exec_1', { call_1: 'ok' });
+
+    expect(bodies).toHaveLength(1);
+    expect(bodies[0]!.clientTools).toBeUndefined();
+    expect(bodies[0]!.clientToolsFingerprint).toBeUndefined();
+  });
+});
+
 describe('AgentWidgetClient - non-client-token paths always send full clientTools', () => {
   function sse(): Response {
     const encoder = new TextEncoder();
@@ -4043,3 +4357,188 @@ describe('AgentWidgetClient - Wire event vocabulary (default in 4.0)', () => {
     }
   });
 });
+
+describe('AgentWidgetClient - Artifact file metadata', () => {
+  const artifactFrames = (fileField: string | null): string[] => [
+    `data: {"type":"artifact_start","id":"a1","artifactType":"markdown","title":"outputs/cat.html"${
+      fileField === null ? '' : ',"file":' + fileField
+    }}\n\n`,
+    `data: {"type":"artifact_delta","id":"a1","delta":${JSON.stringify('```html\n<h1>hi</h1>\n```')}}\n\n`,
+    `data: {"type":"artifact_complete","id":"a1"}\n\n`,
+  ];
+
+  it('propagates valid file metadata to the artifact_start event and card props', async () => {
+    global.fetch = createRawStreamFetch(
+      artifactFrames('{"path":"outputs/cat.html","mimeType":"text/html","language":"html"}')
+    );
+    const client = new AgentWidgetClient({ apiUrl: 'http://localhost:8000' });
+    const events: AgentWidgetEvent[] = [];
+    await client.dispatch(
+      { messages: [{ id: 'u1', role: 'user', content: 'Hi', createdAt: new Date().toISOString() }] },
+      (e) => events.push(e)
+    );
+
+    const startEv = events.find((e) => e.type === 'artifact_start');
+    expect(startEv).toBeDefined();
+    if (startEv?.type === 'artifact_start') {
+      expect(startEv.file).toEqual({
+        path: 'outputs/cat.html',
+        mimeType: 'text/html',
+        language: 'html',
+      });
+    }
+
+    // The completed card message carries the file metadata in its rawContent props.
+    const cardMsgs = events.filter(
+      (e): e is Extract<AgentWidgetEvent, { type: 'message' }> =>
+        e.type === 'message' && e.message.id === 'artifact-ref-a1'
+    );
+    const lastCard = cardMsgs[cardMsgs.length - 1];
+    expect(lastCard).toBeDefined();
+    const props = JSON.parse(lastCard.message.rawContent ?? '{}').props;
+    expect(props.status).toBe('complete');
+    expect(props.file).toEqual({
+      path: 'outputs/cat.html',
+      mimeType: 'text/html',
+      language: 'html',
+    });
+    expect(props.markdown).toBe('```html\n<h1>hi</h1>\n```');
+  });
+
+  it('drops malformed file metadata without error', async () => {
+    global.fetch = createRawStreamFetch(artifactFrames('{"path":123}'));
+    const client = new AgentWidgetClient({ apiUrl: 'http://localhost:8000' });
+    const events: AgentWidgetEvent[] = [];
+    await client.dispatch(
+      { messages: [{ id: 'u1', role: 'user', content: 'Hi', createdAt: new Date().toISOString() }] },
+      (e) => events.push(e)
+    );
+
+    expect(events.some((e) => e.type === 'error')).toBe(false);
+    const startEv = events.find((e) => e.type === 'artifact_start');
+    expect(startEv).toBeDefined();
+    if (startEv?.type === 'artifact_start') {
+      expect(startEv.file).toBeUndefined();
+    }
+    const cardMsgs = events.filter(
+      (e): e is Extract<AgentWidgetEvent, { type: 'message' }> =>
+        e.type === 'message' && e.message.id === 'artifact-ref-a1'
+    );
+    const props = JSON.parse(cardMsgs[cardMsgs.length - 1].message.rawContent ?? '{}').props;
+    expect(props.file).toBeUndefined();
+  });
+});
+
+describe('AgentWidgetClient - Artifact display modes', () => {
+  const markdownArtifactFrames = (id = 'a1'): string[] => [
+    `data: {"type":"artifact_start","id":"${id}","artifactType":"markdown","title":"Notes"}\n\n`,
+    `data: {"type":"artifact_delta","id":"${id}","delta":"# Hello"}\n\n`,
+    `data: {"type":"artifact_complete","id":"${id}"}\n\n`,
+  ];
+  const componentArtifactFrames = (id = 'c1'): string[] => [
+    `data: {"type":"artifact_start","id":"${id}","artifactType":"component","title":"Chart","component":"MyChart"}\n\n`,
+    `data: {"type":"artifact_complete","id":"${id}"}\n\n`,
+  ];
+
+  const dispatchAndCollect = async (
+    frames: string[],
+    artifacts?: AgentWidgetArtifactsFeature
+  ): Promise<AgentWidgetEvent[]> => {
+    global.fetch = createRawStreamFetch(frames);
+    const client = new AgentWidgetClient({
+      apiUrl: 'http://localhost:8000',
+      ...(artifacts ? { features: { artifacts } } : {}),
+    });
+    const events: AgentWidgetEvent[] = [];
+    await client.dispatch(
+      { messages: [{ id: 'u1', role: 'user', content: 'Hi', createdAt: new Date().toISOString() }] },
+      (e) => events.push(e)
+    );
+    return events;
+  };
+
+  const blockMessagesFor = (events: AgentWidgetEvent[], artifactId: string) =>
+    events.filter(
+      (e): e is Extract<AgentWidgetEvent, { type: 'message' }> =>
+        e.type === 'message' && e.message.id === `artifact-ref-${artifactId}`
+    );
+
+  const componentNameOf = (msg: AgentWidgetMessage): string =>
+    JSON.parse(msg.rawContent ?? '{}').component;
+
+  it('injects PersonaArtifactCard when display is unset (default "panel")', async () => {
+    const events = await dispatchAndCollect(markdownArtifactFrames());
+    const msgs = blockMessagesFor(events, 'a1');
+    expect(msgs.length).toBeGreaterThan(0);
+    for (const m of msgs) {
+      expect(componentNameOf(m.message)).toBe('PersonaArtifactCard');
+    }
+  });
+
+  it('injects PersonaArtifactCard for display: "card" and display: "panel"', async () => {
+    for (const mode of ['card', 'panel'] as const) {
+      const events = await dispatchAndCollect(markdownArtifactFrames(), {
+        enabled: true,
+        display: mode,
+      });
+      const msgs = blockMessagesFor(events, 'a1');
+      expect(msgs.length).toBeGreaterThan(0);
+      expect(componentNameOf(msgs[0].message)).toBe('PersonaArtifactCard');
+    }
+  });
+
+  it('injects PersonaArtifactInline for display: "inline"', async () => {
+    const events = await dispatchAndCollect(markdownArtifactFrames(), {
+      enabled: true,
+      display: 'inline',
+    });
+    const msgs = blockMessagesFor(events, 'a1');
+    expect(msgs.length).toBeGreaterThan(0);
+    for (const m of msgs) {
+      expect(componentNameOf(m.message)).toBe('PersonaArtifactInline');
+    }
+    const startProps = JSON.parse(msgs[0].message.rawContent ?? '{}').props;
+    expect(startProps).toMatchObject({
+      artifactId: 'a1',
+      artifactType: 'markdown',
+      status: 'streaming',
+    });
+  });
+
+  it('resolves the mode per artifact type via display.byType', async () => {
+    const display: AgentWidgetArtifactsFeature['display'] = {
+      default: 'card',
+      byType: { component: 'inline' },
+    };
+
+    const mdEvents = await dispatchAndCollect(markdownArtifactFrames(), {
+      enabled: true,
+      display,
+    });
+    expect(componentNameOf(blockMessagesFor(mdEvents, 'a1')[0].message)).toBe(
+      'PersonaArtifactCard'
+    );
+
+    const compEvents = await dispatchAndCollect(componentArtifactFrames(), {
+      enabled: true,
+      display,
+    });
+    const compMsgs = blockMessagesFor(compEvents, 'c1');
+    expect(componentNameOf(compMsgs[0].message)).toBe('PersonaArtifactInline');
+    // Inline component artifacts carry the component name for the preview registry.
+    expect(JSON.parse(compMsgs[0].message.rawContent ?? '{}').props.component).toBe('MyChart');
+  });
+
+  it('embeds accumulated markdown and complete status in inline block props on artifact_complete', async () => {
+    const events = await dispatchAndCollect(markdownArtifactFrames(), {
+      enabled: true,
+      display: 'inline',
+    });
+    const msgs = blockMessagesFor(events, 'a1');
+    const last = msgs[msgs.length - 1];
+    expect(last.message.streaming).toBe(false);
+    const props = JSON.parse(last.message.rawContent ?? '{}').props;
+    expect(props.status).toBe('complete');
+    expect(props.markdown).toBe('# Hello');
+  });
+});