@geminilight/mindos 0.6.73 → 0.6.74

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

@@ -1,280 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,273 +0,0 @@
-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');
-  });
-});