opc-agent 1.4.0 → 2.0.1

package/src/tools/mcp-client.ts

@@ -0,0 +1,131 @@
+import { spawn, type ChildProcess } from 'child_process';
+import type { MCPToolDefinition, MCPToolResult } from './mcp';
+
+export interface MCPServerConfig {
+  name: string;
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
+export class MCPClient {
+  private process: ChildProcess | null = null;
+  private config: MCPServerConfig | null = null;
+  private nextId = 1;
+  private pending = new Map<number, { resolve: (v: any) => void; reject: (e: Error) => void }>();
+  private buffer = '';
+  private connected = false;
+
+  async connect(config: MCPServerConfig): Promise<void> {
+    this.config = config;
+    this.process = spawn(config.command, config.args ?? [], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, ...config.env },
+    });
+
+    this.process.stdout!.on('data', (data: Buffer) => {
+      this.buffer += data.toString();
+      this.processBuffer();
+    });
+
+    this.process.on('error', (err) => {
+      for (const [, p] of this.pending) p.reject(err);
+      this.pending.clear();
+    });
+
+    this.process.on('exit', () => {
+      this.connected = false;
+      for (const [, p] of this.pending) p.reject(new Error('MCP server exited'));
+      this.pending.clear();
+    });
+
+    // Send initialize
+    await this.sendRequest('initialize', {
+      protocolVersion: '2024-11-05',
+      capabilities: {},
+      clientInfo: { name: 'opc-agent', version: '0.7.0' },
+    });
+
+    // Send initialized notification
+    this.sendNotification('notifications/initialized', {});
+    this.connected = true;
+  }
+
+  private processBuffer(): void {
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() ?? '';
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const msg = JSON.parse(trimmed);
+        if (msg.id !== undefined && this.pending.has(msg.id)) {
+          const p = this.pending.get(msg.id)!;
+          this.pending.delete(msg.id);
+          if (msg.error) {
+            p.reject(new Error(msg.error.message || JSON.stringify(msg.error)));
+          } else {
+            p.resolve(msg.result);
+          }
+        }
+      } catch { /* skip non-JSON lines */ }
+    }
+  }
+
+  private sendRequest(method: string, params?: Record<string, unknown>): Promise<any> {
+    return new Promise((resolve, reject) => {
+      if (!this.process?.stdin?.writable) {
+        reject(new Error('MCP server not connected'));
+        return;
+      }
+      const id = this.nextId++;
+      this.pending.set(id, { resolve, reject });
+      const msg = JSON.stringify({ jsonrpc: '2.0', method, params: params ?? {}, id });
+      this.process.stdin.write(msg + '\n');
+
+      // Timeout after 30s
+      setTimeout(() => {
+        if (this.pending.has(id)) {
+          this.pending.delete(id);
+          reject(new Error(`MCP request timed out: ${method}`));
+        }
+      }, 30000);
+    });
+  }
+
+  private sendNotification(method: string, params: Record<string, unknown>): void {
+    if (!this.process?.stdin?.writable) return;
+    const msg = JSON.stringify({ jsonrpc: '2.0', method, params });
+    this.process.stdin.write(msg + '\n');
+  }
+
+  async listTools(): Promise<MCPToolDefinition[]> {
+    const result = await this.sendRequest('tools/list');
+    return (result.tools ?? []).map((t: any) => ({
+      name: t.name,
+      description: t.description ?? '',
+      inputSchema: t.inputSchema ?? {},
+    }));
+  }
+
+  async callTool(name: string, input: Record<string, unknown>): Promise<MCPToolResult> {
+    const result = await this.sendRequest('tools/call', { name, arguments: input });
+    const content = (result.content ?? [])
+      .map((c: any) => c.text ?? JSON.stringify(c))
+      .join('\n');
+    return { content, isError: result.isError ?? false };
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.process) {
+      this.process.kill();
+      this.process = null;
+    }
+    this.connected = false;
+    this.pending.clear();
+  }
+
+  isConnected(): boolean {
+    return this.connected;
+  }
+}

package/src/types/agent-workstation.d.ts

@@ -0,0 +1,2 @@
+declare module "agent-workstation";
+declare module "deepbrain";

package/tests/a2a-protocol.test.ts

@@ -0,0 +1,285 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { A2AServer } from '../src/protocols/a2a/server';
+import { A2AClient } from '../src/protocols/a2a/client';
+import { oadToAgentCard } from '../src/protocols/a2a/utils';
+import { JSON_RPC_ERRORS } from '../src/protocols/a2a/types';
+import type { A2AAgentCard, A2ATask, A2AMessage } from '../src/protocols/a2a/types';
+
+// Mock agent
+function createMockAgent(name = 'test-agent') {
+  return {
+    name,
+    config: { systemPrompt: 'I am a test agent' },
+    handleMessage: async (msg: any) => ({ content: `Echo: ${msg.content}`, role: 'assistant' }),
+  };
+}
+
+describe('oadToAgentCard', () => {
+  it('should generate card from OAD', () => {
+    const oad = {
+      metadata: { name: 'my-agent', description: 'A test agent', version: '2.0.0' },
+      spec: {
+        skills: [
+          { id: 'sum', name: 'Summarize', description: 'Summarize text', tags: ['nlp'] },
+        ],
+        channels: [{ type: 'websocket' }],
+      },
+    };
+    const card = oadToAgentCard(oad, 'http://localhost:3001');
+    expect(card.name).toBe('my-agent');
+    expect(card.description).toBe('A test agent');
+    expect(card.version).toBe('2.0.0');
+    expect(card.url).toBe('http://localhost:3001');
+    expect(card.skills).toHaveLength(1);
+    expect(card.skills[0].id).toBe('sum');
+    expect(card.capabilities.streaming).toBe(true);
+  });
+
+  it('should create default skill when none defined', () => {
+    const oad = { metadata: { name: 'basic', description: 'Basic agent' }, spec: {} };
+    const card = oadToAgentCard(oad, 'http://localhost:3001');
+    expect(card.skills).toHaveLength(1);
+    expect(card.skills[0].id).toBe('default');
+  });
+
+  it('should handle empty OAD', () => {
+    const card = oadToAgentCard({}, 'http://localhost:3001');
+    expect(card.name).toBe('opc-agent');
+    expect(card.url).toBe('http://localhost:3001');
+  });
+
+  it('should strip trailing slash from URL', () => {
+    const card = oadToAgentCard({}, 'http://localhost:3001/');
+    expect(card.url).toBe('http://localhost:3001');
+  });
+});
+
+describe('A2AServer', () => {
+  let server: A2AServer;
+  const PORT = 39871;
+
+  beforeEach(async () => {
+    const agent = createMockAgent();
+    server = new A2AServer(agent, {
+      card: { name: 'test-server', description: 'Test', url: `http://localhost:${PORT}` },
+    });
+    await server.start(PORT);
+  });
+
+  afterEach(async () => {
+    await server.stop();
+  });
+
+  it('should serve /.well-known/agent.json', async () => {
+    const res = await fetch(`http://localhost:${PORT}/.well-known/agent.json`);
+    expect(res.status).toBe(200);
+    const card: A2AAgentCard = await res.json() as any;
+    expect(card.name).toBe('test-server');
+  });
+
+  it('should handle tasks/send', async () => {
+    const res = await fetch(`http://localhost:${PORT}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        jsonrpc: '2.0', id: '1', method: 'tasks/send',
+        params: { id: 'task-1', message: { role: 'user', parts: [{ type: 'text', text: 'Hello' }] } },
+      }),
+    });
+    const json = await res.json() as any;
+    expect(json.result.id).toBe('task-1');
+    expect(json.result.status.state).toBe('completed');
+    expect(json.result.history).toHaveLength(2); // user + agent
+  });
+
+  it('should handle tasks/get', async () => {
+    // First create a task
+    await fetch(`http://localhost:${PORT}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        jsonrpc: '2.0', id: '1', method: 'tasks/send',
+        params: { id: 'task-get-1', message: { role: 'user', parts: [{ type: 'text', text: 'Hi' }] } },
+      }),
+    });
+
+    // Then get it
+    const res = await fetch(`http://localhost:${PORT}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ jsonrpc: '2.0', id: '2', method: 'tasks/get', params: { id: 'task-get-1' } }),
+    });
+    const json = await res.json() as any;
+    expect(json.result.id).toBe('task-get-1');
+    expect(json.result.status.state).toBe('completed');
+  });
+
+  it('should handle tasks/cancel', async () => {
+    // Create task
+    await fetch(`http://localhost:${PORT}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        jsonrpc: '2.0', id: '1', method: 'tasks/send',
+        params: { id: 'task-cancel-1', message: { role: 'user', parts: [{ type: 'text', text: 'Hi' }] } },
+      }),
+    });
+
+    const res = await fetch(`http://localhost:${PORT}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ jsonrpc: '2.0', id: '2', method: 'tasks/cancel', params: { id: 'task-cancel-1' } }),
+    });
+    const json = await res.json() as any;
+    expect(json.result.status.state).toBe('canceled');
+  });
+
+  it('should return error for unknown task', async () => {
+    const res = await fetch(`http://localhost:${PORT}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'tasks/get', params: { id: 'nonexistent' } }),
+    });
+    const json = await res.json() as any;
+    expect(json.error).toBeDefined();
+    expect(json.error.code).toBe(JSON_RPC_ERRORS.TASK_NOT_FOUND);
+  });
+
+  it('should return error for unknown method', async () => {
+    const res = await fetch(`http://localhost:${PORT}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ jsonrpc: '2.0', id: '1', method: 'unknown/method', params: {} }),
+    });
+    const json = await res.json() as any;
+    expect(json.error).toBeDefined();
+    expect(json.error.code).toBe(JSON_RPC_ERRORS.METHOD_NOT_FOUND);
+  });
+
+  it('should return parse error for invalid JSON', async () => {
+    const res = await fetch(`http://localhost:${PORT}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: 'not json',
+    });
+    const json = await res.json() as any;
+    expect(json.error.code).toBe(JSON_RPC_ERRORS.PARSE_ERROR);
+  });
+
+  it('should return getAgentCard()', () => {
+    const card = server.getAgentCard();
+    expect(card.name).toBe('test-server');
+    expect(card.capabilities).toBeDefined();
+  });
+});
+
+describe('A2AClient', () => {
+  let server: A2AServer;
+  let client: A2AClient;
+  const PORT = 39872;
+
+  beforeEach(async () => {
+    const agent = createMockAgent();
+    server = new A2AServer(agent, {
+      card: { name: 'client-test', description: 'Test' },
+    });
+    await server.start(PORT);
+    client = new A2AClient(`http://localhost:${PORT}`);
+  });
+
+  afterEach(async () => {
+    await server.stop();
+  });
+
+  it('should getAgentCard', async () => {
+    const card = await client.getAgentCard();
+    expect(card.name).toBe('client-test');
+  });
+
+  it('should sendText and get response', async () => {
+    const response = await client.sendText('Hello agent');
+    expect(response).toContain('Echo: Hello agent');
+  });
+
+  it('should sendTask with message', async () => {
+    const task = await client.sendTask(
+      { role: 'user', parts: [{ type: 'text', text: 'Test message' }] },
+      { taskId: 'client-task-1' },
+    );
+    expect(task.id).toBe('client-task-1');
+    expect(task.status.state).toBe('completed');
+  });
+
+  it('should getTask', async () => {
+    await client.sendText('setup', { taskId: 'get-test' });
+    const task = await client.getTask('get-test');
+    expect(task.id).toBe('get-test');
+  });
+
+  it('should cancelTask', async () => {
+    await client.sendText('setup', { taskId: 'cancel-test' });
+    const task = await client.cancelTask('cancel-test');
+    expect(task.status.state).toBe('canceled');
+  });
+});
+
+describe('Task state transitions', () => {
+  it('should track state transitions through task lifecycle', async () => {
+    const states: string[] = [];
+    const agent = createMockAgent();
+    const server = new A2AServer(agent);
+    
+    server.onTask(async (task) => {
+      states.push(task.status.state);
+      task.status = { state: 'working', timestamp: new Date().toISOString() };
+      states.push('working');
+      task.status = { state: 'completed', timestamp: new Date().toISOString() };
+      states.push('completed');
+      return task;
+    });
+
+    const PORT = 39873;
+    await server.start(PORT);
+    
+    const client = new A2AClient(`http://localhost:${PORT}`);
+    await client.sendText('test');
+    
+    expect(states).toContain('working');
+    expect(states).toContain('completed');
+    
+    await server.stop();
+  });
+});
+
+describe('Message part types', () => {
+  it('should handle text parts', async () => {
+    const server = new A2AServer(createMockAgent());
+    const PORT = 39874;
+    await server.start(PORT);
+
+    const msg: A2AMessage = { role: 'user', parts: [{ type: 'text', text: 'hello' }] };
+    const client = new A2AClient(`http://localhost:${PORT}`);
+    const task = await client.sendTask(msg);
+    expect(task.history[0].parts[0].type).toBe('text');
+
+    await server.stop();
+  });
+
+  it('should handle file parts in message', () => {
+    const msg: A2AMessage = {
+      role: 'user',
+      parts: [{ type: 'file', file: { name: 'test.txt', mimeType: 'text/plain', bytes: 'aGVsbG8=' } }],
+    };
+    expect(msg.parts[0].type).toBe('file');
+    expect((msg.parts[0] as any).file.name).toBe('test.txt');
+  });
+
+  it('should handle data parts in message', () => {
+    const msg: A2AMessage = {
+      role: 'user',
+      parts: [{ type: 'data', data: { key: 'value', count: 42 } }],
+    };
+    expect(msg.parts[0].type).toBe('data');
+    expect((msg.parts[0] as any).data.key).toBe('value');
+  });
+});

package/tests/agui-protocol.test.ts

@@ -0,0 +1,246 @@
+// AG-UI Protocol Tests
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+  AGUIEventEmitter,
+  AGUIServer,
+  AGUIClient,
+  AGUI_EVENT_TYPES,
+  isValidEventType,
+} from '../src/protocols/agui';
+import type { AGUIEvent, AGUIRunRequest } from '../src/protocols/agui';
+
+// ─── Mock ServerResponse ─────────────────────────────────────
+
+function createMockRes() {
+  const chunks: string[] = [];
+  return {
+    chunks,
+    writeHead: vi.fn(),
+    write: vi.fn((data: string) => { chunks.push(data); return true; }),
+    end: vi.fn(),
+  };
+}
+
+function parseSSEChunks(chunks: string[]): AGUIEvent[] {
+  return chunks
+    .filter(c => c.startsWith('data: '))
+    .map(c => JSON.parse(c.slice(6).trim()));
+}
+
+// ─── Tests ───────────────────────────────────────────────────
+
+describe('AG-UI Protocol', () => {
+  describe('isValidEventType', () => {
+    it('should validate known event types', () => {
+      expect(isValidEventType('TEXT_MESSAGE_START')).toBe(true);
+      expect(isValidEventType('RUN_FINISHED')).toBe(true);
+      expect(isValidEventType('CUSTOM')).toBe(true);
+    });
+
+    it('should reject unknown event types', () => {
+      expect(isValidEventType('UNKNOWN')).toBe(false);
+      expect(isValidEventType('')).toBe(false);
+    });
+
+    it('should have all 15 event types', () => {
+      expect(AGUI_EVENT_TYPES.length).toBe(15);
+    });
+  });
+
+  describe('AGUIEventEmitter', () => {
+    let res: ReturnType<typeof createMockRes>;
+    let emitter: AGUIEventEmitter;
+
+    beforeEach(() => {
+      res = createMockRes();
+      emitter = new AGUIEventEmitter(res as any);
+    });
+
+    it('should emit SSE-formatted events', () => {
+      emitter.emit({ type: 'RUN_STARTED', runId: 'r1', timestamp: '2025-01-01T00:00:00Z' });
+      expect(res.chunks.length).toBe(1);
+      expect(res.chunks[0]).toMatch(/^data: \{.*\}\n\n$/);
+      const parsed = JSON.parse(res.chunks[0].slice(6));
+      expect(parsed.type).toBe('RUN_STARTED');
+      expect(parsed.runId).toBe('r1');
+    });
+
+    it('should emit textStart/textContent/textEnd flow', () => {
+      emitter.textStart('msg1');
+      emitter.textContent('msg1', 'Hello');
+      emitter.textContent('msg1', ' world');
+      emitter.textEnd('msg1');
+      const events = parseSSEChunks(res.chunks);
+      expect(events.length).toBe(4);
+      expect(events[0].type).toBe('TEXT_MESSAGE_START');
+      expect(events[0].messageId).toBe('msg1');
+      expect((events[0] as any).role).toBe('assistant');
+      expect(events[1].type).toBe('TEXT_MESSAGE_CONTENT');
+      expect((events[1] as any).delta).toBe('Hello');
+      expect(events[2].type).toBe('TEXT_MESSAGE_CONTENT');
+      expect((events[2] as any).delta).toBe(' world');
+      expect(events[3].type).toBe('TEXT_MESSAGE_END');
+    });
+
+    it('should emit tool call flow', () => {
+      emitter.toolCallStart('tc1', 'search');
+      emitter.toolCallArgs('tc1', '{"q":"test"}');
+      emitter.toolCallEnd('tc1');
+      const events = parseSSEChunks(res.chunks);
+      expect(events.length).toBe(3);
+      expect(events[0].type).toBe('TOOL_CALL_START');
+      expect((events[0] as any).toolCallName).toBe('search');
+      expect(events[1].type).toBe('TOOL_CALL_ARGS');
+      expect(events[2].type).toBe('TOOL_CALL_END');
+    });
+
+    it('should emit runStarted/runFinished', () => {
+      emitter.runStarted('r1', 'thread1');
+      emitter.runFinished('r1');
+      const events = parseSSEChunks(res.chunks);
+      expect(events[0].type).toBe('RUN_STARTED');
+      expect((events[0] as any).threadId).toBe('thread1');
+      expect(events[1].type).toBe('RUN_FINISHED');
+    });
+
+    it('should emit runError', () => {
+      emitter.runError('r1', 'Something went wrong', 'INTERNAL');
+      const events = parseSSEChunks(res.chunks);
+      expect(events[0].type).toBe('RUN_ERROR');
+      expect((events[0] as any).message).toBe('Something went wrong');
+      expect((events[0] as any).code).toBe('INTERNAL');
+    });
+
+    it('should emit stateSnapshot', () => {
+      emitter.stateSnapshot({ count: 42 });
+      const events = parseSSEChunks(res.chunks);
+      expect(events[0].type).toBe('STATE_SNAPSHOT');
+      expect((events[0] as any).snapshot.count).toBe(42);
+    });
+
+    it('should emit stateDelta', () => {
+      emitter.stateDelta([{ op: 'replace', path: '/count', value: 43 }]);
+      const events = parseSSEChunks(res.chunks);
+      expect(events[0].type).toBe('STATE_DELTA');
+      expect((events[0] as any).delta[0].op).toBe('replace');
+    });
+
+    it('should not emit after close', () => {
+      emitter.close();
+      emitter.textStart('msg1');
+      expect(res.chunks.length).toBe(0);
+      expect(res.end).toHaveBeenCalled();
+    });
+
+    it('should include timestamp on convenience methods', () => {
+      emitter.textStart('msg1');
+      const events = parseSSEChunks(res.chunks);
+      expect(events[0].timestamp).toBeDefined();
+      expect(typeof events[0].timestamp).toBe('string');
+    });
+
+    it('should emit step events', () => {
+      emitter.stepStarted('s1', 'process');
+      emitter.stepFinished('s1');
+      const events = parseSSEChunks(res.chunks);
+      expect(events[0].type).toBe('STEP_STARTED');
+      expect((events[0] as any).stepName).toBe('process');
+      expect(events[1].type).toBe('STEP_FINISHED');
+    });
+
+    it('should emit custom events', () => {
+      emitter.custom('my_event', { foo: 'bar' });
+      const events = parseSSEChunks(res.chunks);
+      expect(events[0].type).toBe('CUSTOM');
+      expect((events[0] as any).name).toBe('my_event');
+      expect((events[0] as any).value.foo).toBe('bar');
+    });
+
+    it('should emit messagesSnapshot', () => {
+      emitter.messagesSnapshot([{ id: 'm1', role: 'user', content: 'hi' }]);
+      const events = parseSSEChunks(res.chunks);
+      expect(events[0].type).toBe('MESSAGES_SNAPSHOT');
+      expect((events[0] as any).messages[0].content).toBe('hi');
+    });
+  });
+
+  describe('AGUIServer', () => {
+    it('should construct with default path', () => {
+      const mockAgent = { handleMessage: vi.fn(), handleMessageStream: vi.fn() };
+      const server = new AGUIServer(mockAgent as any);
+      expect(server).toBeDefined();
+    });
+
+    it('should handle run request with mock agent', async () => {
+      const mockAgent = {
+        handleMessage: vi.fn().mockResolvedValue({ content: 'Hello!' }),
+        handleMessageStream: async function* () { yield 'Hel'; yield 'lo!'; },
+      };
+      const server = new AGUIServer(mockAgent as any);
+      const res = createMockRes();
+
+      // Simulate request
+      const body = JSON.stringify({
+        messages: [{ id: 'msg1', role: 'user', content: 'Hi' }],
+      });
+      const req = {
+        [Symbol.asyncIterator]: async function* () { yield body; },
+      };
+
+      await server.handleRun(req as any, res as any);
+
+      expect(res.writeHead).toHaveBeenCalledWith(200, expect.objectContaining({
+        'Content-Type': 'text/event-stream',
+      }));
+
+      const events = parseSSEChunks(res.chunks);
+      const types = events.map(e => e.type);
+      expect(types).toContain('RUN_STARTED');
+      expect(types).toContain('TEXT_MESSAGE_START');
+      expect(types).toContain('TEXT_MESSAGE_CONTENT');
+      expect(types).toContain('TEXT_MESSAGE_END');
+      expect(types).toContain('RUN_FINISHED');
+    });
+
+    it('should return 400 for invalid JSON', async () => {
+      const mockAgent = { handleMessage: vi.fn() };
+      const server = new AGUIServer(mockAgent as any);
+      const res = createMockRes();
+      const req = { [Symbol.asyncIterator]: async function* () { yield 'not json'; } };
+
+      await server.handleRun(req as any, res as any);
+      expect(res.writeHead).toHaveBeenCalledWith(400, expect.any(Object));
+    });
+
+    it('should return 400 for missing messages', async () => {
+      const mockAgent = { handleMessage: vi.fn() };
+      const server = new AGUIServer(mockAgent as any);
+      const res = createMockRes();
+      const req = { [Symbol.asyncIterator]: async function* () { yield '{}'; } };
+
+      await server.handleRun(req as any, res as any);
+      expect(res.writeHead).toHaveBeenCalledWith(400, expect.any(Object));
+    });
+  });
+
+  describe('AGUIClient', () => {
+    it('should construct with endpoint', () => {
+      const client = new AGUIClient('http://localhost:3000/agui');
+      expect(client).toBeDefined();
+    });
+
+    it('should abort cleanly', () => {
+      const client = new AGUIClient('http://localhost:3000/agui');
+      // Should not throw when no active request
+      client.abort();
+    });
+  });
+
+  describe('Protocol list includes agui', () => {
+    it('should have agui in AGUI_EVENT_TYPES constants', () => {
+      expect(AGUI_EVENT_TYPES).toContain('TEXT_MESSAGE_START');
+      expect(AGUI_EVENT_TYPES).toContain('RUN_STARTED');
+      expect(AGUI_EVENT_TYPES).toContain('TOOL_CALL_START');
+    });
+  });
+});