agent-relay 3.2.2 → 3.2.4

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

@@ -0,0 +1,101 @@
+import assert from 'node:assert/strict';
+import { randomUUID } from 'node:crypto';
+import test from 'node:test';
+
+import { Relay } from '../../../communicate/core.js';
+import { onRelay, onCrewRelay } from '../../../communicate/adapters/crewai.js';
+
+const AGENT_NAME = `e2e-crewai-${randomUUID().slice(0, 8)}`;
+
+function createAgent(role: string) {
+  return {
+    role,
+    tools: [] as any[],
+    step_callback: null as ((step: any) => void) | null,
+  };
+}
+
+test('CrewAI adapter e2e: onRelay tools work against live Relaycast', async () => {
+  const relay = new Relay(AGENT_NAME, { autoCleanup: false });
+
+  try {
+    const agent = createAgent(AGENT_NAME);
+    const { unsubscribe } = onRelay(agent, relay);
+
+    const findTool = (name: string) => {
+      const tool = agent.tools.find((t: any) => t.tool_name === name);
+      assert.ok(tool, `Tool ${name} not found`);
+      return tool;
+    };
+
+    const relaySend = findTool('relay_send');
+    const relayInbox = findTool('relay_inbox');
+    const relayPost = findTool('relay_post');
+    const relayAgents = findTool('relay_agents');
+
+    // relay_agents: should list at least our agent
+    const agentsResult = await relayAgents.execute({});
+    console.log('relay_agents result:', agentsResult);
+    assert.ok(agentsResult.includes(AGENT_NAME), `Expected agent list to include ${AGENT_NAME}`);
+
+    // relay_send: send a DM to ourselves
+    const sendResult = await relaySend.execute({ to: AGENT_NAME, text: 'e2e self-ping' });
+    console.log('relay_send result:', sendResult);
+    assert.ok(sendResult.includes('Sent relay message'), 'Expected send confirmation');
+
+    // relay_post: post to general channel
+    const postResult = await relayPost.execute({ channel: 'general', text: `e2e crewai test from ${AGENT_NAME}` });
+    console.log('relay_post result:', postResult);
+    assert.ok(postResult.includes('Posted relay message'), 'Expected post confirmation');
+
+    // relay_inbox: drain inbox
+    const inboxResult = await relayInbox.execute({});
+    console.log('relay_inbox result:', inboxResult);
+    assert.ok(typeof inboxResult === 'string', 'Expected inbox text string');
+
+    // unsubscribe: stop message routing
+    unsubscribe();
+    console.log('onRelay unsubscribe called successfully.');
+
+    console.log('All CrewAI onRelay e2e checks passed.');
+  } finally {
+    await relay.close();
+    console.log('Relay connection closed.');
+  }
+});
+
+test('CrewAI adapter e2e: onCrewRelay adds tools to all crew agents', async () => {
+  const crewAgentName = `e2e-crew-${randomUUID().slice(0, 8)}`;
+  const relay = new Relay(crewAgentName, { autoCleanup: false });
+
+  try {
+    const agent1 = createAgent('researcher');
+    const agent2 = createAgent('writer');
+    const crew = { agents: [agent1, agent2], task_callback: null };
+
+    const { unsubscribe } = onCrewRelay(crew, relay);
+
+    // Both agents should have all 4 relay tools
+    for (const agent of [agent1, agent2]) {
+      const toolNames = agent.tools.map((t: any) => t.tool_name);
+      assert.ok(toolNames.includes('relay_send'), `${agent.role} missing relay_send`);
+      assert.ok(toolNames.includes('relay_inbox'), `${agent.role} missing relay_inbox`);
+      assert.ok(toolNames.includes('relay_post'), `${agent.role} missing relay_post`);
+      assert.ok(toolNames.includes('relay_agents'), `${agent.role} missing relay_agents`);
+    }
+
+    // Use a tool from one of the crew agents against live API
+    const agentsTool = agent1.tools.find((t: any) => t.tool_name === 'relay_agents');
+    const agentsResult = await agentsTool.execute({});
+    console.log('onCrewRelay relay_agents result:', agentsResult);
+    assert.ok(agentsResult.includes(crewAgentName), `Expected crew agent ${crewAgentName} in list`);
+
+    unsubscribe();
+    console.log('onCrewRelay unsubscribe called successfully.');
+
+    console.log('All CrewAI onCrewRelay e2e checks passed.');
+  } finally {
+    await relay.close();
+    console.log('Crew relay connection closed.');
+  }
+});

package/packages/sdk/src/__tests__/communicate/adapters/e2e-google-adk.test.ts

@@ -0,0 +1,166 @@
+import assert from 'node:assert/strict';
+import { randomUUID } from 'node:crypto';
+import test from 'node:test';
+
+import { onRelay } from '../../../communicate/adapters/google-adk.js';
+import type { Message, MessageCallback } from '../../../communicate/types.js';
+
+const API_KEY = process.env.RELAY_API_KEY!;
+const BASE_URL = (process.env.RELAY_BASE_URL ?? 'https://api.relaycast.dev').replace(/\/+$/, '');
+const AGENT_NAME = `e2e-adk-${randomUUID().slice(0, 8)}`;
+
+class LiveRelay {
+  private agentToken?: string;
+  private agentId?: string;
+  private callbacks: MessageCallback[] = [];
+
+  constructor(private readonly name: string) {}
+
+  async register(): Promise<void> {
+    const res = await fetch(`${BASE_URL}/v1/agents`, {
+      method: 'POST',
+      headers: { authorization: `Bearer ${API_KEY}`, 'content-type': 'application/json' },
+      body: JSON.stringify({ name: this.name, type: 'agent' }),
+    });
+    const body = (await res.json()) as any;
+    if (!body.ok) throw new Error(`Register failed: ${JSON.stringify(body)}`);
+    this.agentId = body.data.id;
+    this.agentToken = body.data.token;
+  }
+
+  async send(to: string, text: string): Promise<void> {
+    const res = await fetch(`${BASE_URL}/v1/dm`, {
+      method: 'POST',
+      headers: { authorization: `Bearer ${this.agentToken}`, 'content-type': 'application/json' },
+      body: JSON.stringify({ to, text }),
+    });
+    const body = (await res.json()) as any;
+    if (!body.ok) throw new Error(`DM failed: ${JSON.stringify(body)}`);
+  }
+
+  async post(channel: string, text: string): Promise<void> {
+    const res = await fetch(`${BASE_URL}/v1/channels/${encodeURIComponent(channel)}/messages`, {
+      method: 'POST',
+      headers: { authorization: `Bearer ${this.agentToken}`, 'content-type': 'application/json' },
+      body: JSON.stringify({ text }),
+    });
+    const body = (await res.json()) as any;
+    if (!body.ok) throw new Error(`Post failed: ${JSON.stringify(body)}`);
+  }
+
+  async inbox(): Promise<Message[]> {
+    const res = await fetch(`${BASE_URL}/v1/inbox`, {
+      headers: { authorization: `Bearer ${this.agentToken}` },
+    });
+    const body = (await res.json()) as any;
+    if (!body.ok) throw new Error(`Inbox failed: ${JSON.stringify(body)}`);
+    const msgs: Message[] = [];
+    for (const dm of body.data.unread_dms ?? []) {
+      msgs.push({ sender: dm.from ?? 'unknown', text: dm.text ?? '' });
+    }
+    return msgs;
+  }
+
+  async agents(): Promise<string[]> {
+    const res = await fetch(`${BASE_URL}/v1/agents`, {
+      headers: { authorization: `Bearer ${API_KEY}` },
+    });
+    const body = (await res.json()) as any;
+    if (!body.ok) throw new Error(`Agents failed: ${JSON.stringify(body)}`);
+    return (body.data as any[]).map((a: any) => a.name);
+  }
+
+  onMessage(callback: MessageCallback): () => void {
+    this.callbacks.push(callback);
+    return () => {
+      this.callbacks = this.callbacks.filter((c) => c !== callback);
+    };
+  }
+
+  async close(): Promise<void> {
+    if (!this.agentId) return;
+    try {
+      await fetch(`${BASE_URL}/v1/agents/${this.agentId}`, {
+        method: 'DELETE',
+        headers: { authorization: `Bearer ${API_KEY}` },
+      });
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
+test('Google ADK adapter e2e: relay tools work against live Relaycast', async () => {
+  const relay = new LiveRelay(AGENT_NAME);
+  await relay.register();
+
+  try {
+    const mockAgent = { name: 'test-adk-agent', tools: [] as any[] };
+    const { agent, tools, unsubscribe } = onRelay(AGENT_NAME, { agent: mockAgent }, relay);
+
+    // Verify tools were injected into the agent
+    assert.ok(agent.tools.length >= 4, `Expected >= 4 relay tools on agent, got ${agent.tools.length}`);
+
+    const findTool = (name: string) => {
+      const tool = tools.find((t: any) => t.name === name);
+      assert.ok(tool, `Tool ${name} not found`);
+      return tool;
+    };
+
+    const relayAgents = findTool('relay_agents');
+    const relaySend = findTool('relay_send');
+    const relayPost = findTool('relay_post');
+    const relayInbox = findTool('relay_inbox');
+
+    // 1. relay_agents — should include our freshly registered agent
+    const agentsResult = await (relayAgents as any).execute({});
+    const agentsText = agentsResult.result as string;
+    console.log('relay_agents:', agentsText.split('\n').length, 'agents');
+    assert.ok(agentsText.includes(AGENT_NAME), `Agent list must include ${AGENT_NAME}`);
+
+    // 2. relay_send — DM to self
+    const sendResult = await (relaySend as any).execute({ to: AGENT_NAME, text: 'e2e self-ping' });
+    console.log('relay_send:', sendResult.result);
+    assert.ok((sendResult.result as string).includes('Sent relay message'));
+
+    // 3. relay_post — post to general channel
+    const postResult = await (relayPost as any).execute({
+      channel: 'general',
+      text: `e2e ADK test from ${AGENT_NAME}`,
+    });
+    console.log('relay_post:', postResult.result);
+    assert.ok((postResult.result as string).includes('Posted relay message'));
+
+    // 4. relay_inbox — drain inbox
+    await new Promise((r) => setTimeout(r, 1000));
+    const inboxResult = await (relayInbox as any).execute({});
+    console.log('relay_inbox:', inboxResult.result);
+    assert.ok(typeof inboxResult.result === 'string');
+
+    // 5. Verify unsubscribe stops routing
+    let routerFired = false;
+    const mockRunner = {
+      async *runAsync() {
+        routerFired = true;
+      },
+    };
+    const { unsubscribe: unsub2 } = onRelay(
+      `${AGENT_NAME}-sub`,
+      { agent: { name: 'sub-agent', tools: [] }, runner: mockRunner },
+      relay,
+    );
+    unsub2();
+    // After unsubscribe, incoming messages should NOT invoke the runner
+    await (relaySend as any).execute({ to: AGENT_NAME, text: 'should-not-route' });
+    await new Promise((r) => setTimeout(r, 500));
+    assert.ok(!routerFired, 'Expected runner NOT to fire after unsubscribe');
+
+    // Also test that unsubscribe from the main config works
+    unsubscribe();
+
+    console.log('All Google ADK adapter e2e checks passed.');
+  } finally {
+    await relay.close();
+    console.log('Relay closed.');
+  }
+});

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

@@ -0,0 +1,181 @@
+import assert from 'node:assert/strict';
+import { randomUUID } from 'node:crypto';
+import test from 'node:test';
+import { setTimeout as sleep } from 'node:timers/promises';
+
+import { onRelay, type RelayToolDef } from '../../../communicate/adapters/langgraph.js';
+import type { Message, MessageCallback } from '../../../communicate/types.js';
+
+const API_KEY = process.env.RELAY_API_KEY!;
+const BASE_URL = (process.env.RELAY_BASE_URL ?? 'https://api.relaycast.dev').replace(/\/+$/, '');
+const AGENT_NAME = `e2e-lg-${randomUUID().slice(0, 8)}`;
+const CHANNEL = 'general';
+
+/**
+ * Thin RelayLike wrapper that talks to the real Relaycast API using correct
+ * endpoints (POST /v1/agents, POST /v1/channels/{name}/messages, etc.).
+ * The SDK's Relay/RelayTransport uses legacy routes that 404 on the live API,
+ * so we bypass it for this e2e test.
+ */
+class LiveRelay {
+  private agentToken?: string;
+  private agentId?: string;
+  private callbacks = new Set<MessageCallback>();
+
+  constructor(private name: string) {}
+
+  async register(): Promise<void> {
+    const res = await fetch(`${BASE_URL}/v1/agents`, {
+      method: 'POST',
+      headers: { authorization: `Bearer ${API_KEY}`, 'content-type': 'application/json' },
+      body: JSON.stringify({ name: this.name }),
+    });
+    if (!res.ok) throw new Error(`register failed: ${res.status} ${await res.text()}`);
+    const body = (await res.json()) as any;
+    this.agentToken = body.data.token;
+    this.agentId = body.data.id;
+
+    // join channel
+    await fetch(`${BASE_URL}/v1/channels/${CHANNEL}/join`, {
+      method: 'POST',
+      headers: { authorization: `Bearer ${this.agentToken}` },
+    });
+  }
+
+  async send(to: string, text: string): Promise<void> {
+    const res = await fetch(`${BASE_URL}/v1/dm`, {
+      method: 'POST',
+      headers: { authorization: `Bearer ${this.agentToken}`, 'content-type': 'application/json' },
+      body: JSON.stringify({ to, text }),
+    });
+    if (!res.ok) throw new Error(`send failed: ${res.status} ${await res.text()}`);
+  }
+
+  async post(channel: string, text: string): Promise<void> {
+    const res = await fetch(`${BASE_URL}/v1/channels/${encodeURIComponent(channel)}/messages`, {
+      method: 'POST',
+      headers: { authorization: `Bearer ${this.agentToken}`, 'content-type': 'application/json' },
+      body: JSON.stringify({ text }),
+    });
+    if (!res.ok) throw new Error(`post failed: ${res.status} ${await res.text()}`);
+  }
+
+  async inbox(): Promise<Message[]> {
+    const res = await fetch(`${BASE_URL}/v1/inbox`, {
+      headers: { authorization: `Bearer ${this.agentToken}` },
+    });
+    if (!res.ok) throw new Error(`inbox failed: ${res.status} ${await res.text()}`);
+    const body = (await res.json()) as any;
+    const msgs: Message[] = [];
+    for (const dm of body.data?.unread_dms ?? []) {
+      msgs.push({ sender: dm.from ?? '', text: dm.text ?? '' });
+    }
+    return msgs;
+  }
+
+  async agents(): Promise<string[]> {
+    const res = await fetch(`${BASE_URL}/v1/agents`, {
+      headers: { authorization: `Bearer ${API_KEY}` },
+    });
+    if (!res.ok) throw new Error(`agents failed: ${res.status} ${await res.text()}`);
+    const body = (await res.json()) as any;
+    return (body.data ?? []).map((a: any) => a.name as string);
+  }
+
+  onMessage(callback: MessageCallback): () => void {
+    this.callbacks.add(callback);
+    return () => { this.callbacks.delete(callback); };
+  }
+
+  async simulateIncoming(message: Message): Promise<void> {
+    for (const cb of [...this.callbacks]) await cb(message);
+  }
+
+  async disconnect(): Promise<void> {
+    if (!this.agentToken) return;
+    await fetch(`${BASE_URL}/v1/agents/disconnect`, {
+      method: 'POST',
+      headers: { authorization: `Bearer ${this.agentToken}` },
+    }).catch(() => {});
+  }
+}
+
+function createFakeGraph() {
+  return {
+    nodes: {},
+    invokeCalls: [] as Array<{ input: Record<string, unknown> }>,
+    async invoke(input: Record<string, unknown>) {
+      this.invokeCalls.push({ input });
+      return { messages: [] };
+    },
+  };
+}
+
+test('LangGraph e2e: full lifecycle against live Relaycast', async () => {
+  const relay = new LiveRelay(AGENT_NAME);
+  await relay.register();
+  console.log(`[e2e] Registered agent: ${AGENT_NAME}`);
+
+  const graph = createFakeGraph();
+
+  try {
+    // 1. onRelay returns tools and unsubscribe handle
+    const result = onRelay(graph, relay as any);
+    assert.ok(result.tools, 'tools should be defined');
+    assert.ok(typeof result.unsubscribe === 'function', 'unsubscribe should be a function');
+
+    const toolMap = new Map<string, RelayToolDef>();
+    for (const t of result.tools) toolMap.set(t.name, t);
+
+    assert.ok(toolMap.has('relay_send'), 'should have relay_send');
+    assert.ok(toolMap.has('relay_inbox'), 'should have relay_inbox');
+    assert.ok(toolMap.has('relay_post'), 'should have relay_post');
+    assert.ok(toolMap.has('relay_agents'), 'should have relay_agents');
+    console.log('[e2e] onRelay returned 4 tools + unsubscribe');
+
+    // 2. relay_agents returns a real agent list that includes ourselves
+    const agentsOutput = await toolMap.get('relay_agents')!.invoke({});
+    assert.ok(typeof agentsOutput === 'string', 'agents output should be a string');
+    const agentNames = agentsOutput.split('\n');
+    assert.ok(agentNames.includes(AGENT_NAME), `agents list should include "${AGENT_NAME}"`);
+    console.log(`[e2e] relay_agents OK: ${agentNames.length} agent(s), self found`);
+
+    // 3. relay_post sends a message to a channel (real HTTP 201)
+    const postOutput = await toolMap.get('relay_post')!.invoke({ channel: CHANNEL, text: `e2e post from ${AGENT_NAME}` });
+    assert.equal(postOutput, `Posted relay message to #${CHANNEL}.`);
+    console.log('[e2e] relay_post OK');
+
+    // 4. relay_send sends a DM to ourselves (real HTTP 201)
+    const sendOutput = await toolMap.get('relay_send')!.invoke({ to: AGENT_NAME, text: 'e2e self-DM' });
+    assert.equal(sendOutput, `Sent relay message to ${AGENT_NAME}.`);
+    console.log('[e2e] relay_send OK');
+
+    // 5. relay_inbox drains messages (real HTTP 200)
+    await sleep(500);
+    const inboxOutput = await toolMap.get('relay_inbox')!.invoke({});
+    assert.ok(typeof inboxOutput === 'string', 'inbox output should be a string');
+    console.log('[e2e] relay_inbox OK:', inboxOutput.slice(0, 120));
+
+    // 6. Test message routing into graph via simulateIncoming
+    await relay.simulateIncoming({ sender: 'test-peer', text: 'routed msg', messageId: 'msg-sim-1' });
+    assert.equal(graph.invokeCalls.length, 1, 'graph should receive 1 routed message');
+    const call = graph.invokeCalls[0];
+    assert.ok(Array.isArray(call.input.messages));
+    const routedMsg = (call.input.messages as any[])[0];
+    assert.equal(routedMsg.role, 'user');
+    assert.match(routedMsg.content, /test-peer/);
+    assert.match(routedMsg.content, /routed msg/);
+    console.log('[e2e] message routing into graph OK');
+
+    // 7. unsubscribe stops routing
+    result.unsubscribe();
+    await relay.simulateIncoming({ sender: 'test-peer', text: 'should not route', messageId: 'msg-sim-2' });
+    assert.equal(graph.invokeCalls.length, 1, 'graph should NOT receive messages after unsubscribe');
+    console.log('[e2e] unsubscribe OK');
+
+    console.log('[e2e] All LangGraph e2e checks passed.');
+  } finally {
+    await relay.disconnect();
+    console.log('[e2e] Agent disconnected.');
+  }
+});

package/packages/sdk/src/__tests__/communicate/adapters/e2e-openai-agents.test.ts

@@ -0,0 +1,137 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { randomUUID } from 'node:crypto';
+
+import { onRelay } from '../../../communicate/adapters/openai-agents.js';
+import type { Message, MessageCallback } from '../../../communicate/types.js';
+
+const API_KEY = process.env.RELAY_API_KEY!;
+const BASE_URL = process.env.RELAY_BASE_URL!;
+const AGENT_NAME = `e2e-oai-${randomUUID().slice(0, 8)}`;
+
+/**
+ * Lightweight relay implementation that speaks the real Relaycast API surface
+ * (the SDK transport endpoints are currently misaligned).
+ */
+class LiveRelay {
+  private agentToken?: string;
+  private agentId?: string;
+  private callbacks = new Set<MessageCallback>();
+  private pending: Message[] = [];
+
+  constructor(private name: string) {}
+
+  async register(): Promise<void> {
+    const res = await fetch(`${BASE_URL}/v1/agents`, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: this.name, type: 'agent' }),
+    });
+    const body = await res.json() as any;
+    if (!body.ok) throw new Error(`register failed: ${JSON.stringify(body)}`);
+    this.agentId = body.data.id;
+    this.agentToken = body.data.token;
+  }
+
+  async send(to: string, text: string): Promise<void> {
+    const res = await fetch(`${BASE_URL}/v1/dm`, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${this.agentToken}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ to, text }),
+    });
+    const body = await res.json() as any;
+    if (!body.ok) throw new Error(`send failed: ${JSON.stringify(body)}`);
+  }
+
+  async post(channel: string, text: string): Promise<void> {
+    const res = await fetch(`${BASE_URL}/v1/channels/${encodeURIComponent(channel)}/messages`, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${this.agentToken}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ text }),
+    });
+    const body = await res.json() as any;
+    if (!body.ok) throw new Error(`post failed: ${JSON.stringify(body)}`);
+  }
+
+  async inbox(): Promise<Message[]> {
+    const msgs = [...this.pending];
+    this.pending = [];
+    return msgs;
+  }
+
+  async agents(): Promise<string[]> {
+    const res = await fetch(`${BASE_URL}/v1/agents`, {
+      headers: { Authorization: `Bearer ${API_KEY}` },
+    });
+    const body = await res.json() as any;
+    if (!body.ok) throw new Error(`agents failed: ${JSON.stringify(body)}`);
+    return (body.data as any[]).map((a) => a.name);
+  }
+
+  onMessage(callback: MessageCallback): () => void {
+    this.callbacks.add(callback);
+    return () => { this.callbacks.delete(callback); };
+  }
+
+  async cleanup(): Promise<void> {
+    if (!this.name) return;
+    await fetch(`${BASE_URL}/v1/agents/${encodeURIComponent(this.name)}`, {
+      method: 'PATCH',
+      headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ status: 'offline' }),
+    }).catch(() => {});
+  }
+}
+
+function createAgent(name: string) {
+  return {
+    name,
+    instructions: 'You are an e2e test agent.',
+    tools: [] as any[],
+  };
+}
+
+test('OpenAI Agents adapter e2e against live Relaycast', async (t) => {
+  const relay = new LiveRelay(AGENT_NAME);
+  await relay.register();
+
+  const agent = createAgent(AGENT_NAME);
+  const { agent: augmented, cleanup } = onRelay(agent, relay);
+
+  await t.test('onRelay injects 4 relay tools', () => {
+    const names = augmented.tools.map((tool: any) => tool.name);
+    assert.deepEqual(names, ['relay_send', 'relay_inbox', 'relay_post', 'relay_agents']);
+  });
+
+  await t.test('relay_agents returns live agent list including ours', async () => {
+    const tool = augmented.tools.find((t: any) => t.name === 'relay_agents')!;
+    const result: string = await tool.invoke(null, '{}');
+    assert.ok(result.includes(AGENT_NAME), `Expected agent list to contain "${AGENT_NAME}", got: ${result.slice(0, 200)}`);
+  });
+
+  await t.test('relay_send delivers a DM without error', async () => {
+    const tool = augmented.tools.find((t: any) => t.name === 'relay_send')!;
+    const result: string = await tool.invoke(null, JSON.stringify({ to: AGENT_NAME, text: 'e2e self-ping' }));
+    assert.match(result, /Sent relay message to/);
+  });
+
+  await t.test('relay_post posts to channel without error', async () => {
+    const tool = augmented.tools.find((t: any) => t.name === 'relay_post')!;
+    const result: string = await tool.invoke(null, JSON.stringify({ channel: 'general', text: `e2e from ${AGENT_NAME}` }));
+    assert.match(result, /Posted relay message to #general/);
+  });
+
+  await t.test('relay_inbox returns string result', async () => {
+    const tool = augmented.tools.find((t: any) => t.name === 'relay_inbox')!;
+    const result: string = await tool.invoke(null, '{}');
+    assert.ok(typeof result === 'string');
+  });
+
+  await t.test('cleanup restores agent and removes tools', () => {
+    cleanup();
+    assert.equal(augmented.tools.length, 0);
+    assert.equal(augmented.instructions, 'You are an e2e test agent.');
+  });
+
+  await relay.cleanup();
+});