agent-relay 3.2.3 → 3.2.4

package/packages/sdk/src/__tests__/communicate/a2a-types.test.ts

@@ -0,0 +1,297 @@
+import { describe, it, expect } from 'vitest';
+
+import {
+  type A2AAgentCard,
+  type A2AMessage,
+  type A2APart,
+  type A2ASkill,
+  type A2ATask,
+  type A2ATaskStatus,
+  VALID_TASK_STATES,
+  a2aAgentCardFromDict,
+  a2aAgentCardToDict,
+  a2aMessageFromDict,
+  a2aMessageGetText,
+  a2aMessageToDict,
+  a2aPartFromDict,
+  a2aPartToDict,
+  a2aSkillFromDict,
+  a2aSkillToDict,
+  a2aTaskFromDict,
+  a2aTaskStatusFromDict,
+  a2aTaskStatusToDict,
+  a2aTaskToDict,
+  createA2AAgentCard,
+  createA2AMessage,
+  createA2APart,
+  createA2ATask,
+  createA2ATaskStatus,
+  makeJsonRpcError,
+  makeJsonRpcRequest,
+  makeJsonRpcResponse,
+  JSONRPC_PARSE_ERROR,
+  JSONRPC_METHOD_NOT_FOUND,
+  JSONRPC_INTERNAL_ERROR,
+  A2A_TASK_NOT_FOUND,
+  A2A_TASK_NOT_CANCELABLE,
+} from '../../communicate/a2a-types.js';
+
+describe('A2APart', () => {
+  it('creates a text part', () => {
+    const part = createA2APart('hello');
+    expect(part.text).toBe('hello');
+  });
+
+  it('serializes to dict with only defined fields', () => {
+    const part: A2APart = { text: 'hello' };
+    const d = a2aPartToDict(part);
+    expect(d).toEqual({ text: 'hello' });
+    expect(d).not.toHaveProperty('file');
+    expect(d).not.toHaveProperty('data');
+  });
+
+  it('deserializes from dict', () => {
+    const d = { text: 'world', file: { uri: 'test.txt' } };
+    const part = a2aPartFromDict(d);
+    expect(part.text).toBe('world');
+    expect(part.file).toEqual({ uri: 'test.txt' });
+    expect(part.data).toBeUndefined();
+  });
+});
+
+describe('A2AMessage', () => {
+  it('creates with auto-generated messageId', () => {
+    const msg = createA2AMessage('user', [{ text: 'hi' }]);
+    expect(msg.role).toBe('user');
+    expect(msg.messageId).toBeDefined();
+    expect(msg.messageId!.length).toBeGreaterThan(0);
+    expect(msg.parts).toHaveLength(1);
+  });
+
+  it('creates with explicit messageId', () => {
+    const msg = createA2AMessage('agent', [{ text: 'reply' }], {
+      messageId: 'msg-123',
+      contextId: 'ctx-1',
+      taskId: 'task-1',
+    });
+    expect(msg.messageId).toBe('msg-123');
+    expect(msg.contextId).toBe('ctx-1');
+    expect(msg.taskId).toBe('task-1');
+  });
+
+  it('serializes and deserializes roundtrip', () => {
+    const msg = createA2AMessage('user', [{ text: 'hello' }, { text: 'world' }], {
+      messageId: 'test-id',
+      contextId: 'ctx-1',
+    });
+    const dict = a2aMessageToDict(msg);
+    const restored = a2aMessageFromDict(dict);
+    expect(restored.role).toBe('user');
+    expect(restored.parts).toHaveLength(2);
+    expect(restored.messageId).toBe('test-id');
+    expect(restored.contextId).toBe('ctx-1');
+  });
+
+  it('extracts concatenated text', () => {
+    const msg: A2AMessage = {
+      role: 'agent',
+      parts: [{ text: 'hello' }, { text: 'world' }, { data: { key: 'val' } }],
+    };
+    expect(a2aMessageGetText(msg)).toBe('hello world');
+  });
+
+  it('extracts empty text from no text parts', () => {
+    const msg: A2AMessage = { role: 'agent', parts: [{ data: { x: 1 } }] };
+    expect(a2aMessageGetText(msg)).toBe('');
+  });
+});
+
+describe('A2ATaskStatus', () => {
+  it('creates with auto timestamp', () => {
+    const status = createA2ATaskStatus('submitted');
+    expect(status.state).toBe('submitted');
+    expect(status.timestamp).toBeDefined();
+  });
+
+  it('serializes and deserializes roundtrip', () => {
+    const msg = createA2AMessage('agent', [{ text: 'done' }], { messageId: 'r1' });
+    const status = createA2ATaskStatus('completed', msg);
+    const dict = a2aTaskStatusToDict(status);
+    expect(dict.state).toBe('completed');
+    expect(dict.message).toBeDefined();
+
+    const restored = a2aTaskStatusFromDict(dict);
+    expect(restored.state).toBe('completed');
+    expect(restored.message?.role).toBe('agent');
+  });
+
+  it('deserializes without message', () => {
+    const dict = { state: 'working', timestamp: '2024-01-01T00:00:00Z' };
+    const status = a2aTaskStatusFromDict(dict);
+    expect(status.state).toBe('working');
+    expect(status.message).toBeUndefined();
+  });
+});
+
+describe('VALID_TASK_STATES', () => {
+  it('contains all expected states', () => {
+    expect(VALID_TASK_STATES.has('submitted')).toBe(true);
+    expect(VALID_TASK_STATES.has('working')).toBe(true);
+    expect(VALID_TASK_STATES.has('completed')).toBe(true);
+    expect(VALID_TASK_STATES.has('failed')).toBe(true);
+    expect(VALID_TASK_STATES.has('canceled')).toBe(true);
+    expect(VALID_TASK_STATES.has('unknown')).toBe(false);
+  });
+});
+
+describe('A2ATask', () => {
+  it('creates with defaults', () => {
+    const task = createA2ATask('task-1', 'ctx-1');
+    expect(task.id).toBe('task-1');
+    expect(task.contextId).toBe('ctx-1');
+    expect(task.status.state).toBe('submitted');
+    expect(task.messages).toEqual([]);
+    expect(task.artifacts).toEqual([]);
+  });
+
+  it('serializes and deserializes roundtrip', () => {
+    const task: A2ATask = {
+      id: 'task-42',
+      contextId: 'ctx-7',
+      status: createA2ATaskStatus('completed'),
+      messages: [createA2AMessage('user', [{ text: 'do stuff' }], { messageId: 'm1' })],
+      artifacts: [{ type: 'text', data: 'result' }],
+    };
+
+    const dict = a2aTaskToDict(task);
+    expect(dict.id).toBe('task-42');
+
+    const restored = a2aTaskFromDict(dict);
+    expect(restored.id).toBe('task-42');
+    expect(restored.contextId).toBe('ctx-7');
+    expect(restored.status.state).toBe('completed');
+    expect(restored.messages).toHaveLength(1);
+    expect(restored.artifacts).toHaveLength(1);
+  });
+
+  it('deserializes with missing status defaults to submitted', () => {
+    const dict = { id: 't1', messages: [], artifacts: [] };
+    const task = a2aTaskFromDict(dict);
+    expect(task.status.state).toBe('submitted');
+  });
+});
+
+describe('A2ASkill', () => {
+  it('serializes and deserializes', () => {
+    const skill: A2ASkill = {
+      id: 'billing',
+      name: 'Billing',
+      description: 'Handles billing queries',
+    };
+    const dict = a2aSkillToDict(skill);
+    expect(dict).toEqual({
+      id: 'billing',
+      name: 'Billing',
+      description: 'Handles billing queries',
+    });
+
+    const restored = a2aSkillFromDict(dict);
+    expect(restored).toEqual(skill);
+  });
+});
+
+describe('A2AAgentCard', () => {
+  it('creates with defaults', () => {
+    const card = createA2AAgentCard('test-agent', 'A test agent', 'http://localhost:5000');
+    expect(card.name).toBe('test-agent');
+    expect(card.version).toBe('1.0.0');
+    expect(card.capabilities).toEqual({ streaming: true, pushNotifications: false });
+    expect(card.defaultInputModes).toEqual(['text']);
+    expect(card.defaultOutputModes).toEqual(['text']);
+    expect(card.skills).toEqual([]);
+  });
+
+  it('creates with skills', () => {
+    const skills: A2ASkill[] = [{ id: 's1', name: 'Search', description: 'Search things' }];
+    const card = createA2AAgentCard('agent', 'desc', 'http://localhost:5000', skills);
+    expect(card.skills).toHaveLength(1);
+    expect(card.skills[0].id).toBe('s1');
+  });
+
+  it('serializes and deserializes roundtrip', () => {
+    const card = createA2AAgentCard(
+      'my-agent',
+      'My agent',
+      'http://example.com',
+      [{ id: 'sk1', name: 'Skill1', description: 'Does skill1' }],
+    );
+    const dict = a2aAgentCardToDict(card);
+    const restored = a2aAgentCardFromDict(dict);
+    expect(restored.name).toBe('my-agent');
+    expect(restored.description).toBe('My agent');
+    expect(restored.url).toBe('http://example.com');
+    expect(restored.version).toBe('1.0.0');
+    expect(restored.skills).toHaveLength(1);
+    expect(restored.skills[0].name).toBe('Skill1');
+  });
+
+  it('deserializes with defaults for missing fields', () => {
+    const dict = { name: 'agent', description: 'desc', url: 'http://localhost' };
+    const card = a2aAgentCardFromDict(dict);
+    expect(card.version).toBe('1.0.0');
+    expect(card.capabilities).toEqual({ streaming: true, pushNotifications: false });
+    expect(card.defaultInputModes).toEqual(['text']);
+    expect(card.defaultOutputModes).toEqual(['text']);
+    expect(card.skills).toEqual([]);
+  });
+});
+
+describe('JSON-RPC helpers', () => {
+  it('makeJsonRpcRequest creates valid request', () => {
+    const req = makeJsonRpcRequest('message/send', { message: { role: 'user', parts: [] } }, 'req-1');
+    expect(req.jsonrpc).toBe('2.0');
+    expect(req.method).toBe('message/send');
+    expect(req.id).toBe('req-1');
+    expect(req.params).toHaveProperty('message');
+  });
+
+  it('makeJsonRpcRequest auto-generates id', () => {
+    const req = makeJsonRpcRequest('test', {});
+    expect(req.id).toBeDefined();
+    expect(typeof req.id).toBe('string');
+  });
+
+  it('makeJsonRpcResponse creates valid response', () => {
+    const res = makeJsonRpcResponse({ ok: true }, 'req-1');
+    expect(res.jsonrpc).toBe('2.0');
+    expect(res.result).toEqual({ ok: true });
+    expect(res.id).toBe('req-1');
+    expect(res.error).toBeUndefined();
+  });
+
+  it('makeJsonRpcError creates valid error response', () => {
+    const res = makeJsonRpcError(-32600, 'Invalid request', 'req-1');
+    expect(res.jsonrpc).toBe('2.0');
+    expect(res.error).toEqual({ code: -32600, message: 'Invalid request' });
+    expect(res.id).toBe('req-1');
+    expect(res.result).toBeUndefined();
+  });
+
+  it('makeJsonRpcError handles null id', () => {
+    const res = makeJsonRpcError(-32700, 'Parse error', null);
+    expect(res.id).toBeNull();
+  });
+});
+
+describe('Error code constants', () => {
+  it('has correct standard JSON-RPC codes', () => {
+    expect(JSONRPC_PARSE_ERROR).toBe(-32700);
+    expect(JSONRPC_METHOD_NOT_FOUND).toBe(-32601);
+    expect(JSONRPC_INTERNAL_ERROR).toBe(-32603);
+  });
+
+  it('has correct A2A-specific codes', () => {
+    expect(A2A_TASK_NOT_FOUND).toBe(-32001);
+    expect(A2A_TASK_NOT_CANCELABLE).toBe(-32002);
+  });
+});

package/packages/sdk/src/__tests__/communicate/adapters/claude-sdk.test.ts

@@ -0,0 +1,163 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+const claudeAdapterModulePath = '../../../communicate/adapters/claude-sdk.js';
+
+async function loadClaudeAdapterModule(): Promise<any> {
+  return import(claudeAdapterModulePath);
+}
+
+class FakeRelay {
+  inboxCalls = 0;
+  private queuedMessages: any[] = [];
+
+  queue(...messages: any[]): void {
+    this.queuedMessages.push(...messages);
+  }
+
+  async inbox(): Promise<any[]> {
+    this.inboxCalls += 1;
+    const drained = [...this.queuedMessages];
+    this.queuedMessages = [];
+    return drained;
+  }
+}
+
+function getAddedHook(options: any, eventName: 'PostToolUse' | 'Stop') {
+  const matchers = options.hooks?.[eventName];
+  assert.ok(Array.isArray(matchers), `Expected ${eventName} matchers to be configured`);
+  assert.ok(matchers.length > 0, `Expected at least one ${eventName} matcher`);
+
+  const matcher = matchers.at(-1);
+  assert.ok(Array.isArray(matcher.hooks), `Expected ${eventName} matcher to contain hook callbacks`);
+  assert.equal(matcher.hooks.length, 1);
+
+  return matcher.hooks[0];
+}
+
+test('Claude onRelay injects the Relaycast MCP server into query options', async () => {
+  const { onRelay } = await loadClaudeAdapterModule();
+  const relay = new FakeRelay();
+
+  const options = onRelay(
+    'ClaudeTester',
+    {
+      mcpServers: {
+        existing: {
+          command: 'node',
+          args: ['./other-mcp.js'],
+        },
+      },
+    },
+    relay
+  );
+
+  assert.ok(options.mcpServers);
+  assert.deepEqual(options.mcpServers.existing, {
+    command: 'node',
+    args: ['./other-mcp.js'],
+  });
+  assert.deepEqual(options.mcpServers.relaycast, {
+    command: 'agent-relay',
+    args: ['mcp'],
+  });
+  assert.ok(options.hooks?.PostToolUse?.length);
+  assert.ok(options.hooks?.Stop?.length);
+});
+
+test('Claude PostToolUse hook returns a systemMessage when relay inbox messages are pending', async () => {
+  const { onRelay } = await loadClaudeAdapterModule();
+  const relay = new FakeRelay();
+  relay.queue({
+    sender: 'Other',
+    text: 'Hello',
+    messageId: 'message-1',
+  });
+
+  const options = onRelay('ClaudeTester', {}, relay);
+  const postToolUseHook = getAddedHook(options, 'PostToolUse');
+
+  const result = await postToolUseHook(
+    {
+      hook_event_name: 'PostToolUse',
+      tool_name: 'Read',
+      tool_input: {},
+      tool_response: {},
+      tool_use_id: 'tool-1',
+    },
+    'tool-1',
+    { signal: new AbortController().signal }
+  );
+
+  assert.equal(relay.inboxCalls, 1);
+  assert.ok(result);
+  assert.equal(typeof result.systemMessage, 'string');
+  assert.match(result.systemMessage, /New messages from other agents:/);
+  assert.match(result.systemMessage, /Relay message from Other: Hello/);
+});
+
+test('Claude Stop hook continues the agent when relay messages are pending', async () => {
+  const { onRelay } = await loadClaudeAdapterModule();
+  const relay = new FakeRelay();
+  relay.queue({
+    sender: 'Other',
+    text: 'Wait!',
+    messageId: 'message-2',
+  });
+
+  const options = onRelay('ClaudeTester', {}, relay);
+  const stopHook = getAddedHook(options, 'Stop');
+
+  const result = await stopHook(
+    {
+      hook_event_name: 'Stop',
+      stop_hook_active: true,
+      last_assistant_message: 'Stopping now',
+    },
+    undefined,
+    { signal: new AbortController().signal }
+  );
+
+  assert.equal(relay.inboxCalls, 1);
+  assert.ok(result);
+  assert.equal(result.continue, true);
+  assert.equal(typeof result.systemMessage, 'string');
+  assert.match(result.systemMessage, /Relay message from Other: Wait!/);
+});
+
+test('Claude onRelay preserves existing PostToolUse and Stop hook matchers', async () => {
+  const { onRelay } = await loadClaudeAdapterModule();
+  const relay = new FakeRelay();
+
+  const existingPostToolUse = async () => ({ systemMessage: 'Existing post hook' });
+  const existingStop = async () => ({ continue: false, systemMessage: 'Existing stop hook' });
+
+  const options = onRelay(
+    'ClaudeTester',
+    {
+      hooks: {
+        PostToolUse: [
+          {
+            matcher: 'existing-post',
+            hooks: [existingPostToolUse],
+          },
+        ],
+        Stop: [
+          {
+            matcher: 'existing-stop',
+            hooks: [existingStop],
+          },
+        ],
+      },
+    },
+    relay
+  );
+
+  assert.equal(options.hooks.PostToolUse.length, 2);
+  assert.equal(options.hooks.PostToolUse[0].hooks[0], existingPostToolUse);
+  assert.equal(options.hooks.PostToolUse[0].matcher, 'existing-post');
+
+  assert.equal(options.hooks.Stop.length, 2);
+  assert.equal(options.hooks.Stop[0].hooks[0], existingStop);
+  assert.equal(options.hooks.Stop[0].matcher, 'existing-stop');
+});

package/packages/sdk/src/__tests__/communicate/adapters/crewai.test.ts

@@ -0,0 +1,219 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+const crewaiAdapterModulePath = '../../../communicate/adapters/crewai.js';
+
+async function loadCrewAIAdapterModule(): Promise<any> {
+  return import(crewaiAdapterModulePath);
+}
+
+class FakeRelay {
+  private callbacks: Array<(message: any) => void | Promise<void>> = [];
+  sendCalls: Array<{ to: string; text: string }> = [];
+  postCalls: Array<{ channel: string; text: string }> = [];
+
+  async send(to: string, text: string): Promise<void> {
+    this.sendCalls.push({ to, text });
+  }
+
+  async post(channel: string, text: string): Promise<void> {
+    this.postCalls.push({ channel, text });
+  }
+
+  async inbox(): Promise<any[]> {
+    return [];
+  }
+
+  async agents(): Promise<string[]> {
+    return ['Lead', 'Worker-1'];
+  }
+
+  onMessage(callback: (message: any) => void | Promise<void>): () => void {
+    this.callbacks.push(callback);
+    return () => {
+      this.callbacks = this.callbacks.filter((entry) => entry !== callback);
+    };
+  }
+
+  async emit(message: any): Promise<void> {
+    for (const callback of [...this.callbacks]) {
+      await callback(message);
+    }
+  }
+}
+
+function createAgent(opts: { role?: string; tools?: any[]; step_callback?: any } = {}) {
+  return {
+    role: opts.role ?? 'researcher',
+    tools: opts.tools ?? [],
+    step_callback: opts.step_callback ?? null,
+  };
+}
+
+function createCrew(agents: any[]) {
+  return {
+    agents,
+    task_callback: null,
+  };
+}
+
+test('CrewAI onRelay appends relay tools to agent.tools', async () => {
+  const { onRelay } = await loadCrewAIAdapterModule();
+  const relay = new FakeRelay();
+  const agent = createAgent({ tools: [{ tool_name: 'existing_tool', description: 'Existing' }] });
+
+  onRelay(agent, relay);
+
+  const toolNames = agent.tools.map((t: any) => t.tool_name);
+  assert.deepEqual(toolNames, [
+    'existing_tool',
+    'relay_send',
+    'relay_inbox',
+    'relay_post',
+    'relay_agents',
+  ]);
+
+  for (const toolName of ['relay_send', 'relay_inbox', 'relay_post', 'relay_agents']) {
+    const tool = agent.tools.find((t: any) => t.tool_name === toolName);
+    assert.ok(tool, `Expected ${toolName} to be registered`);
+    assert.equal(typeof tool.execute, 'function');
+    assert.ok(tool.description);
+  }
+});
+
+test('CrewAI relay_send tool calls relay.send', async () => {
+  const { onRelay } = await loadCrewAIAdapterModule();
+  const relay = new FakeRelay();
+  const agent = createAgent();
+
+  onRelay(agent, relay);
+
+  const sendTool = agent.tools.find((t: any) => t.tool_name === 'relay_send');
+  const result = await sendTool.execute({ to: 'Worker-1', text: 'hello' });
+
+  assert.equal(relay.sendCalls.length, 1);
+  assert.deepEqual(relay.sendCalls[0], { to: 'Worker-1', text: 'hello' });
+  assert.match(result, /Sent relay message to Worker-1/);
+});
+
+test('CrewAI relay_post tool calls relay.post', async () => {
+  const { onRelay } = await loadCrewAIAdapterModule();
+  const relay = new FakeRelay();
+  const agent = createAgent();
+
+  onRelay(agent, relay);
+
+  const postTool = agent.tools.find((t: any) => t.tool_name === 'relay_post');
+  const result = await postTool.execute({ channel: 'general', text: 'update' });
+
+  assert.equal(relay.postCalls.length, 1);
+  assert.deepEqual(relay.postCalls[0], { channel: 'general', text: 'update' });
+  assert.match(result, /Posted relay message to #general/);
+});
+
+test('CrewAI relay_inbox tool returns formatted inbox', async () => {
+  const { onRelay } = await loadCrewAIAdapterModule();
+  const relay = new FakeRelay();
+  const agent = createAgent();
+
+  onRelay(agent, relay);
+
+  const inboxTool = agent.tools.find((t: any) => t.tool_name === 'relay_inbox');
+  const result = await inboxTool.execute({});
+
+  assert.equal(result, 'No new relay messages.');
+});
+
+test('CrewAI relay_agents tool lists agents', async () => {
+  const { onRelay } = await loadCrewAIAdapterModule();
+  const relay = new FakeRelay();
+  const agent = createAgent();
+
+  onRelay(agent, relay);
+
+  const agentsTool = agent.tools.find((t: any) => t.tool_name === 'relay_agents');
+  const result = await agentsTool.execute({});
+
+  assert.equal(result, 'Lead\nWorker-1');
+});
+
+test('CrewAI onRelay routes incoming messages via step_callback', async () => {
+  const { onRelay } = await loadCrewAIAdapterModule();
+  const relay = new FakeRelay();
+  const stepCalls: any[] = [];
+  const agent = createAgent({
+    step_callback: (step: any) => { stepCalls.push(step); },
+  });
+
+  onRelay(agent, relay);
+
+  await relay.emit({
+    sender: 'Lead',
+    text: 'Need status update',
+    messageId: 'msg-1',
+  });
+
+  assert.equal(stepCalls.length, 1);
+  assert.ok(stepCalls[0].relay_message);
+  assert.match(stepCalls[0].relay_message, /Lead/);
+  assert.match(stepCalls[0].relay_message, /Need status update/);
+});
+
+test('CrewAI onRelay unsubscribe stops message routing', async () => {
+  const { onRelay } = await loadCrewAIAdapterModule();
+  const relay = new FakeRelay();
+  const stepCalls: any[] = [];
+  const agent = createAgent({
+    step_callback: (step: any) => { stepCalls.push(step); },
+  });
+
+  const { unsubscribe } = onRelay(agent, relay);
+
+  await relay.emit({ sender: 'A', text: 'first', messageId: 'm1' });
+  assert.equal(stepCalls.length, 1);
+
+  unsubscribe();
+
+  await relay.emit({ sender: 'B', text: 'second', messageId: 'm2' });
+  assert.equal(stepCalls.length, 1); // no new calls after unsubscribe
+});
+
+test('CrewAI onCrewRelay adds tools to all agents in a crew', async () => {
+  const { onCrewRelay } = await loadCrewAIAdapterModule();
+  const relay = new FakeRelay();
+  const agent1 = createAgent({ role: 'researcher' });
+  const agent2 = createAgent({ role: 'writer' });
+  const crew = createCrew([agent1, agent2]);
+
+  onCrewRelay(crew, relay);
+
+  for (const agent of [agent1, agent2]) {
+    const toolNames = agent.tools.map((t: any) => t.tool_name);
+    assert.ok(toolNames.includes('relay_send'), `${agent.role} should have relay_send`);
+    assert.ok(toolNames.includes('relay_inbox'), `${agent.role} should have relay_inbox`);
+    assert.ok(toolNames.includes('relay_post'), `${agent.role} should have relay_post`);
+    assert.ok(toolNames.includes('relay_agents'), `${agent.role} should have relay_agents`);
+  }
+});
+
+test('CrewAI onCrewRelay unsubscribe stops all routing', async () => {
+  const { onCrewRelay } = await loadCrewAIAdapterModule();
+  const relay = new FakeRelay();
+  const stepCalls1: any[] = [];
+  const stepCalls2: any[] = [];
+  const agent1 = createAgent({ role: 'a1', step_callback: (s: any) => { stepCalls1.push(s); } });
+  const agent2 = createAgent({ role: 'a2', step_callback: (s: any) => { stepCalls2.push(s); } });
+  const crew = createCrew([agent1, agent2]);
+
+  const { unsubscribe } = onCrewRelay(crew, relay);
+
+  await relay.emit({ sender: 'X', text: 'ping', messageId: 'm1' });
+  assert.equal(stepCalls1.length, 1);
+  assert.equal(stepCalls2.length, 1);
+
+  unsubscribe();
+
+  await relay.emit({ sender: 'Y', text: 'pong', messageId: 'm2' });
+  assert.equal(stepCalls1.length, 1);
+  assert.equal(stepCalls2.length, 1);
+});