@geminilight/mindos 0.6.74 → 0.6.75

package/_standalone/__tests__/a2a/orchestrator.test.ts

@@ -0,0 +1,280 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { matchSkill, decompose, createPlan, executePlan } from '../../lib/a2a/orchestrator';
+import { discoverAgent, getDiscoveredAgents, clearRegistry } from '../../lib/a2a/client';
+
+const mockFetch = vi.fn();
+vi.stubGlobal('fetch', mockFetch);
+
+const MOCK_CARD_SEARCH = {
+  name: 'SearchAgent',
+  description: 'A search agent',
+  version: '1.0.0',
+  provider: { organization: 'Test', url: 'http://search:3000' },
+  supportedInterfaces: [{ url: 'http://search:3000/api/a2a', protocolBinding: 'JSONRPC', protocolVersion: '1.0' }],
+  capabilities: { streaming: false, pushNotifications: false, stateTransitionHistory: false },
+  defaultInputModes: ['text/plain'],
+  defaultOutputModes: ['text/plain'],
+  skills: [
+    { id: 'search', name: 'Search Files', description: 'Search knowledge base files', tags: ['search', 'files', 'knowledge'] },
+  ],
+};
+
+const MOCK_CARD_CODE = {
+  name: 'CodeAgent',
+  description: 'A coding agent',
+  version: '1.0.0',
+  provider: { organization: 'Test', url: 'http://code:4000' },
+  supportedInterfaces: [{ url: 'http://code:4000/api/a2a', protocolBinding: 'JSONRPC', protocolVersion: '1.0' }],
+  capabilities: { streaming: false, pushNotifications: false, stateTransitionHistory: false },
+  defaultInputModes: ['text/plain'],
+  defaultOutputModes: ['text/plain'],
+  skills: [
+    { id: 'write-code', name: 'Write Code', description: 'Write and review code', tags: ['code', 'write', 'review'] },
+  ],
+};
+
+describe('A2A Orchestrator', () => {
+  beforeEach(() => {
+    clearRegistry();
+    mockFetch.mockReset();
+  });
+
+  describe('decompose', () => {
+    it('splits numbered list into subtasks', () => {
+      const tasks = decompose('1. Search for notes. 2. Summarize results. 3. Write report.');
+      expect(tasks).toHaveLength(3);
+      expect(tasks[0].description).toContain('Search');
+      expect(tasks[1].description).toContain('Summarize');
+      expect(tasks[2].description).toContain('Write');
+    });
+
+    it('splits on conjunctions', () => {
+      const tasks = decompose('Search for notes; then summarize them');
+      expect(tasks.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it('keeps single task as-is', () => {
+      const tasks = decompose('Search for project notes');
+      expect(tasks).toHaveLength(1);
+      expect(tasks[0].description).toBe('Search for project notes');
+    });
+
+    it('uses provided subtask descriptions', () => {
+      const tasks = decompose('complex request', ['task A', 'task B']);
+      expect(tasks).toHaveLength(2);
+      expect(tasks[0].description).toBe('task A');
+      expect(tasks[1].description).toBe('task B');
+    });
+
+    it('limits to MAX_SUBTASKS', () => {
+      const many = Array.from({ length: 20 }, (_, i) => `task ${i}`);
+      const tasks = decompose('many tasks', many);
+      expect(tasks.length).toBeLessThanOrEqual(10);
+    });
+
+    it('assigns unique IDs to each subtask', () => {
+      const tasks = decompose('x', ['a', 'b', 'c']);
+      const ids = new Set(tasks.map(t => t.id));
+      expect(ids.size).toBe(3);
+    });
+
+    it('initializes subtasks with pending status', () => {
+      const tasks = decompose('x', ['a']);
+      expect(tasks[0].status).toBe('pending');
+      expect(tasks[0].result).toBeNull();
+      expect(tasks[0].error).toBeNull();
+      expect(tasks[0].assignedAgentId).toBeNull();
+    });
+  });
+
+  describe('matchSkill', () => {
+    it('returns null when no agents discovered', () => {
+      expect(matchSkill('search for files')).toBeNull();
+    });
+
+    it('matches search task to search agent', async () => {
+      mockFetch.mockResolvedValueOnce({ ok: true, json: async () => MOCK_CARD_SEARCH });
+      mockFetch.mockResolvedValueOnce({ ok: true, json: async () => MOCK_CARD_CODE });
+      await discoverAgent('http://search:3000');
+      await discoverAgent('http://code:4000');
+
+      const match = matchSkill('search knowledge base files');
+      expect(match).not.toBeNull();
+      expect(match!.agentName).toBe('SearchAgent');
+      expect(match!.skillId).toBe('search');
+    });
+
+    it('matches code task to code agent', async () => {
+      mockFetch.mockResolvedValueOnce({ ok: true, json: async () => MOCK_CARD_SEARCH });
+      mockFetch.mockResolvedValueOnce({ ok: true, json: async () => MOCK_CARD_CODE });
+      await discoverAgent('http://search:3000');
+      await discoverAgent('http://code:4000');
+
+      const match = matchSkill('write code review');
+      expect(match).not.toBeNull();
+      expect(match!.agentName).toBe('CodeAgent');
+    });
+  });
+
+  describe('createPlan', () => {
+    it('creates a plan with subtasks', () => {
+      const plan = createPlan('do things', 'parallel', ['task A', 'task B']);
+      expect(plan.id).toBeTruthy();
+      expect(plan.status).toBe('planning');
+      expect(plan.subtasks).toHaveLength(2);
+      expect(plan.strategy).toBe('parallel');
+    });
+
+    it('auto-matches skills when agents are available', async () => {
+      mockFetch.mockResolvedValueOnce({ ok: true, json: async () => MOCK_CARD_SEARCH });
+      await discoverAgent('http://search:3000');
+
+      const plan = createPlan('find things', 'parallel', ['search files']);
+      const assigned = plan.subtasks.filter(st => st.assignedAgentId);
+      expect(assigned.length).toBeGreaterThanOrEqual(0);
+    });
+
+    it('defaults to parallel strategy', () => {
+      const plan = createPlan('test');
+      expect(plan.strategy).toBe('parallel');
+    });
+  });
+
+  describe('executePlan', () => {
+    it('fails when no agents assigned to any subtask', async () => {
+      const plan = createPlan('no agents', 'parallel', ['task A']);
+      const result = await executePlan(plan);
+      expect(result.status).toBe('failed');
+      expect(result.aggregatedResult).toContain('No agents available');
+    });
+
+    it('executes parallel plan with assigned agents', async () => {
+      mockFetch.mockResolvedValueOnce({ ok: true, json: async () => MOCK_CARD_SEARCH });
+      await discoverAgent('http://search:3000');
+
+      const plan = createPlan('search', 'parallel', ['search files']);
+      // Manually assign agent
+      plan.subtasks[0].assignedAgentId = getDiscoveredAgents()[0].id;
+
+      // Mock RPC response for delegation
+      const mockTask = {
+        id: 'task-1',
+        status: { state: 'TASK_STATE_COMPLETED', timestamp: new Date().toISOString() },
+        artifacts: [{ artifactId: 'a1', parts: [{ text: 'found 3 files' }] }],
+      };
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ jsonrpc: '2.0', id: '1', result: mockTask }),
+      });
+
+      const result = await executePlan(plan);
+      expect(result.status).toBe('completed');
+      expect(result.aggregatedResult).toContain('found 3 files');
+      expect(result.completedAt).toBeTruthy();
+    });
+
+    it('handles mixed success and failure', async () => {
+      mockFetch.mockResolvedValueOnce({ ok: true, json: async () => MOCK_CARD_SEARCH });
+      await discoverAgent('http://search:3000');
+      const agentId = getDiscoveredAgents()[0].id;
+
+      const plan = createPlan('multi', 'parallel', ['task ok', 'task fail']);
+      plan.subtasks[0].assignedAgentId = agentId;
+      plan.subtasks[1].assignedAgentId = agentId;
+
+      // First succeeds, second fails
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          jsonrpc: '2.0', id: '1',
+          result: { id: 't1', status: { state: 'TASK_STATE_COMPLETED', timestamp: '' }, artifacts: [{ artifactId: 'a1', parts: [{ text: 'ok' }] }] },
+        }),
+      });
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          jsonrpc: '2.0', id: '2',
+          error: { code: -32603, message: 'Internal error' },
+        }),
+      });
+
+      const result = await executePlan(plan);
+      expect(result.status).toBe('completed');
+      expect(result.aggregatedResult).toContain('ok');
+      expect(result.aggregatedResult).toContain('Failed');
+    });
+
+    it('stops on failure in sequential mode', async () => {
+      mockFetch.mockResolvedValueOnce({ ok: true, json: async () => MOCK_CARD_SEARCH });
+      await discoverAgent('http://search:3000');
+      const agentId = getDiscoveredAgents()[0].id;
+
+      const plan = createPlan('seq', 'sequential', ['first', 'second']);
+      plan.subtasks[0].assignedAgentId = agentId;
+      plan.subtasks[1].assignedAgentId = agentId;
+
+      // First fails
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          jsonrpc: '2.0', id: '1',
+          error: { code: -32603, message: 'boom' },
+        }),
+      });
+
+      const result = await executePlan(plan);
+      expect(plan.subtasks[0].status).toBe('failed');
+      expect(plan.subtasks[1].status).toBe('pending');
+    });
+
+    it('marks unassigned subtasks as failed before execution', async () => {
+      mockFetch.mockResolvedValueOnce({ ok: true, json: async () => MOCK_CARD_SEARCH });
+      await discoverAgent('http://search:3000');
+      const agentId = getDiscoveredAgents()[0].id;
+
+      const plan = createPlan('mixed', 'parallel', ['search files', 'unrelated task']);
+      plan.subtasks[0].assignedAgentId = agentId;
+      // subtask[1] stays unassigned
+
+      const mockTask = {
+        id: 't1',
+        status: { state: 'TASK_STATE_COMPLETED', timestamp: '' },
+        artifacts: [{ artifactId: 'a1', parts: [{ text: 'found stuff' }] }],
+      };
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ jsonrpc: '2.0', id: '1', result: mockTask }),
+      });
+
+      const result = await executePlan(plan);
+      expect(result.subtasks[0].status).toBe('completed');
+      expect(result.subtasks[1].status).toBe('failed');
+      expect(result.subtasks[1].error).toContain('No matching agent');
+    });
+
+    it('sets completedAt timestamp on finish', async () => {
+      const plan = createPlan('no agents', 'parallel', ['task A']);
+      expect(plan.completedAt).toBeNull();
+      await executePlan(plan);
+      // Even failed plans should get a completedAt (or aggregatedResult)
+      expect(plan.aggregatedResult).toBeTruthy();
+    });
+  });
+
+  describe('decompose edge cases', () => {
+    it('handles empty string', () => {
+      const tasks = decompose('');
+      expect(tasks).toHaveLength(1);
+    });
+
+    it('handles numbered list with periods in content', () => {
+      const tasks = decompose('1. Search for notes about A.I. 2. Write a summary');
+      expect(tasks.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it('trims whitespace from subtask descriptions', () => {
+      const tasks = decompose('x', ['  task with spaces  ']);
+      expect(tasks[0].description).toBe('task with spaces');
+    });
+  });
+});

package/_standalone/__tests__/a2a/task-handler.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { handleSendMessage, handleGetTask, handleCancelTask } from '../../lib/a2a/task-handler';
+import type { SendMessageParams } from '../../lib/a2a/types';
+
+function makeMessage(text: string): SendMessageParams {
+  return {
+    message: { role: 'ROLE_USER', parts: [{ text }] },
+  };
+}
+
+describe('A2A Task Handler', () => {
+  describe('handleSendMessage', () => {
+    it('returns a task with an id and status', async () => {
+      const task = await handleSendMessage(makeMessage('search for meeting notes'));
+      expect(task.id).toBeTruthy();
+      expect(task.status).toBeDefined();
+      expect(task.status.timestamp).toBeTruthy();
+    });
+
+    it('fails gracefully for empty message', async () => {
+      const task = await handleSendMessage({ message: { role: 'ROLE_USER', parts: [{ text: '' }] } });
+      expect(task.status.state).toBe('TASK_STATE_FAILED');
+    });
+
+    it('stores task history', async () => {
+      const task = await handleSendMessage(makeMessage('search for test'));
+      // History should include at least the user message
+      expect(task.history).toBeDefined();
+      expect(task.history!.length).toBeGreaterThanOrEqual(1);
+      expect(task.history![0].role).toBe('ROLE_USER');
+    });
+  });
+
+  describe('handleGetTask', () => {
+    it('returns null for non-existent task', () => {
+      const result = handleGetTask({ id: 'non-existent-id' });
+      expect(result).toBeNull();
+    });
+
+    it('retrieves a previously created task', async () => {
+      const task = await handleSendMessage(makeMessage('list files'));
+      const retrieved = handleGetTask({ id: task.id });
+      expect(retrieved).not.toBeNull();
+      expect(retrieved!.id).toBe(task.id);
+    });
+  });
+
+  describe('handleCancelTask', () => {
+    it('returns not_found for non-existent task', () => {
+      const { task, reason } = handleCancelTask({ id: 'non-existent-id' });
+      expect(task).toBeNull();
+      expect(reason).toBe('not_found');
+    });
+
+    it('returns not_cancelable for already completed task', async () => {
+      const task = await handleSendMessage(makeMessage('search for anything'));
+      // Task completes synchronously in Phase 1, so it should be completed or failed
+      const { task: canceledTask, reason } = handleCancelTask({ id: task.id });
+      expect(canceledTask).toBeNull();
+      expect(reason).toBe('not_cancelable'); // completed tasks can't be canceled
+    });
+  });
+
+  describe('skill routing', () => {
+    it('routes search-like messages to search_notes', async () => {
+      const task = await handleSendMessage(makeMessage('search for project updates'));
+      // Should attempt search (may fail due to no server, but state tells us it tried)
+      expect(['TASK_STATE_COMPLETED', 'TASK_STATE_FAILED']).toContain(task.status.state);
+    });
+
+    it('routes read-like messages to read_file', async () => {
+      const task = await handleSendMessage(makeMessage('read the file at test.md'));
+      expect(['TASK_STATE_COMPLETED', 'TASK_STATE_FAILED']).toContain(task.status.state);
+    });
+
+    it('routes list-like messages to list_files', async () => {
+      const task = await handleSendMessage(makeMessage('list files'));
+      expect(['TASK_STATE_COMPLETED', 'TASK_STATE_FAILED']).toContain(task.status.state);
+    });
+
+    it('falls back to search for unrecognized messages', async () => {
+      const task = await handleSendMessage(makeMessage('tell me about my projects'));
+      expect(['TASK_STATE_COMPLETED', 'TASK_STATE_FAILED']).toContain(task.status.state);
+    });
+  });
+});

package/_standalone/__tests__/acp/acp-types.test.ts

@@ -0,0 +1,273 @@
+import { describe, it, expect } from 'vitest';
+import type {
+  AcpStopReason,
+  AcpAgentCapabilities,
+  AcpMode,
+  AcpConfigOption,
+  AcpSessionUpdate,
+  AcpUpdateType,
+  AcpContentBlock,
+  AcpToolCallFull,
+  AcpPlan,
+  AcpSessionInfo,
+  AcpAuthMethod,
+} from '@/lib/acp/types';
+
+/* ── ContentBlock types ──────────────────────────────────────────────── */
+
+describe('AcpContentBlock types', () => {
+  it('text block is valid', () => {
+    const block: AcpContentBlock = { type: 'text', text: 'Hello' };
+    expect(block.type).toBe('text');
+  });
+
+  it('image block is valid', () => {
+    const block: AcpContentBlock = { type: 'image', data: 'base64data', mimeType: 'image/png' };
+    expect(block.type).toBe('image');
+  });
+
+  it('audio block is valid', () => {
+    const block: AcpContentBlock = { type: 'audio', data: 'base64data', mimeType: 'audio/wav' };
+    expect(block.type).toBe('audio');
+  });
+
+  it('resource_link block is valid', () => {
+    const block: AcpContentBlock = { type: 'resource_link', uri: 'file:///foo', name: 'foo.ts' };
+    expect(block.type).toBe('resource_link');
+  });
+
+  it('resource block is valid', () => {
+    const block: AcpContentBlock = { type: 'resource', resource: { uri: 'file:///foo', text: 'content' } };
+    expect(block.type).toBe('resource');
+  });
+});
+
+/* ── StopReason ──────────────────────────────────────────────────────── */
+
+describe('AcpStopReason', () => {
+  it('all valid values are accepted', () => {
+    const valid: AcpStopReason[] = ['end_turn', 'max_tokens', 'max_turn_requests', 'refusal', 'cancelled'];
+    expect(valid).toHaveLength(5);
+    for (const v of valid) {
+      expect(typeof v).toBe('string');
+    }
+  });
+});
+
+/* ── UpdateType — full spec coverage ─────────────────────────────────── */
+
+describe('AcpUpdateType', () => {
+  it('has all spec-defined types', () => {
+    const specTypes: AcpUpdateType[] = [
+      'user_message_chunk',
+      'agent_message_chunk',
+      'agent_thought_chunk',
+      'tool_call',
+      'tool_call_update',
+      'plan',
+      'available_commands_update',
+      'current_mode_update',
+      'config_option_update',
+      'session_info_update',
+    ];
+    expect(specTypes).toHaveLength(10);
+  });
+
+  it('has legacy compat types', () => {
+    const legacyTypes: AcpUpdateType[] = ['text', 'tool_result', 'done', 'error'];
+    expect(legacyTypes).toHaveLength(4);
+  });
+});
+
+/* ── ToolCallFull ────────────────────────────────────────────────────── */
+
+describe('AcpToolCallFull', () => {
+  it('supports all status values', () => {
+    const statuses: AcpToolCallFull['status'][] = ['pending', 'in_progress', 'completed', 'failed'];
+    expect(statuses).toHaveLength(4);
+  });
+
+  it('supports all kind values', () => {
+    const kinds: NonNullable<AcpToolCallFull['kind']>[] = [
+      'read', 'edit', 'delete', 'move', 'search', 'execute', 'think', 'fetch', 'switch_mode', 'other',
+    ];
+    expect(kinds).toHaveLength(10);
+  });
+});
+
+/* ── Plan ─────────────────────────────────────────────────────────────── */
+
+describe('AcpPlan', () => {
+  it('plan entry has required fields', () => {
+    const plan: AcpPlan = {
+      entries: [
+        { content: 'Fix bug', status: 'in_progress', priority: 'high' },
+        { content: 'Write tests', status: 'pending', priority: 'medium' },
+        { content: 'Update docs', status: 'completed', priority: 'low' },
+      ],
+    };
+    expect(plan.entries).toHaveLength(3);
+    expect(plan.entries[0].status).toBe('in_progress');
+    expect(plan.entries[2].priority).toBe('low');
+  });
+});
+
+/* ── Mode & ConfigOption ─────────────────────────────────────────────── */
+
+describe('AcpMode', () => {
+  it('mode has required fields', () => {
+    const mode: AcpMode = { id: 'code', name: 'Code', description: 'Write code' };
+    expect(mode.id).toBe('code');
+    expect(mode.name).toBe('Code');
+  });
+});
+
+describe('AcpConfigOption', () => {
+  it('config option has required fields', () => {
+    const opt: AcpConfigOption = {
+      type: 'select',
+      configId: 'model',
+      category: 'model',
+      currentValue: 'claude-4',
+      options: [
+        { id: 'claude-4', label: 'Claude 4' },
+        { id: 'gpt-5', label: 'GPT-5' },
+      ],
+    };
+    expect(opt.options).toHaveLength(2);
+  });
+});
+
+/* ── SessionInfo (from list) ─────────────────────────────────────────── */
+
+describe('AcpSessionInfo', () => {
+  it('session info has required fields', () => {
+    const info: AcpSessionInfo = {
+      sessionId: 'ses-123',
+      title: 'Debug session',
+      cwd: '/home/user/project',
+      updatedAt: '2025-01-01T00:00:00Z',
+    };
+    expect(info.sessionId).toBe('ses-123');
+  });
+});
+
+/* ── AuthMethod ──────────────────────────────────────────────────────── */
+
+describe('AcpAuthMethod', () => {
+  it('auth method has required fields', () => {
+    const auth: AcpAuthMethod = { id: 'agent', name: 'Agent Auth' };
+    expect(auth.id).toBe('agent');
+  });
+});
+
+/* ── AgentCapabilities ───────────────────────────────────────────────── */
+
+describe('AcpAgentCapabilities', () => {
+  it('supports all capability fields', () => {
+    const caps: AcpAgentCapabilities = {
+      loadSession: true,
+      mcpCapabilities: { http: true, sse: false },
+      promptCapabilities: { audio: false, embeddedContext: true, image: true },
+      sessionCapabilities: { list: true },
+    };
+    expect(caps.loadSession).toBe(true);
+    expect(caps.sessionCapabilities?.list).toBe(true);
+  });
+});
+
+/* ── SessionUpdate — all 10 spec types ───────────────────────────────── */
+
+describe('AcpSessionUpdate variants', () => {
+  it('agent_message_chunk', () => {
+    const update: AcpSessionUpdate = { sessionId: 'ses-1', type: 'agent_message_chunk', text: 'Hello' };
+    expect(update.type).toBe('agent_message_chunk');
+    expect(update.text).toBe('Hello');
+  });
+
+  it('agent_thought_chunk', () => {
+    const update: AcpSessionUpdate = { sessionId: 'ses-1', type: 'agent_thought_chunk', text: 'Thinking...' };
+    expect(update.type).toBe('agent_thought_chunk');
+  });
+
+  it('tool_call with full details', () => {
+    const update: AcpSessionUpdate = {
+      sessionId: 'ses-1',
+      type: 'tool_call',
+      toolCall: {
+        toolCallId: 'tc-1',
+        title: 'Read file',
+        kind: 'read',
+        status: 'in_progress',
+        rawInput: '{"path": "/foo.ts"}',
+      },
+    };
+    expect(update.toolCall?.kind).toBe('read');
+    expect(update.toolCall?.status).toBe('in_progress');
+  });
+
+  it('tool_call_update', () => {
+    const update: AcpSessionUpdate = {
+      sessionId: 'ses-1',
+      type: 'tool_call_update',
+      toolCall: { toolCallId: 'tc-1', status: 'completed', rawOutput: 'file content' },
+    };
+    expect(update.toolCall?.status).toBe('completed');
+  });
+
+  it('plan', () => {
+    const update: AcpSessionUpdate = {
+      sessionId: 'ses-1',
+      type: 'plan',
+      plan: { entries: [{ content: 'Step 1', status: 'pending', priority: 'high' }] },
+    };
+    expect(update.plan?.entries).toHaveLength(1);
+  });
+
+  it('available_commands_update', () => {
+    const update: AcpSessionUpdate = {
+      sessionId: 'ses-1',
+      type: 'available_commands_update',
+      availableCommands: [{ id: 'cmd-1', label: 'Run tests' }],
+    };
+    expect(update.availableCommands).toHaveLength(1);
+  });
+
+  it('current_mode_update', () => {
+    const update: AcpSessionUpdate = {
+      sessionId: 'ses-1',
+      type: 'current_mode_update',
+      currentModeId: 'architect',
+    };
+    expect(update.currentModeId).toBe('architect');
+  });
+
+  it('config_option_update', () => {
+    const update: AcpSessionUpdate = {
+      sessionId: 'ses-1',
+      type: 'config_option_update',
+      configOptions: [{
+        type: 'select',
+        configId: 'model',
+        category: 'model',
+        currentValue: 'gpt-5',
+        options: [{ id: 'gpt-5', label: 'GPT-5' }],
+      }],
+    };
+    expect(update.configOptions?.[0].currentValue).toBe('gpt-5');
+  });
+
+  it('session_info_update', () => {
+    const update: AcpSessionUpdate = {
+      sessionId: 'ses-1',
+      type: 'session_info_update',
+      sessionInfo: { title: 'Debug session', updatedAt: '2025-01-01' },
+    };
+    expect(update.sessionInfo?.title).toBe('Debug session');
+  });
+
+  it('user_message_chunk', () => {
+    const update: AcpSessionUpdate = { sessionId: 'ses-1', type: 'user_message_chunk', text: 'User input' };
+    expect(update.type).toBe('user_message_chunk');
+  });
+});