@aleph-alpha/chat-kit 1.3.0 → 1.4.0

package/src/adapters/responses-api.spec.ts

@@ -0,0 +1,365 @@
+import { useMessageHandler } from '../handlers/useMessageHandler';
+import type { MessageContent, MessageTextContent } from '../types';
+import {
+  responsesToTree,
+  type ResponseOutputMessage,
+  type ResponseOutputReasoning,
+  type ResponseOutputTool,
+  type StoredResponse,
+} from './responses-api';
+
+function getText(content: MessageContent[]): string {
+  return content
+    .filter((c): c is MessageTextContent => c.type === 'text')
+    .map((c) => c.text)
+    .join('');
+}
+
+function makeResponse(
+  overrides: Partial<StoredResponse> & { id: string },
+): StoredResponse {
+  return {
+    object: 'response',
+    created_at: 1_777_456_700,
+    completed_at: 1_777_456_701,
+    status: 'completed',
+    model: 'pharia-1',
+    output: [],
+    request_input: [],
+    ...overrides,
+  };
+}
+
+function userInput(text: string): Record<string, unknown> {
+  return { role: 'user', content: text };
+}
+
+function assistantOutput(id: string, text: string): ResponseOutputMessage {
+  return {
+    type: 'message',
+    id,
+    status: 'completed',
+    role: 'assistant',
+    content: [{ type: 'output_text', text }],
+  };
+}
+
+function reasoningOutput(id: string, text: string): ResponseOutputReasoning {
+  return {
+    type: 'reasoning',
+    id,
+    status: 'completed',
+    role: null,
+    content: [{ type: 'reasoning_text', text }],
+  };
+}
+
+function toolOutput(
+  overrides: Partial<ResponseOutputTool> & { id: string },
+): ResponseOutputTool {
+  return {
+    type: 'mcp_list_tools',
+    server_label: 'firecrawl',
+    tools: [],
+    ...overrides,
+  };
+}
+
+describe('responsesToTree', () => {
+  it('returns an empty tree for an empty response list', () => {
+    expect(responsesToTree([])).toEqual({ nodes: {}, rootId: null });
+  });
+
+  it('builds a linear tree from a single response with one user input and one assistant output', () => {
+    const tree = responsesToTree([
+      makeResponse({
+        id: 'r1',
+        request_input: [userInput('Hello')],
+        output: [assistantOutput('msg-a1', 'Hi there')],
+      }),
+    ]);
+
+    const ids = Object.keys(tree.nodes);
+    expect(ids).toHaveLength(2);
+
+    const userNode = tree.nodes['user-r1-0']!;
+    expect(userNode.role).toBe('user');
+    expect(userNode.parentId).toBeNull();
+    expect(getText(userNode.content)).toBe('Hello');
+
+    const assistantNode = tree.nodes['msg-a1']!;
+    expect(assistantNode.role).toBe('assistant');
+    expect(assistantNode.parentId).toBe('user-r1-0');
+    expect(getText(assistantNode.content)).toBe('Hi there');
+
+    expect(tree.rootId).toBe('user-r1-0');
+  });
+
+  it('chains a follow-up response under the previous assistant message via previous_response_id', () => {
+    const tree = responsesToTree([
+      makeResponse({
+        id: 'r1',
+        request_input: [userInput('First')],
+        output: [assistantOutput('msg-a1', 'A1')],
+      }),
+      makeResponse({
+        id: 'r2',
+        previous_response_id: 'r1',
+        request_input: [userInput('Second')],
+        output: [assistantOutput('msg-a2', 'A2')],
+      }),
+    ]);
+
+    expect(tree.nodes['user-r2-0']!.parentId).toBe('msg-a1');
+    expect(tree.nodes['msg-a2']!.parentId).toBe('user-r2-0');
+    expect(tree.rootId).toBe('user-r1-0');
+  });
+
+  it('treats sibling responses (same previous_response_id) as branches and surfaces the latest as active', () => {
+    const tree = responsesToTree([
+      makeResponse({
+        id: 'r1',
+        request_input: [userInput('Hello')],
+        output: [assistantOutput('msg-a1', 'Hi')],
+      }),
+      makeResponse({
+        id: 'r2',
+        previous_response_id: 'r1',
+        request_input: [userInput('Branch A')],
+        output: [assistantOutput('msg-a2', 'A')],
+      }),
+      makeResponse({
+        id: 'r3',
+        previous_response_id: 'r1',
+        request_input: [userInput('Branch B')],
+        output: [assistantOutput('msg-a3', 'B')],
+      }),
+    ]);
+
+    const a1 = tree.nodes['msg-a1']!;
+    expect(a1.childrenIds).toEqual(['user-r2-0', 'user-r3-0']);
+    expect(a1.activeChildIndex).toBe(1);
+  });
+
+  it('skips responses with no visible content but keeps descendants attached to the parent tail', () => {
+    const tree = responsesToTree([
+      makeResponse({
+        id: 'r1',
+        request_input: [userInput('Hello')],
+        output: [assistantOutput('msg-a1', 'Hi')],
+      }),
+      makeResponse({
+        id: 'r2',
+        previous_response_id: 'r1',
+        request_input: [],
+        output: [],
+      }),
+      makeResponse({
+        id: 'r3',
+        previous_response_id: 'r2',
+        request_input: [userInput('Follow-up')],
+        output: [assistantOutput('msg-a3', 'Reply')],
+      }),
+    ]);
+
+    expect(tree.nodes['user-r3-0']!.parentId).toBe('msg-a1');
+  });
+
+  it('extracts text from string content as well as output_text / text parts', () => {
+    const tree = responsesToTree([
+      makeResponse({
+        id: 'r1',
+        request_input: [userInput('plain string')],
+        output: [
+          {
+            type: 'message',
+            id: 'msg-mixed',
+            status: 'completed',
+            role: 'assistant',
+            content: [
+              { type: 'output_text', text: 'first ' },
+              { type: 'reasoning_summary', text: 'should-be-ignored' },
+              { type: 'text', text: 'second' },
+            ],
+          },
+        ],
+      }),
+    ]);
+
+    expect(getText(tree.nodes['user-r1-0']!.content)).toBe('plain string');
+    expect(getText(tree.nodes['msg-mixed']!.content)).toBe('first second');
+  });
+
+  it('merges reasoning, tool calls, and message text into a single assistant node, preserving wire order', () => {
+    const tree = responsesToTree([
+      makeResponse({
+        id: 'r1',
+        request_input: [userInput('Hello')],
+        output: [
+          toolOutput({
+            id: 'tool-list',
+            type: 'mcp_list_tools',
+            server_label: 'firecrawl',
+            tools: [{ name: 'firecrawl_scrape' }],
+          }),
+          reasoningOutput('rs-1', 'thinking out loud'),
+          toolOutput({
+            id: 'tool-call-1',
+            type: 'mcp_call',
+            name: 'firecrawl_scrape',
+          }),
+          assistantOutput('msg-a1', 'Hi'),
+        ],
+      }),
+    ]);
+
+    // Reasoning and tool items don't get their own tree nodes; they are
+    // rolled up onto the assistant message.
+    expect(tree.nodes['tool-list']).toBeUndefined();
+    expect(tree.nodes['rs-1']).toBeUndefined();
+    expect(tree.nodes['tool-call-1']).toBeUndefined();
+
+    const assistant = tree.nodes['msg-a1']!;
+    expect(assistant).toBeDefined();
+    // mcp_list_tools is informational and skipped; reasoning + mcp_call +
+    // text remain in their original order.
+    expect(assistant.content).toHaveLength(3);
+    expect(assistant.content[0]).toMatchObject({
+      type: 'reasoning',
+      id: 'rs-1',
+      text: 'thinking out loud',
+      status: 'completed',
+    });
+    expect(assistant.content[1]).toMatchObject({
+      type: 'tool',
+      id: 'tool-call-1',
+      name: 'firecrawl_scrape',
+    });
+    expect(assistant.content[2]).toMatchObject({
+      type: 'text',
+      id: 'msg-a1',
+      text: 'Hi',
+      status: 'completed',
+    });
+  });
+
+  it('also picks up function_call / tool_call outputs as tool parts', () => {
+    const tree = responsesToTree([
+      makeResponse({
+        id: 'r1',
+        request_input: [userInput('Hello')],
+        output: [
+          toolOutput({ id: 'fn-1', type: 'function_call', name: 'lookup' }),
+          toolOutput({ id: 'tc-1', type: 'tool_call', name: 'shell' }),
+          assistantOutput('msg-a1', 'Done'),
+        ],
+      }),
+    ]);
+
+    const assistant = tree.nodes['msg-a1']!;
+    expect(assistant.content).toHaveLength(3);
+    expect(assistant.content[0]).toMatchObject({
+      type: 'tool',
+      id: 'fn-1',
+      name: 'lookup',
+    });
+    expect(assistant.content[1]).toMatchObject({
+      type: 'tool',
+      id: 'tc-1',
+      name: 'shell',
+    });
+    expect(assistant.content[2].type).toBe('text');
+  });
+
+  it('creates an assistant node from reasoning / tool outputs even when no message output is present', () => {
+    const tree = responsesToTree([
+      makeResponse({
+        id: 'r1',
+        request_input: [userInput('Hello')],
+        output: [
+          reasoningOutput('rs-1', 'planning'),
+          toolOutput({ id: 'tool-1', type: 'mcp_call', name: 'search' }),
+        ],
+      }),
+    ]);
+
+    const assistant = tree.nodes['assistant-r1']!;
+    expect(assistant).toBeDefined();
+    expect(assistant.role).toBe('assistant');
+    expect(assistant.content).toHaveLength(2);
+    expect(assistant.content[0]).toMatchObject({
+      type: 'reasoning',
+      text: 'planning',
+    });
+    expect(assistant.content[1].type).toBe('tool');
+  });
+
+  it('omits reasoning text when no reasoning_text parts are present', () => {
+    const tree = responsesToTree([
+      makeResponse({
+        id: 'r1',
+        request_input: [userInput('Hello')],
+        output: [
+          {
+            type: 'reasoning',
+            id: 'rs-empty',
+            status: 'completed',
+            role: null,
+            content: [],
+          },
+          assistantOutput('msg-a1', 'Hi'),
+        ],
+      }),
+    ]);
+
+    const reasoning = tree.nodes['msg-a1']!.content[0];
+    expect(reasoning.type).toBe('reasoning');
+    if (reasoning.type === 'reasoning') {
+      expect(reasoning.text).toBeUndefined();
+    }
+  });
+
+  it('chains the next response under a reasoning-only assistant turn', () => {
+    const tree = responsesToTree([
+      makeResponse({
+        id: 'r1',
+        request_input: [userInput('Hello')],
+        output: [reasoningOutput('rs-1', 'planning')],
+      }),
+      makeResponse({
+        id: 'r2',
+        previous_response_id: 'r1',
+        request_input: [userInput('Follow-up')],
+        output: [assistantOutput('msg-a2', 'Reply')],
+      }),
+    ]);
+
+    expect(tree.nodes['rs-1']).toBeUndefined();
+    expect(tree.nodes['assistant-r1']).toBeDefined();
+    expect(tree.nodes['user-r2-0']!.parentId).toBe('assistant-r1');
+    expect(tree.nodes['msg-a2']!.parentId).toBe('user-r2-0');
+  });
+});
+
+describe('responsesToTree + useMessageHandler.setTree', () => {
+  it('hydrates a handler from a Responses-API list via the documented adapter pattern', () => {
+    const handler = useMessageHandler();
+    handler.setTree(
+      responsesToTree([
+        makeResponse({
+          id: 'r1',
+          request_input: [userInput('Hello')],
+          output: [assistantOutput('msg-a1', 'Hi')],
+        }),
+      ]),
+    );
+
+    expect(handler.messages.value).toHaveLength(2);
+    expect(handler.messages.value.map((m) => m.role)).toEqual([
+      'user',
+      'assistant',
+    ]);
+    expect(getText(handler.messages.value[0].content)).toBe('Hello');
+    expect(getText(handler.messages.value[1].content)).toBe('Hi');
+  });
+});