@jackchen_me/open-multi-agent 0.1.0 → 1.0.0

package/tests/team-messaging.test.ts

@@ -0,0 +1,329 @@
+import { describe, it, expect, vi } from 'vitest'
+import { MessageBus } from '../src/team/messaging.js'
+import { Team } from '../src/team/team.js'
+import type { AgentConfig, TeamConfig } from '../src/types.js'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function agent(name: string): AgentConfig {
+  return { name, model: 'test-model', systemPrompt: `You are ${name}.` }
+}
+
+function teamConfig(opts?: Partial<TeamConfig>): TeamConfig {
+  return {
+    name: 'test-team',
+    agents: [agent('alice'), agent('bob')],
+    ...opts,
+  }
+}
+
+// ===========================================================================
+// MessageBus
+// ===========================================================================
+
+describe('MessageBus', () => {
+  describe('send / getAll / getUnread', () => {
+    it('delivers a point-to-point message', () => {
+      const bus = new MessageBus()
+      bus.send('alice', 'bob', 'hello')
+
+      const msgs = bus.getAll('bob')
+      expect(msgs).toHaveLength(1)
+      expect(msgs[0]!.from).toBe('alice')
+      expect(msgs[0]!.to).toBe('bob')
+      expect(msgs[0]!.content).toBe('hello')
+    })
+
+    it('does not deliver messages to sender', () => {
+      const bus = new MessageBus()
+      bus.send('alice', 'bob', 'hello')
+      expect(bus.getAll('alice')).toHaveLength(0)
+    })
+
+    it('tracks unread state', () => {
+      const bus = new MessageBus()
+      const msg = bus.send('alice', 'bob', 'hello')
+
+      expect(bus.getUnread('bob')).toHaveLength(1)
+
+      bus.markRead('bob', [msg.id])
+      expect(bus.getUnread('bob')).toHaveLength(0)
+      // getAll still returns the message
+      expect(bus.getAll('bob')).toHaveLength(1)
+    })
+
+    it('markRead with empty array is a no-op', () => {
+      const bus = new MessageBus()
+      bus.markRead('bob', [])
+      expect(bus.getUnread('bob')).toHaveLength(0)
+    })
+  })
+
+  describe('broadcast', () => {
+    it('delivers to all except sender', () => {
+      const bus = new MessageBus()
+      // Set up subscribers so the bus knows about agents
+      bus.subscribe('alice', () => {})
+      bus.subscribe('bob', () => {})
+      bus.subscribe('carol', () => {})
+
+      bus.broadcast('alice', 'everyone listen')
+
+      expect(bus.getAll('bob')).toHaveLength(1)
+      expect(bus.getAll('carol')).toHaveLength(1)
+      expect(bus.getAll('alice')).toHaveLength(0) // sender excluded
+    })
+
+    it('broadcast message has to === "*"', () => {
+      const bus = new MessageBus()
+      const msg = bus.broadcast('alice', 'hi')
+      expect(msg.to).toBe('*')
+    })
+  })
+
+  describe('subscribe', () => {
+    it('notifies subscriber on new direct message', () => {
+      const bus = new MessageBus()
+      const received: string[] = []
+      bus.subscribe('bob', (msg) => received.push(msg.content))
+
+      bus.send('alice', 'bob', 'ping')
+
+      expect(received).toEqual(['ping'])
+    })
+
+    it('notifies subscriber on broadcast', () => {
+      const bus = new MessageBus()
+      const received: string[] = []
+      bus.subscribe('bob', (msg) => received.push(msg.content))
+
+      bus.broadcast('alice', 'broadcast msg')
+
+      expect(received).toEqual(['broadcast msg'])
+    })
+
+    it('does not notify sender of own broadcast', () => {
+      const bus = new MessageBus()
+      const received: string[] = []
+      bus.subscribe('alice', (msg) => received.push(msg.content))
+
+      bus.broadcast('alice', 'my broadcast')
+
+      expect(received).toEqual([])
+    })
+
+    it('unsubscribe stops notifications', () => {
+      const bus = new MessageBus()
+      const received: string[] = []
+      const unsub = bus.subscribe('bob', (msg) => received.push(msg.content))
+
+      bus.send('alice', 'bob', 'first')
+      unsub()
+      bus.send('alice', 'bob', 'second')
+
+      expect(received).toEqual(['first'])
+    })
+  })
+
+  describe('getConversation', () => {
+    it('returns messages in both directions', () => {
+      const bus = new MessageBus()
+      bus.send('alice', 'bob', 'hello')
+      bus.send('bob', 'alice', 'hi back')
+      bus.send('alice', 'carol', 'unrelated')
+
+      const convo = bus.getConversation('alice', 'bob')
+      expect(convo).toHaveLength(2)
+      expect(convo[0]!.content).toBe('hello')
+      expect(convo[1]!.content).toBe('hi back')
+    })
+  })
+})
+
+// ===========================================================================
+// Team
+// ===========================================================================
+
+describe('Team', () => {
+  describe('agent roster', () => {
+    it('returns all agents via getAgents()', () => {
+      const team = new Team(teamConfig())
+      const agents = team.getAgents()
+      expect(agents).toHaveLength(2)
+      expect(agents.map(a => a.name)).toEqual(['alice', 'bob'])
+    })
+
+    it('looks up agent by name', () => {
+      const team = new Team(teamConfig())
+      expect(team.getAgent('alice')?.name).toBe('alice')
+      expect(team.getAgent('nonexistent')).toBeUndefined()
+    })
+  })
+
+  describe('messaging', () => {
+    it('sends point-to-point messages and emits event', () => {
+      const team = new Team(teamConfig())
+      const events: unknown[] = []
+      team.on('message', (d) => events.push(d))
+
+      team.sendMessage('alice', 'bob', 'hey')
+
+      expect(team.getMessages('bob')).toHaveLength(1)
+      expect(team.getMessages('bob')[0]!.content).toBe('hey')
+      expect(events).toHaveLength(1)
+    })
+
+    it('broadcasts and emits broadcast event', () => {
+      const team = new Team(teamConfig())
+      const events: unknown[] = []
+      team.on('broadcast', (d) => events.push(d))
+
+      team.broadcast('alice', 'all hands')
+
+      expect(events).toHaveLength(1)
+    })
+  })
+
+  describe('task management', () => {
+    it('adds and retrieves tasks', () => {
+      const team = new Team(teamConfig())
+      const task = team.addTask({
+        title: 'Do something',
+        description: 'Details here',
+        status: 'pending',
+        assignee: 'alice',
+      })
+
+      expect(task.id).toBeDefined()
+      expect(task.title).toBe('Do something')
+      expect(team.getTasks()).toHaveLength(1)
+    })
+
+    it('filters tasks by assignee', () => {
+      const team = new Team(teamConfig())
+      team.addTask({ title: 't1', description: 'd', status: 'pending', assignee: 'alice' })
+      team.addTask({ title: 't2', description: 'd', status: 'pending', assignee: 'bob' })
+
+      expect(team.getTasksByAssignee('alice')).toHaveLength(1)
+      expect(team.getTasksByAssignee('alice')[0]!.title).toBe('t1')
+    })
+
+    it('updates a task', () => {
+      const team = new Team(teamConfig())
+      const task = team.addTask({ title: 't1', description: 'd', status: 'pending' })
+
+      const updated = team.updateTask(task.id, { status: 'in_progress' })
+      expect(updated.status).toBe('in_progress')
+    })
+
+    it('getNextTask prefers assigned tasks', () => {
+      const team = new Team(teamConfig())
+      team.addTask({ title: 'unassigned', description: 'd', status: 'pending' })
+      team.addTask({ title: 'for alice', description: 'd', status: 'pending', assignee: 'alice' })
+
+      const next = team.getNextTask('alice')
+      expect(next?.title).toBe('for alice')
+    })
+
+    it('getNextTask falls back to unassigned', () => {
+      const team = new Team(teamConfig())
+      team.addTask({ title: 'unassigned', description: 'd', status: 'pending' })
+
+      const next = team.getNextTask('alice')
+      expect(next?.title).toBe('unassigned')
+    })
+
+    it('getNextTask returns undefined when no tasks available', () => {
+      const team = new Team(teamConfig())
+      expect(team.getNextTask('alice')).toBeUndefined()
+    })
+
+    it('preserves non-default status on addTask', () => {
+      const team = new Team(teamConfig())
+      const task = team.addTask({
+        title: 'blocked task',
+        description: 'd',
+        status: 'blocked',
+        result: 'waiting on dep',
+      })
+      expect(task.status).toBe('blocked')
+      expect(task.result).toBe('waiting on dep')
+    })
+  })
+
+  describe('shared memory', () => {
+    it('returns undefined when sharedMemory is disabled', () => {
+      const team = new Team(teamConfig({ sharedMemory: false }))
+      expect(team.getSharedMemory()).toBeUndefined()
+      expect(team.getSharedMemoryInstance()).toBeUndefined()
+    })
+
+    it('returns a MemoryStore when sharedMemory is enabled', () => {
+      const team = new Team(teamConfig({ sharedMemory: true }))
+      const store = team.getSharedMemory()
+      expect(store).toBeDefined()
+      expect(typeof store!.get).toBe('function')
+      expect(typeof store!.set).toBe('function')
+    })
+
+    it('returns SharedMemory instance', () => {
+      const team = new Team(teamConfig({ sharedMemory: true }))
+      const mem = team.getSharedMemoryInstance()
+      expect(mem).toBeDefined()
+      expect(typeof mem!.write).toBe('function')
+      expect(typeof mem!.getSummary).toBe('function')
+    })
+  })
+
+  describe('events', () => {
+    it('emits task:ready when a pending task becomes runnable', () => {
+      const team = new Team(teamConfig())
+      const events: unknown[] = []
+      team.on('task:ready', (d) => events.push(d))
+
+      team.addTask({ title: 't1', description: 'd', status: 'pending' })
+
+      // task:ready is fired by the queue when a task with no deps is added
+      expect(events.length).toBeGreaterThanOrEqual(1)
+    })
+
+    it('emits custom events via emit()', () => {
+      const team = new Team(teamConfig())
+      const received: unknown[] = []
+      team.on('custom:event', (d) => received.push(d))
+
+      team.emit('custom:event', { foo: 'bar' })
+
+      expect(received).toEqual([{ foo: 'bar' }])
+    })
+
+    it('unsubscribe works', () => {
+      const team = new Team(teamConfig())
+      const received: unknown[] = []
+      const unsub = team.on('custom:event', (d) => received.push(d))
+
+      team.emit('custom:event', 'first')
+      unsub()
+      team.emit('custom:event', 'second')
+
+      expect(received).toEqual(['first'])
+    })
+
+    it('bridges task:complete and task:failed from the queue', () => {
+      // These events fire via queue.complete()/queue.fail(), which happen
+      // during orchestration. Team only exposes updateTask() which calls
+      // queue.update() — no event is emitted. We verify the bridge is
+      // wired correctly by checking that task:ready fires on addTask.
+      const team = new Team(teamConfig())
+      const readyEvents: unknown[] = []
+      team.on('task:ready', (d) => readyEvents.push(d))
+
+      team.addTask({ title: 't1', description: 'd', status: 'pending' })
+
+      // task:ready fires because a pending task with no deps is immediately ready
+      expect(readyEvents.length).toBeGreaterThanOrEqual(1)
+    })
+  })
+})

package/tests/text-tool-extractor.test.ts

@@ -0,0 +1,170 @@
+import { describe, it, expect } from 'vitest'
+import { extractToolCallsFromText } from '../src/tool/text-tool-extractor.js'
+
+const TOOLS = ['bash', 'file_read', 'file_write']
+
+describe('extractToolCallsFromText', () => {
+  // -------------------------------------------------------------------------
+  // No tool calls
+  // -------------------------------------------------------------------------
+
+  it('returns empty array for empty text', () => {
+    expect(extractToolCallsFromText('', TOOLS)).toEqual([])
+  })
+
+  it('returns empty array for plain text with no JSON', () => {
+    expect(extractToolCallsFromText('Hello, I am a helpful assistant.', TOOLS)).toEqual([])
+  })
+
+  it('returns empty array for JSON that does not match any known tool', () => {
+    const text = '{"name": "unknown_tool", "arguments": {"x": 1}}'
+    expect(extractToolCallsFromText(text, TOOLS)).toEqual([])
+  })
+
+  // -------------------------------------------------------------------------
+  // Bare JSON
+  // -------------------------------------------------------------------------
+
+  it('extracts a bare JSON tool call with "arguments"', () => {
+    const text = 'I will run this command:\n{"name": "bash", "arguments": {"command": "ls -la"}}'
+    const result = extractToolCallsFromText(text, TOOLS)
+    expect(result).toHaveLength(1)
+    expect(result[0]!.type).toBe('tool_use')
+    expect(result[0]!.name).toBe('bash')
+    expect(result[0]!.input).toEqual({ command: 'ls -la' })
+    expect(result[0]!.id).toMatch(/^extracted_call_/)
+  })
+
+  it('extracts a bare JSON tool call with "parameters"', () => {
+    const text = '{"name": "file_read", "parameters": {"path": "/tmp/test.txt"}}'
+    const result = extractToolCallsFromText(text, TOOLS)
+    expect(result).toHaveLength(1)
+    expect(result[0]!.name).toBe('file_read')
+    expect(result[0]!.input).toEqual({ path: '/tmp/test.txt' })
+  })
+
+  it('extracts a bare JSON tool call with "input"', () => {
+    const text = '{"name": "bash", "input": {"command": "pwd"}}'
+    const result = extractToolCallsFromText(text, TOOLS)
+    expect(result).toHaveLength(1)
+    expect(result[0]!.name).toBe('bash')
+    expect(result[0]!.input).toEqual({ command: 'pwd' })
+  })
+
+  it('extracts { function: { name, arguments } } shape', () => {
+    const text = '{"function": {"name": "bash", "arguments": {"command": "echo hi"}}}'
+    const result = extractToolCallsFromText(text, TOOLS)
+    expect(result).toHaveLength(1)
+    expect(result[0]!.name).toBe('bash')
+    expect(result[0]!.input).toEqual({ command: 'echo hi' })
+  })
+
+  it('handles string-encoded arguments', () => {
+    const text = '{"name": "bash", "arguments": "{\\"command\\": \\"ls\\"}"}'
+    const result = extractToolCallsFromText(text, TOOLS)
+    expect(result).toHaveLength(1)
+    expect(result[0]!.input).toEqual({ command: 'ls' })
+  })
+
+  // -------------------------------------------------------------------------
+  // Multiple tool calls
+  // -------------------------------------------------------------------------
+
+  it('extracts multiple tool calls from text', () => {
+    const text = `Let me do two things:
+{"name": "bash", "arguments": {"command": "ls"}}
+And then:
+{"name": "file_read", "arguments": {"path": "/tmp/x"}}`
+    const result = extractToolCallsFromText(text, TOOLS)
+    expect(result).toHaveLength(2)
+    expect(result[0]!.name).toBe('bash')
+    expect(result[1]!.name).toBe('file_read')
+  })
+
+  // -------------------------------------------------------------------------
+  // Code fence wrapped
+  // -------------------------------------------------------------------------
+
+  it('extracts tool call from markdown code fence', () => {
+    const text = 'Here is the tool call:\n```json\n{"name": "bash", "arguments": {"command": "whoami"}}\n```'
+    const result = extractToolCallsFromText(text, TOOLS)
+    expect(result).toHaveLength(1)
+    expect(result[0]!.name).toBe('bash')
+    expect(result[0]!.input).toEqual({ command: 'whoami' })
+  })
+
+  it('extracts tool call from code fence without language tag', () => {
+    const text = '```\n{"name": "file_write", "arguments": {"path": "/tmp/a.txt", "content": "hi"}}\n```'
+    const result = extractToolCallsFromText(text, TOOLS)
+    expect(result).toHaveLength(1)
+    expect(result[0]!.name).toBe('file_write')
+  })
+
+  // -------------------------------------------------------------------------
+  // Hermes format
+  // -------------------------------------------------------------------------
+
+  it('extracts tool call from <tool_call> tags', () => {
+    const text = '<tool_call>\n{"name": "bash", "arguments": {"command": "date"}}\n</tool_call>'
+    const result = extractToolCallsFromText(text, TOOLS)
+    expect(result).toHaveLength(1)
+    expect(result[0]!.name).toBe('bash')
+    expect(result[0]!.input).toEqual({ command: 'date' })
+  })
+
+  it('extracts multiple hermes tool calls', () => {
+    const text = `<tool_call>{"name": "bash", "arguments": {"command": "ls"}}</tool_call>
+Some text in between
+<tool_call>{"name": "file_read", "arguments": {"path": "/tmp/x"}}</tool_call>`
+    const result = extractToolCallsFromText(text, TOOLS)
+    expect(result).toHaveLength(2)
+    expect(result[0]!.name).toBe('bash')
+    expect(result[1]!.name).toBe('file_read')
+  })
+
+  // -------------------------------------------------------------------------
+  // Edge cases
+  // -------------------------------------------------------------------------
+
+  it('skips malformed JSON gracefully', () => {
+    const text = '{"name": "bash", "arguments": {invalid json}}'
+    const result = extractToolCallsFromText(text, TOOLS)
+    expect(result).toEqual([])
+  })
+
+  it('skips JSON objects without a name field', () => {
+    const text = '{"command": "ls", "arguments": {"x": 1}}'
+    const result = extractToolCallsFromText(text, TOOLS)
+    expect(result).toEqual([])
+  })
+
+  it('works with empty knownToolNames (no whitelist filtering)', () => {
+    const text = '{"name": "anything", "arguments": {"x": 1}}'
+    const result = extractToolCallsFromText(text, [])
+    expect(result).toHaveLength(1)
+    expect(result[0]!.name).toBe('anything')
+  })
+
+  it('generates unique IDs for each extracted call', () => {
+    const text = `{"name": "bash", "arguments": {"command": "a"}}
+{"name": "bash", "arguments": {"command": "b"}}`
+    const result = extractToolCallsFromText(text, TOOLS)
+    expect(result).toHaveLength(2)
+    expect(result[0]!.id).not.toBe(result[1]!.id)
+  })
+
+  it('handles tool call with no arguments', () => {
+    const text = '{"name": "bash"}'
+    const result = extractToolCallsFromText(text, TOOLS)
+    expect(result).toHaveLength(1)
+    expect(result[0]!.input).toEqual({})
+  })
+
+  it('handles text with nested JSON objects that are not tool calls', () => {
+    const text = `Here is some config: {"port": 3000, "host": "localhost"}
+And a tool call: {"name": "bash", "arguments": {"command": "ls"}}`
+    const result = extractToolCallsFromText(text, TOOLS)
+    expect(result).toHaveLength(1)
+    expect(result[0]!.name).toBe('bash')
+  })
+})

package/tests/tool-executor.test.ts

@@ -0,0 +1,193 @@
+import { describe, it, expect, vi } from 'vitest'
+import { z } from 'zod'
+import { ToolRegistry, defineTool } from '../src/tool/framework.js'
+import { ToolExecutor } from '../src/tool/executor.js'
+import type { ToolUseContext } from '../src/types.js'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const dummyContext: ToolUseContext = {
+  agent: { name: 'test-agent', role: 'tester', model: 'test-model' },
+}
+
+function echoTool() {
+  return defineTool({
+    name: 'echo',
+    description: 'Echoes the message.',
+    inputSchema: z.object({ message: z.string() }),
+    execute: async ({ message }) => ({ data: message, isError: false }),
+  })
+}
+
+function failTool() {
+  return defineTool({
+    name: 'fail',
+    description: 'Always throws.',
+    inputSchema: z.object({}),
+    execute: async () => {
+      throw new Error('intentional failure')
+    },
+  })
+}
+
+function makeExecutor(...tools: ReturnType<typeof defineTool>[]) {
+  const registry = new ToolRegistry()
+  for (const t of tools) registry.register(t)
+  return { executor: new ToolExecutor(registry), registry }
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('ToolExecutor', () => {
+  // -------------------------------------------------------------------------
+  // Single execution
+  // -------------------------------------------------------------------------
+
+  it('executes a tool and returns its result', async () => {
+    const { executor } = makeExecutor(echoTool())
+    const result = await executor.execute('echo', { message: 'hello' }, dummyContext)
+    expect(result.data).toBe('hello')
+    expect(result.isError).toBeFalsy()
+  })
+
+  it('returns an error result for an unknown tool', async () => {
+    const { executor } = makeExecutor()
+    const result = await executor.execute('ghost', {}, dummyContext)
+    expect(result.isError).toBe(true)
+    expect(result.data).toContain('not registered')
+  })
+
+  it('returns an error result when Zod validation fails', async () => {
+    const { executor } = makeExecutor(echoTool())
+    // 'message' is required but missing
+    const result = await executor.execute('echo', {}, dummyContext)
+    expect(result.isError).toBe(true)
+    expect(result.data).toContain('Invalid input')
+  })
+
+  it('catches tool execution errors and returns them as error results', async () => {
+    const { executor } = makeExecutor(failTool())
+    const result = await executor.execute('fail', {}, dummyContext)
+    expect(result.isError).toBe(true)
+    expect(result.data).toContain('intentional failure')
+  })
+
+  it('returns an error result when aborted before execution', async () => {
+    const { executor } = makeExecutor(echoTool())
+    const controller = new AbortController()
+    controller.abort()
+
+    const result = await executor.execute(
+      'echo',
+      { message: 'hi' },
+      { ...dummyContext, abortSignal: controller.signal },
+    )
+    expect(result.isError).toBe(true)
+    expect(result.data).toContain('aborted')
+  })
+
+  // -------------------------------------------------------------------------
+  // Batch execution
+  // -------------------------------------------------------------------------
+
+  it('executeBatch runs multiple tools and returns a map of results', async () => {
+    const { executor } = makeExecutor(echoTool())
+    const results = await executor.executeBatch(
+      [
+        { id: 'c1', name: 'echo', input: { message: 'a' } },
+        { id: 'c2', name: 'echo', input: { message: 'b' } },
+      ],
+      dummyContext,
+    )
+
+    expect(results.size).toBe(2)
+    expect(results.get('c1')!.data).toBe('a')
+    expect(results.get('c2')!.data).toBe('b')
+  })
+
+  it('executeBatch isolates errors — one failure does not affect others', async () => {
+    const { executor } = makeExecutor(echoTool(), failTool())
+    const results = await executor.executeBatch(
+      [
+        { id: 'ok', name: 'echo', input: { message: 'fine' } },
+        { id: 'bad', name: 'fail', input: {} },
+      ],
+      dummyContext,
+    )
+
+    expect(results.get('ok')!.isError).toBeFalsy()
+    expect(results.get('bad')!.isError).toBe(true)
+  })
+
+  // -------------------------------------------------------------------------
+  // Concurrency control
+  // -------------------------------------------------------------------------
+
+  it('respects maxConcurrency limit', async () => {
+    let peak = 0
+    let running = 0
+
+    const trackTool = defineTool({
+      name: 'track',
+      description: 'Tracks concurrency.',
+      inputSchema: z.object({}),
+      execute: async () => {
+        running++
+        peak = Math.max(peak, running)
+        await new Promise((r) => setTimeout(r, 50))
+        running--
+        return { data: 'ok', isError: false }
+      },
+    })
+
+    const registry = new ToolRegistry()
+    registry.register(trackTool)
+    const executor = new ToolExecutor(registry, { maxConcurrency: 2 })
+
+    await executor.executeBatch(
+      Array.from({ length: 5 }, (_, i) => ({ id: `t${i}`, name: 'track', input: {} })),
+      dummyContext,
+    )
+
+    expect(peak).toBeLessThanOrEqual(2)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// ToolRegistry
+// ---------------------------------------------------------------------------
+
+describe('ToolRegistry', () => {
+  it('registers and retrieves a tool', () => {
+    const registry = new ToolRegistry()
+    registry.register(echoTool())
+    expect(registry.get('echo')).toBeDefined()
+    expect(registry.has('echo')).toBe(true)
+  })
+
+  it('throws on duplicate registration', () => {
+    const registry = new ToolRegistry()
+    registry.register(echoTool())
+    expect(() => registry.register(echoTool())).toThrow('already registered')
+  })
+
+  it('unregister removes the tool', () => {
+    const registry = new ToolRegistry()
+    registry.register(echoTool())
+    registry.unregister('echo')
+    expect(registry.has('echo')).toBe(false)
+  })
+
+  it('toToolDefs produces JSON schema representations', () => {
+    const registry = new ToolRegistry()
+    registry.register(echoTool())
+    const defs = registry.toToolDefs()
+    expect(defs).toHaveLength(1)
+    expect(defs[0].name).toBe('echo')
+    expect(defs[0].inputSchema).toHaveProperty('properties')
+  })
+})