agent-relay 3.2.15 → 3.2.16

package/packages/sdk/src/__tests__/communicate/transport.test.ts

@@ -41,9 +41,6 @@ class MockServer {
   private nextAgentId = 1;
   private nextMessageId = 1;
 
-  /** Track agent tokens from registration: token -> agentId */
-  private tokenToAgentId = new Map<string, string>();
-
   /** Override to customize HTTP responses */
   responseOverride?: (method: string, path: string, json?: any) => { status: number; body: unknown } | undefined;
 
@@ -52,12 +49,7 @@ class MockServer {
   constructor() {
     this.server.on('upgrade', (req, socket, head) => {
       const url = new URL(req.url ?? '/', 'http://127.0.0.1');
-      if (url.pathname !== '/v1/ws') {
-        socket.destroy();
-        return;
-      }
-      const token = url.searchParams.get('token');
-      if (!token || !this.tokenToAgentId.has(token)) {
+      if (!url.pathname.startsWith('/v1/ws/')) {
         socket.destroy();
         return;
       }
@@ -115,15 +107,6 @@ class MockServer {
     });
   }
 
-  private resolveAgentFromToken(request: IncomingMessage): string | undefined {
-    const auth = request.headers.authorization ?? '';
-    if (auth.startsWith('Bearer ')) {
-      const token = auth.slice(7);
-      return this.tokenToAgentId.get(token);
-    }
-    return undefined;
-  }
-
   private async handleRequest(request: IncomingMessage, response: ServerResponse): Promise<void> {
     const url = new URL(request.url ?? '/', this.baseUrl || 'http://127.0.0.1');
     const method = request.method ?? 'GET';
@@ -140,86 +123,68 @@ class MockServer {
       }
     }
 
-    // POST /v1/agents — register (workspace key auth)
-    if (method === 'POST' && path === '/v1/agents') {
+    if (method === 'POST' && path === '/v1/agents/register') {
       if (request.headers.authorization !== `Bearer ${this.apiKey}`) {
         sendJson(response, 401, { message: 'Unauthorized' });
         return;
       }
       const agentId = `agent-${this.nextAgentId++}`;
-      const token = `token-${agentId}`;
-      this.tokenToAgentId.set(token, agentId);
-      sendJson(response, 200, { ok: true, data: { id: agentId, name: json?.name, token, status: 'online' } });
+      sendJson(response, 200, { agent_id: agentId, token: `token-${agentId}` });
       return;
     }
 
-    // POST /v1/agents/disconnect — unregister (agent token auth)
-    if (method === 'POST' && path === '/v1/agents/disconnect') {
-      const agentId = this.resolveAgentFromToken(request);
-      if (!agentId) {
+    if (method === 'DELETE' && path.startsWith('/v1/agents/')) {
+      if (request.headers.authorization !== `Bearer ${this.apiKey}`) {
         sendJson(response, 401, { message: 'Unauthorized' });
         return;
       }
-      // Remove token mapping
-      const auth = request.headers.authorization ?? '';
-      const token = auth.startsWith('Bearer ') ? auth.slice(7) : '';
-      this.tokenToAgentId.delete(token);
-      sendJson(response, 200, { ok: true });
+      response.statusCode = 204;
+      response.end();
       return;
     }
 
-    // POST /v1/dm — send DM (agent token auth)
-    if (method === 'POST' && path === '/v1/dm') {
-      if (!this.resolveAgentFromToken(request)) {
+    if (method === 'POST' && path === '/v1/messages/dm') {
+      if (request.headers.authorization !== `Bearer ${this.apiKey}`) {
         sendJson(response, 401, { message: 'Unauthorized' });
         return;
       }
-      const msgId = `msg-${this.nextMessageId++}`;
-      sendJson(response, 201, { ok: true, data: { id: msgId, text: json?.text } });
+      sendJson(response, 200, { message_id: `msg-${this.nextMessageId++}` });
       return;
     }
 
-    // POST /v1/channels/{channel}/messages — channel post (agent token auth)
-    const channelMatch = path.match(/^\/v1\/channels\/([^/]+)\/messages$/);
-    if (method === 'POST' && channelMatch) {
-      if (!this.resolveAgentFromToken(request)) {
+    if (method === 'POST' && path === '/v1/messages/channel') {
+      if (request.headers.authorization !== `Bearer ${this.apiKey}`) {
         sendJson(response, 401, { message: 'Unauthorized' });
         return;
       }
-      const msgId = `msg-${this.nextMessageId++}`;
-      sendJson(response, 201, { ok: true, data: { id: msgId, channel_name: channelMatch[1], text: json?.text } });
+      sendJson(response, 200, { message_id: `msg-${this.nextMessageId++}` });
       return;
     }
 
-    // POST /v1/messages/{id}/replies — reply (agent token auth)
-    const replyMatch = path.match(/^\/v1\/messages\/([^/]+)\/replies$/);
-    if (method === 'POST' && replyMatch) {
-      if (!this.resolveAgentFromToken(request)) {
+    if (method === 'POST' && path === '/v1/messages/reply') {
+      if (request.headers.authorization !== `Bearer ${this.apiKey}`) {
         sendJson(response, 401, { message: 'Unauthorized' });
         return;
       }
-      const msgId = `msg-${this.nextMessageId++}`;
-      sendJson(response, 201, { ok: true, data: { id: msgId, text: json?.text } });
+      sendJson(response, 200, { message_id: `msg-${this.nextMessageId++}` });
       return;
     }
 
-    // GET /v1/inbox — inbox (agent token auth)
-    if (method === 'GET' && path === '/v1/inbox') {
-      if (!this.resolveAgentFromToken(request)) {
+    if (method === 'GET' && path.startsWith('/v1/inbox/')) {
+      if (request.headers.authorization !== `Bearer ${this.apiKey}`) {
         sendJson(response, 401, { message: 'Unauthorized' });
         return;
       }
-      sendJson(response, 200, { ok: true, data: { unread_channels: [], mentions: [], unread_dms: [], recent_reactions: [] } });
+      sendJson(response, 200, { messages: [] });
       return;
     }
 
-    // GET /v1/agents — list agents (workspace key auth)
     if (method === 'GET' && path === '/v1/agents') {
       if (request.headers.authorization !== `Bearer ${this.apiKey}`) {
         sendJson(response, 401, { message: 'Unauthorized' });
         return;
       }
-      sendJson(response, 200, { ok: true, data: [{ name: 'TestAgent', id: 'extra-TestAgent', status: 'online' }] });
+      sendJson(response, 200, { agents: ['TestAgent'] });
       return;
     }
 
@@ -239,7 +204,7 @@ async function withServer(run: (server: MockServer) => Promise<void>): Promise<v
 
 // --- HTTP method tests ---
 
-test('registerAgent sends POST /v1/agents with auth header', async () => {
+test('registerAgent sends POST /v1/agents/register with auth header', async () => {
   await withServer(async (server) => {
     const { RelayTransport } = await loadModules();
     const transport = new RelayTransport('TestAgent', server.makeConfig());
@@ -248,14 +213,13 @@ test('registerAgent sends POST /v1/agents with auth header', async () => {
 
     assert.ok(agentId.startsWith('agent-'));
     assert.ok(transport.token);
-    const reqs = server.requestsFor('/v1/agents').filter((r) => r.method === 'POST');
-    assert.ok(reqs.length > 0);
-    assert.equal(reqs[0].auth, `Bearer ${server.apiKey}`);
-    assert.deepEqual(reqs[0].json, { name: 'TestAgent', type: 'agent' });
+    const req = server.requestsFor('/v1/agents/register')[0];
+    assert.equal(req.auth, `Bearer ${server.apiKey}`);
+    assert.deepEqual(req.json, { name: 'TestAgent', workspace: server.workspace });
   });
 });
 
-test('unregisterAgent sends POST /v1/agents/disconnect', async () => {
+test('unregisterAgent sends DELETE /v1/agents/{id}', async () => {
   await withServer(async (server) => {
     const { RelayTransport } = await loadModules();
     const transport = new RelayTransport('TestAgent', server.makeConfig());
@@ -263,14 +227,14 @@ test('unregisterAgent sends POST /v1/agents/disconnect', async () => {
     await transport.registerAgent();
     await transport.unregisterAgent();
 
-    const disconnectReqs = server.requestsFor('/v1/agents/disconnect');
-    assert.ok(disconnectReqs.some((r) => r.method === 'POST'));
+    const deleteReqs = server.requestsFor('/v1/agents/agent-');
+    assert.ok(deleteReqs.some((r) => r.method === 'DELETE'));
     assert.equal(transport.agentId, undefined);
     assert.equal(transport.token, undefined);
   });
 });
 
-test('sendDm sends POST /v1/dm with correct payload', async () => {
+test('sendDm sends POST /v1/messages/dm with correct payload', async () => {
   await withServer(async (server) => {
     const { RelayTransport } = await loadModules();
     const transport = new RelayTransport('Sender', server.makeConfig());
@@ -278,14 +242,13 @@ test('sendDm sends POST /v1/dm with correct payload', async () => {
     const messageId = await transport.sendDm('Recipient', 'hello');
 
     assert.ok(messageId.startsWith('msg-'));
-    const req = server.requestsFor('/v1/dm')[0];
-    assert.deepEqual(req.json, { to: 'Recipient', text: 'hello' });
-    // Agent-authenticated endpoint uses the per-agent token, not workspace key
-    assert.ok(req.auth?.startsWith('Bearer token-agent-'));
+    const req = server.requestsFor('/v1/messages/dm')[0];
+    assert.deepEqual(req.json, { to: 'Recipient', text: 'hello', from: 'Sender' });
+    assert.equal(req.auth, `Bearer ${server.apiKey}`);
   });
 });
 
-test('postMessage sends POST /v1/channels/{channel}/messages', async () => {
+test('postMessage sends POST /v1/messages/channel', async () => {
   await withServer(async (server) => {
     const { RelayTransport } = await loadModules();
     const transport = new RelayTransport('Poster', server.makeConfig());
@@ -293,13 +256,12 @@ test('postMessage sends POST /v1/channels/{channel}/messages', async () => {
     const messageId = await transport.postMessage('general', 'update');
 
     assert.ok(messageId.startsWith('msg-'));
-    const req = server.requestsFor('/v1/channels/general/messages')[0];
-    assert.deepEqual(req.json, { text: 'update' });
-    assert.ok(req.auth?.startsWith('Bearer token-agent-'));
+    const req = server.requestsFor('/v1/messages/channel')[0];
+    assert.deepEqual(req.json, { channel: 'general', text: 'update', from: 'Poster' });
   });
 });
 
-test('reply sends POST /v1/messages/{id}/replies', async () => {
+test('reply sends POST /v1/messages/reply', async () => {
   await withServer(async (server) => {
     const { RelayTransport } = await loadModules();
     const transport = new RelayTransport('Replier', server.makeConfig());
@@ -307,9 +269,8 @@ test('reply sends POST /v1/messages/{id}/replies', async () => {
     const messageId = await transport.reply('msg-42', 'response');
 
     assert.ok(messageId.startsWith('msg-'));
-    const req = server.requestsFor('/v1/messages/msg-42/replies')[0];
-    assert.deepEqual(req.json, { text: 'response' });
-    assert.ok(req.auth?.startsWith('Bearer token-agent-'));
+    const req = server.requestsFor('/v1/messages/reply')[0];
+    assert.deepEqual(req.json, { message_id: 'msg-42', text: 'response', from: 'Replier' });
   });
 });
 
@@ -326,7 +287,7 @@ test('listAgents sends GET /v1/agents', async () => {
   });
 });
 
-test('checkInbox sends GET /v1/inbox', async () => {
+test('checkInbox sends GET /v1/inbox/{agentId}', async () => {
   await withServer(async (server) => {
     const { RelayTransport } = await loadModules();
     const transport = new RelayTransport('Checker', server.makeConfig());
@@ -334,7 +295,7 @@ test('checkInbox sends GET /v1/inbox', async () => {
     const messages = await transport.checkInbox();
 
     assert.deepEqual(messages, []);
-    assert.ok(server.requestsFor('/v1/inbox').length > 0);
+    assert.ok(server.requestsFor('/v1/inbox/').length > 0);
   });
 });
 
@@ -526,7 +487,7 @@ test('disconnect closes WebSocket and unregisters agent', async () => {
 
     await transport.disconnect();
 
-    assert.ok(server.requestsFor('/v1/agents/disconnect').some((r) => r.method === 'POST'));
+    assert.ok(server.requestsFor('/v1/agents/agent-').some((r) => r.method === 'DELETE'));
   });
 });
 
@@ -570,7 +531,7 @@ test('all HTTP methods include Authorization header', async () => {
     await transport.unregisterAgent();
 
     for (const req of server.requests) {
-      assert.ok(req.auth?.startsWith('Bearer '), `Missing auth on ${req.method} ${req.path}`);
+      assert.equal(req.auth, `Bearer ${server.apiKey}`, `Missing auth on ${req.method} ${req.path}`);
     }
   });
 });

package/packages/sdk/src/__tests__/orchestration-upgrades.test.ts

@@ -180,6 +180,29 @@ describe('AgentRelayClient orchestration payloads', () => {
     );
   });
 
+  it('sendMessage forwards mode for injection behavior', async () => {
+    const client = new AgentRelayClient();
+    vi.spyOn(client, 'start').mockResolvedValue(undefined);
+    const requestOk = vi
+      .spyOn(client as any, 'requestOk')
+      .mockResolvedValue({ event_id: 'evt_mode', targets: ['worker'] });
+
+    await client.sendMessage({
+      to: 'worker',
+      text: 'urgent update',
+      mode: 'steer',
+    });
+
+    expect(requestOk).toHaveBeenCalledWith(
+      'send_message',
+      expect.objectContaining({
+        to: 'worker',
+        text: 'urgent update',
+        mode: 'steer',
+      })
+    );
+  });
+
   it('release forwards optional reason', async () => {
     const client = new AgentRelayClient();
     vi.spyOn(client, 'start').mockResolvedValue(undefined);
@@ -1107,4 +1130,101 @@ describe('Agent.onOutput', () => {
       await relay.shutdown();
     }
   });
+
+  it('onOutput with { stream: "stdout" } only receives stdout events', async () => {
+    const { client, emit } = createMockFacadeClient();
+    vi.spyOn(AgentRelayClient, 'start').mockResolvedValue(client);
+
+    const relay = new AgentRelay();
+    try {
+      const agent = await relay.spawnPty({
+        name: 'stream-filter-agent',
+        cli: 'claude',
+        channels: ['general'],
+      });
+
+      const chunks: string[] = [];
+      agent.onOutput((chunk: string) => chunks.push(chunk), { stream: 'stdout' });
+
+      emit({ kind: 'worker_stream', name: 'stream-filter-agent', stream: 'stdout', chunk: 'out1' });
+      emit({ kind: 'worker_stream', name: 'stream-filter-agent', stream: 'stderr', chunk: 'err1' });
+      emit({ kind: 'worker_stream', name: 'stream-filter-agent', stream: 'stdout', chunk: 'out2' });
+
+      expect(chunks).toEqual(['out1', 'out2']);
+    } finally {
+      await relay.shutdown();
+    }
+  });
+
+  it('onOutput without filter receives all streams', async () => {
+    const { client, emit } = createMockFacadeClient();
+    vi.spyOn(AgentRelayClient, 'start').mockResolvedValue(client);
+
+    const relay = new AgentRelay();
+    try {
+      const agent = await relay.spawnPty({
+        name: 'all-streams-agent',
+        cli: 'claude',
+        channels: ['general'],
+      });
+
+      const chunks: string[] = [];
+      agent.onOutput((chunk: string) => chunks.push(chunk));
+
+      emit({ kind: 'worker_stream', name: 'all-streams-agent', stream: 'stdout', chunk: 'out' });
+      emit({ kind: 'worker_stream', name: 'all-streams-agent', stream: 'stderr', chunk: 'err' });
+
+      expect(chunks).toEqual(['out', 'err']);
+    } finally {
+      await relay.shutdown();
+    }
+  });
+
+  it('onOutput with { stream: "stderr" } ignores stdout events', async () => {
+    const { client, emit } = createMockFacadeClient();
+    vi.spyOn(AgentRelayClient, 'start').mockResolvedValue(client);
+
+    const relay = new AgentRelay();
+    try {
+      const agent = await relay.spawnPty({
+        name: 'stderr-filter-agent',
+        cli: 'claude',
+        channels: ['general'],
+      });
+
+      const chunks: string[] = [];
+      agent.onOutput((chunk: string) => chunks.push(chunk), { stream: 'stderr' });
+
+      emit({ kind: 'worker_stream', name: 'stderr-filter-agent', stream: 'stdout', chunk: 'ignored' });
+      emit({ kind: 'worker_stream', name: 'stderr-filter-agent', stream: 'stderr', chunk: 'captured' });
+
+      expect(chunks).toEqual(['captured']);
+    } finally {
+      await relay.shutdown();
+    }
+  });
+
+  it('onOutput with explicit mode: "structured" receives { stream, chunk } objects', async () => {
+    const { client, emit } = createMockFacadeClient();
+    vi.spyOn(AgentRelayClient, 'start').mockResolvedValue(client);
+
+    const relay = new AgentRelay();
+    try {
+      const agent = await relay.spawnPty({
+        name: 'explicit-mode-agent',
+        cli: 'claude',
+        channels: ['general'],
+      });
+
+      const payloads: Array<{ stream: string; chunk: string }> = [];
+      // Use a plain (chunk) => ... signature but force structured mode via options
+      agent.onOutput(((data: { stream: string; chunk: string }) => payloads.push(data)) as any, { mode: 'structured' });
+
+      emit({ kind: 'worker_stream', name: 'explicit-mode-agent', stream: 'stdout', chunk: 'hello' });
+
+      expect(payloads).toEqual([{ stream: 'stdout', chunk: 'hello' }]);
+    } finally {
+      await relay.shutdown();
+    }
+  });
 });

package/packages/sdk/src/__tests__/relay-channel-ops.test.ts

@@ -0,0 +1,121 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import type { BrokerEvent } from '../protocol.js';
+import { AgentRelay } from '../relay.js';
+
+function createMockFacadeClient() {
+  const listeners = new Set<(event: BrokerEvent) => void>();
+
+  const mock = {
+    subscribeChannels: vi.fn(async () => undefined),
+    unsubscribeChannels: vi.fn(async () => undefined),
+    muteChannel: vi.fn(async () => undefined),
+    unmuteChannel: vi.fn(async () => undefined),
+    onEvent: vi.fn((listener: (event: BrokerEvent) => void) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }),
+  };
+
+  const emit = (event: BrokerEvent) => {
+    for (const listener of Array.from(listeners)) {
+      listener(event);
+    }
+  };
+
+  return {
+    client: mock,
+    emit,
+  };
+}
+
+function setupRelay() {
+  const relay = new AgentRelay();
+  const mockClient = createMockFacadeClient();
+  (relay as any).client = mockClient.client;
+  (relay as any).wireEvents(mockClient.client);
+  return { relay, ...mockClient };
+}
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe('AgentRelay channel operations', () => {
+  it('relay.subscribe delegates to client', async () => {
+    const { relay, client } = setupRelay();
+
+    await relay.subscribe({ agent: 'worker-1', channels: ['ch-a', 'ch-b'] });
+
+    expect(client.subscribeChannels).toHaveBeenCalledWith('worker-1', ['ch-a', 'ch-b']);
+  });
+
+  it('relay.mute delegates to client', async () => {
+    const { relay, client } = setupRelay();
+
+    await relay.mute({ agent: 'worker-1', channel: 'ch-a' });
+
+    expect(client.muteChannel).toHaveBeenCalledWith('worker-1', 'ch-a');
+  });
+
+  it('Agent.subscribe updates the local channel list on success', async () => {
+    const { relay, client } = setupRelay();
+    const agent = (relay as any).ensureAgentHandle('worker-1', 'pty', ['ch-a']);
+
+    await agent.subscribe(['ch-b']);
+
+    expect(client.subscribeChannels).toHaveBeenCalledWith('worker-1', ['ch-b']);
+    expect(agent.channels).toEqual(['ch-a', 'ch-b']);
+  });
+
+  it('Agent.mute adds the channel to mutedChannels', async () => {
+    const { relay, client } = setupRelay();
+    const agent = (relay as any).ensureAgentHandle('worker-1', 'pty', ['ch-a']);
+
+    await agent.mute('ch-a');
+
+    expect(client.muteChannel).toHaveBeenCalledWith('worker-1', 'ch-a');
+    expect(agent.mutedChannels).toEqual(['ch-a']);
+  });
+
+  it('Agent.unmute removes the channel from mutedChannels', async () => {
+    const { relay, client } = setupRelay();
+    const agent = (relay as any).ensureAgentHandle('worker-1', 'pty', ['ch-a']);
+
+    await agent.mute('ch-a');
+    await agent.unmute('ch-a');
+
+    expect(client.unmuteChannel).toHaveBeenCalledWith('worker-1', 'ch-a');
+    expect(agent.mutedChannels).toEqual([]);
+  });
+
+  it('onChannelSubscribed fires on channel_subscribed events', () => {
+    const { relay, emit } = setupRelay();
+    const callback = vi.fn();
+    relay.onChannelSubscribed = callback;
+
+    emit({
+      kind: 'channel_subscribed',
+      name: 'worker-1',
+      channels: ['ch-a'],
+    });
+
+    expect(callback).toHaveBeenCalledWith('worker-1', ['ch-a']);
+  });
+
+  it('onChannelMuted fires on channel_muted events', () => {
+    const { relay, emit } = setupRelay();
+    const callback = vi.fn();
+    relay.onChannelMuted = callback;
+
+    emit({
+      kind: 'channel_muted',
+      name: 'worker-1',
+      channel: 'ch-a',
+    });
+
+    expect(callback).toHaveBeenCalledWith('worker-1', 'ch-a');
+  });
+});

package/packages/sdk/src/broker-path.ts

@@ -0,0 +1,74 @@
+/**
+ * Resolves the agent-relay-broker binary path at runtime.
+ *
+ * Usage:
+ *   import { getBrokerBinaryPath } from '@agent-relay/sdk/broker-path';
+ *   const binPath = getBrokerBinaryPath();
+ */
+
+import { existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { execSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const BROKER_NAME = 'agent-relay-broker';
+
+/**
+ * Resolve the agent-relay-broker binary path.
+ *
+ * Search order:
+ *   1. SDK's bin/ directory (resolved via createRequire or import.meta.url)
+ *   2. Platform-specific name (agent-relay-broker-{platform}-{arch}) in bin/
+ *   3. PATH lookup via `which` / `where`
+ *
+ * @returns Absolute path to the broker binary, or null if not found
+ */
+export function getBrokerBinaryPath(): string | null {
+  let binDir: string | null = null;
+  try {
+    // Use createRequire for ESM-compatible require.resolve
+    const esmRequire = createRequire(import.meta.url);
+    const sdkEntry = esmRequire.resolve('@agent-relay/sdk');
+    binDir = join(dirname(sdkEntry), '..', 'bin');
+  } catch {
+    try {
+      // Fallback: derive from import.meta.url
+      binDir = join(dirname(dirname(fileURLToPath(import.meta.url))), 'bin');
+    } catch {
+      // Neither method worked
+    }
+  }
+  if (!binDir) return null;
+
+  const ext = process.platform === 'win32' ? '.exe' : '';
+
+  // 1. Exact name in bin/
+  const exactPath = join(binDir, `${BROKER_NAME}${ext}`);
+  if (existsSync(exactPath)) {
+    return exactPath;
+  }
+
+  // 2. Platform-specific name in bin/
+  const platformSpecific = `${BROKER_NAME}-${process.platform}-${process.arch}${ext}`;
+  const platformPath = join(binDir, platformSpecific);
+  if (existsSync(platformPath)) {
+    return platformPath;
+  }
+
+  // 3. PATH lookup
+  try {
+    const cmd = process.platform === 'win32' ? 'where' : 'which';
+    const result = execSync(`${cmd} ${BROKER_NAME}`, {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    if (result) {
+      return result.split('\n')[0].trim();
+    }
+  } catch {
+    // Not found on PATH
+  }
+
+  return null;
+}

package/packages/sdk/src/cli-registry.ts

@@ -137,6 +137,10 @@ const CLI_REGISTRY: Record<AgentCli, CliDefinition> = {
       ...extra,
     ],
   },
+  api: {
+    binaries: [],
+    nonInteractiveArgs: (task) => [task],
+  },
 };
 
 /**

package/packages/sdk/src/client.ts

@@ -20,6 +20,7 @@ import {
   type ProtocolEnvelope,
   type ProtocolError,
   type RestartPolicy,
+  type MessageInjectionMode,
 } from './protocol.js';
 
 export interface AgentRelayClientOptions {
@@ -99,6 +100,7 @@ export interface SendMessageInput {
   workspaceAlias?: string;
   priority?: number;
   data?: Record<string, unknown>;
+  mode?: MessageInjectionMode;
 }
 
 export interface ListAgent {
@@ -369,6 +371,16 @@ export class AgentRelayClient {
     return this.requestOk<{ name: string; bytes_written: number }>('send_input', { name, data });
   }
 
+  async subscribeChannels(name: string, channels: string[]): Promise<void> {
+    await this.start();
+    await this.requestOk<void>('subscribe_channels', { name, channels });
+  }
+
+  async unsubscribeChannels(name: string, channels: string[]): Promise<void> {
+    await this.start();
+    await this.requestOk<void>('unsubscribe_channels', { name, channels });
+  }
+
   async resizePty(
     name: string,
     rows: number,
@@ -423,6 +435,7 @@ export class AgentRelayClient {
         workspace_alias: input.workspaceAlias,
         priority: input.priority,
         data: input.data,
+        mode: input.mode,
       });
     } catch (error) {
       if (error instanceof AgentRelayProtocolError && error.code === 'unsupported_operation') {
@@ -1154,6 +1167,7 @@ export class HttpAgentRelayClient {
         workspaceAlias: input.workspaceAlias,
         priority: input.priority,
         data: input.data,
+        mode: input.mode,
       }),
     });
   }
@@ -1176,6 +1190,20 @@ export class HttpAgentRelayClient {
     return { name: typeof payload?.name === 'string' ? payload.name : name };
   }
 
+  async subscribeChannels(_name: string, _channels: string[]): Promise<void> {
+    throw new Error(
+      'subscribeChannels is only available via the broker protocol (BrokerAgentRelayClient). ' +
+      'The HTTP API does not support dynamic channel subscription.'
+    );
+  }
+
+  async unsubscribeChannels(_name: string, _channels: string[]): Promise<void> {
+    throw new Error(
+      'unsubscribeChannels is only available via the broker protocol (BrokerAgentRelayClient). ' +
+      'The HTTP API does not support dynamic channel unsubscription.'
+    );
+  }
+
   async setModel(
     name: string,
     model: string,