agent-relay 2.1.13 → 2.1.14

package/packages/mcp/dist/tools/relay-spawn.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import type { RelayClient } from '../client.js';
+import type { RelayClient } from '../client-adapter.js';
 /**
  * Supported CLI tools for spawning workers.
  * This list should be kept in sync with CliType in packages/wrapper/src/shared.ts
@@ -18,14 +18,14 @@ export declare const relaySpawnSchema: z.ZodObject<{
     name: string;
     cli: "claude" | "gemini" | "opencode" | "droid" | "codex";
     task: string;
-    cwd?: string | undefined;
     model?: string | undefined;
+    cwd?: string | undefined;
 }, {
     name: string;
     cli: "claude" | "gemini" | "opencode" | "droid" | "codex";
     task: string;
-    cwd?: string | undefined;
     model?: string | undefined;
+    cwd?: string | undefined;
 }>;
 export type RelaySpawnInput = z.infer<typeof relaySpawnSchema>;
 export declare const relaySpawnTool: Tool;

package/packages/mcp/dist/tools/relay-spawn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relay-spawn.d.ts","sourceRoot":"","sources":["../../src/tools/relay-spawn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,cAAc,6DAA8D,CAAC;AAC1F,MAAM,MAAM,YAAY,GAAG,OAAO,cAAc,CAAC,MAAM,CAAC,CAAC;AAEzD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;EAQ3B,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE/D,eAAO,MAAM,cAAc,EAAE,IAsC5B,CAAC;AAEF;;GAEG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE,eAAe,GACrB,OAAO,CAAC,MAAM,CAAC,CAgBjB"}
+{"version":3,"file":"relay-spawn.d.ts","sourceRoot":"","sources":["../../src/tools/relay-spawn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,cAAc,6DAA8D,CAAC;AAC1F,MAAM,MAAM,YAAY,GAAG,OAAO,cAAc,CAAC,MAAM,CAAC,CAAC;AAEzD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;EAQ3B,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE/D,eAAO,MAAM,cAAc,EAAE,IAsC5B,CAAC;AAEF;;GAEG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE,eAAe,GACrB,OAAO,CAAC,MAAM,CAAC,CAgBjB"}

package/packages/mcp/dist/tools/relay-status.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import type { RelayClient } from '../client.js';
+import type { RelayClient } from '../client-adapter.js';
 export declare const relayStatusSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
 export type RelayStatusInput = z.infer<typeof relayStatusSchema>;
 export declare const relayStatusTool: Tool;

package/packages/mcp/dist/tools/relay-status.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relay-status.d.ts","sourceRoot":"","sources":["../../src/tools/relay-status.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD,eAAO,MAAM,iBAAiB,gDAAe,CAAC;AAE9C,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAEjE,eAAO,MAAM,eAAe,EAAE,IAQ7B,CAAC;AAEF;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,gBAAgB,GACvB,OAAO,CAAC,MAAM,CAAC,CAgCjB"}
+{"version":3,"file":"relay-status.d.ts","sourceRoot":"","sources":["../../src/tools/relay-status.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,eAAO,MAAM,iBAAiB,gDAAe,CAAC;AAE9C,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAEjE,eAAO,MAAM,eAAe,EAAE,IAQ7B,CAAC;AAEF;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,gBAAgB,GACvB,OAAO,CAAC,MAAM,CAAC,CAgCjB"}

package/packages/mcp/dist/tools/relay-subscribe.d.ts

@@ -3,7 +3,7 @@
  */
 import { z } from 'zod';
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import type { RelayClient } from '../client.js';
+import type { RelayClient } from '../client-adapter.js';
 export declare const relaySubscribeSchema: z.ZodObject<{
     topic: z.ZodString;
 }, "strip", z.ZodTypeAny, {

package/packages/mcp/dist/tools/relay-subscribe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relay-subscribe.d.ts","sourceRoot":"","sources":["../../src/tools/relay-subscribe.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,eAAO,MAAM,oBAAoB;;;;;;EAE/B,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEvE,eAAO,MAAM,kBAAkB,EAAE,IAUhC,CAAC;AAEF,wBAAsB,oBAAoB,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC,CAM3G;AAGD,eAAO,MAAM,sBAAsB;;;;;;EAEjC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE3E,eAAO,MAAM,oBAAoB,EAAE,IAUlC,CAAC;AAEF,wBAAsB,sBAAsB,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,qBAAqB,GAAG,OAAO,CAAC,MAAM,CAAC,CAM/G"}
+{"version":3,"file":"relay-subscribe.d.ts","sourceRoot":"","sources":["../../src/tools/relay-subscribe.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAGxD,eAAO,MAAM,oBAAoB;;;;;;EAE/B,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEvE,eAAO,MAAM,kBAAkB,EAAE,IAUhC,CAAC;AAEF,wBAAsB,oBAAoB,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC,CAM3G;AAGD,eAAO,MAAM,sBAAsB;;;;;;EAEjC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE3E,eAAO,MAAM,oBAAoB,EAAE,IAUlC,CAAC;AAEF,wBAAsB,sBAAsB,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,qBAAqB,GAAG,OAAO,CAAC,MAAM,CAAC,CAM/G"}

package/packages/mcp/dist/tools/relay-who.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import type { RelayClient } from '../client.js';
+import type { RelayClient } from '../client-adapter.js';
 export declare const relayWhoSchema: z.ZodObject<{
     include_idle: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     project: z.ZodOptional<z.ZodString>;

package/packages/mcp/dist/tools/relay-who.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relay-who.d.ts","sourceRoot":"","sources":["../../src/tools/relay-who.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD,eAAO,MAAM,cAAc;;;;;;;;;EAGzB,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE3D,eAAO,MAAM,YAAY,EAAE,IAyB1B,CAAC;AAEF;;GAEG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE,aAAa,GACnB,OAAO,CAAC,MAAM,CAAC,CA8BjB"}
+{"version":3,"file":"relay-who.d.ts","sourceRoot":"","sources":["../../src/tools/relay-who.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,eAAO,MAAM,cAAc;;;;;;;;;EAGzB,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE3D,eAAO,MAAM,YAAY,EAAE,IAyB1B,CAAC;AAEF;;GAEG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE,aAAa,GACnB,OAAO,CAAC,MAAM,CAAC,CA8BjB"}

package/packages/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/mcp",
-  "version": "2.1.13",
+  "version": "2.1.14",
   "description": "MCP server for Agent Relay - native messaging tools for AI agents in Claude, Cursor, and VS Code",
   "author": "Agent Workforce Inc.",
   "license": "Apache-2.0",
@@ -47,18 +47,27 @@
     "prepublishOnly": "npm run clean && npm run build && npm test"
   },
   "dependencies": {
-    "@agent-relay/config": "2.1.13",
-    "@agent-relay/protocol": "2.1.13",
-    "@agent-relay/utils": "2.1.13",
+    "@agent-relay/config": "2.1.14",
+    "@agent-relay/protocol": "2.1.14",
+    "@agent-relay/utils": "2.1.14",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "smol-toml": "^1.6.0",
     "zod": "^3.23.8"
   },
   "devDependencies": {
+    "@agent-relay/sdk": "2.1.13",
     "@types/node": "^22.19.3",
     "typescript": "^5.9.3",
     "vitest": "^2.1.9"
   },
+  "peerDependencies": {
+    "@agent-relay/sdk": ">=2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@agent-relay/sdk": {
+      "optional": true
+    }
+  },
   "keywords": [
     "mcp",
     "agent-relay",

package/packages/mcp/src/bin.ts

@@ -11,6 +11,8 @@
 
 import { parseArgs } from 'node:util';
 import { runInstall, validateEditor, getValidEditors } from './install-cli.js';
+import { RelayClient } from '@agent-relay/sdk';
+import { createRelayClientAdapter } from './client-adapter.js';
 
 const { values, positionals } = parseArgs({
   allowPositionals: true,
@@ -114,7 +116,7 @@ switch (command) {
     (async () => {
       try {
         const { runMCPServer, discoverSocket, discoverAgentName } = await import('./index.js');
-        const { createHybridClient, discoverProjectRoot } = await import('./hybrid-client.js');
+        const { discoverProjectRoot } = await import('./hybrid-client.js');
         const { join } = await import('node:path');
         const { existsSync } = await import('node:fs');
 
@@ -138,7 +140,7 @@ switch (command) {
         const discovery = discoverSocket();
         const agentName = discoverAgentName(discovery) || `mcp-${process.pid}`;
 
-        // Discover project root for file-based transport
+        // Discover project root
         if (!projectRoot) {
           projectRoot = discoverProjectRoot() ?? undefined;
         }
@@ -157,15 +159,28 @@ switch (command) {
           process.exit(1);
         }
 
-        // Create hybrid client (file-based writes, socket queries)
-        const client = createHybridClient({
+        const client = new RelayClient({
           agentName,
-          projectRoot,
           socketPath: socketPath || discovery?.socketPath,
+          quiet: values.quiet,
+          reconnect: true,
+        });
+
+        await client.connect();
+
+        const mcpClient = createRelayClientAdapter(client, {
+          agentName,
           project: discovery?.project,
+          projectRoot,
+          socketPath: socketPath || discovery?.socketPath,
         });
 
-        await runMCPServer(client);
+        await runMCPServer(mcpClient, {
+          projectRoot,
+          project: discovery?.project,
+          socketPath: socketPath || discovery?.socketPath,
+          agentName,
+        });
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         console.error('Failed to start MCP server:', message);

package/packages/mcp/src/client-adapter.ts

@@ -0,0 +1,349 @@
+import { RelayClient as SdkRelayClient, type AckPayload, type AgentInfo, type HealthResponsePayload, type InboxMessage, type MetricsResponsePayload, type MessagesResponsePayload, type SpawnResult, type ReleaseResultPayload } from '@agent-relay/sdk';
+import { PROTOCOL_VERSION, type Envelope } from '@agent-relay/protocol';
+import { randomUUID } from 'node:crypto';
+
+export type QueryMessage = MessagesResponsePayload['messages'][number];
+export type HealthResponse = HealthResponsePayload;
+export type MetricsResponse = MetricsResponsePayload;
+export type MessagesResponse = MessagesResponsePayload;
+
+export interface RelayClient {
+  send(to: string, message: string, options?: { thread?: string; kind?: string; data?: Record<string, unknown> }): Promise<void>;
+  sendAndWait(
+    to: string,
+    message: string,
+    options?: { thread?: string; timeoutMs?: number; kind?: string; data?: Record<string, unknown> }
+  ): Promise<AckPayload>;
+  broadcast(message: string, options?: { kind?: string; data?: Record<string, unknown> }): Promise<void>;
+
+  spawn(options: { name: string; cli: string; task?: string; model?: string; cwd?: string }): Promise<SpawnResult>;
+  release(name: string, reason?: string): Promise<ReleaseResultPayload>;
+
+  subscribe(topic: string): Promise<{ success: boolean; error?: string }>;
+  unsubscribe(topic: string): Promise<{ success: boolean; error?: string }>;
+
+  joinChannel(channel: string, displayName?: string): Promise<{ success: boolean; error?: string }>;
+  leaveChannel(channel: string, reason?: string): Promise<{ success: boolean; error?: string }>;
+  sendChannelMessage(channel: string, message: string, options?: { thread?: string }): Promise<void>;
+  adminJoinChannel(channel: string, member: string): Promise<{ success: boolean; error?: string }>;
+  adminRemoveMember(channel: string, member: string): Promise<{ success: boolean; error?: string }>;
+
+  bindAsShadow(primaryAgent: string, options?: { speakOn?: string[] }): Promise<{ success: boolean; error?: string }>;
+  unbindAsShadow(primaryAgent: string): Promise<{ success: boolean; error?: string }>;
+
+  createProposal(options: {
+    id: string;
+    description: string;
+    options: string[];
+    votingMethod?: string;
+    deadline?: number;
+  }): Promise<{ success: boolean; error?: string }>;
+
+  vote(options: { proposalId: string; vote: string; reason?: string }): Promise<{ success: boolean; error?: string }>;
+
+  getStatus(): Promise<{
+    connected: boolean;
+    agentName: string;
+    project: string;
+    socketPath: string;
+    daemonVersion?: string;
+    uptime?: string;
+  }>;
+
+  getInbox(options?: { limit?: number; unread_only?: boolean; from?: string; channel?: string }): Promise<
+    Array<{
+      id: string;
+      from: string;
+      content: string;
+      channel?: string;
+      thread?: string;
+    }>
+  >;
+
+  listAgents(options?: { include_idle?: boolean; project?: string }): Promise<AgentInfo[]>;
+  listConnectedAgents(options?: { project?: string }): Promise<AgentInfo[]>;
+  removeAgent(name: string, options?: { removeMessages?: boolean }): Promise<{ success: boolean; removed: boolean; message?: string }>;
+  getHealth(options?: { include_crashes?: boolean; include_alerts?: boolean }): Promise<HealthResponsePayload>;
+  getMetrics(options?: { agent?: string }): Promise<MetricsResponsePayload>;
+
+  queryMessages(options?: {
+    limit?: number;
+    sinceTs?: number;
+    since_ts?: number;
+    from?: string;
+    to?: string;
+    thread?: string;
+    order?: 'asc' | 'desc';
+  }): Promise<QueryMessage[]>;
+
+  sendLog(data: string): Promise<void>;
+}
+
+export interface RelayClientAdapterOptions {
+  agentName: string;
+  project?: string;
+  projectRoot?: string;
+  socketPath?: string;
+}
+
+async function ensureReady(client: SdkRelayClient): Promise<void> {
+  if ((client as any).state !== 'READY') {
+    await client.connect();
+  }
+}
+
+function boolResult(ok: boolean, action: string): { success: boolean; error?: string } {
+  return ok ? { success: true } : { success: false, error: `Failed to ${action}` };
+}
+
+export function createRelayClientAdapter(client: SdkRelayClient, ctx: RelayClientAdapterOptions): RelayClient {
+  const project = ctx.projectRoot ?? ctx.project ?? 'default';
+  const socketPath = ctx.socketPath ?? '';
+
+  return {
+    async send(to, message, opts = {}) {
+      await ensureReady(client);
+      const ok = client.sendMessage(to, message, (opts.kind as any) ?? 'message', opts.data, opts.thread);
+      if (!ok) throw new Error('Failed to send message');
+    },
+
+    async sendAndWait(to, message, opts = {}) {
+      await ensureReady(client);
+      return client.sendAndWait(to, message, {
+        thread: opts.thread,
+        timeoutMs: opts.timeoutMs,
+        kind: opts.kind as any,
+        data: opts.data,
+      });
+    },
+
+    async broadcast(message, opts = {}) {
+      await ensureReady(client);
+      const ok = client.broadcast(message, (opts.kind as any) ?? 'message', opts.data);
+      if (!ok) throw new Error('Failed to broadcast message');
+    },
+
+    async subscribe(topic) {
+      await ensureReady(client);
+      const ok = client.subscribe(topic);
+      return boolResult(ok, 'subscribe');
+    },
+
+    async unsubscribe(topic) {
+      await ensureReady(client);
+      const ok = client.unsubscribe(topic);
+      return boolResult(ok, 'unsubscribe');
+    },
+
+    async joinChannel(channel, displayName) {
+      await ensureReady(client);
+      const ok = client.joinChannel(channel, displayName);
+      return boolResult(ok, 'join channel');
+    },
+
+    async leaveChannel(channel, reason) {
+      await ensureReady(client);
+      const ok = client.leaveChannel(channel, reason);
+      return boolResult(ok, 'leave channel');
+    },
+
+    async sendChannelMessage(channel, message, options = {}) {
+      await ensureReady(client);
+      const ok = client.sendChannelMessage(channel, message, { thread: options.thread });
+      if (!ok) throw new Error('Failed to send channel message');
+    },
+
+    async adminJoinChannel(channel, member) {
+      await ensureReady(client);
+      const ok = client.adminJoinChannel(channel, member);
+      return boolResult(ok, 'add member to channel');
+    },
+
+    async adminRemoveMember(channel, member) {
+      await ensureReady(client);
+      const ok = client.adminRemoveMember(channel, member);
+      return boolResult(ok, 'remove member from channel');
+    },
+
+    async bindAsShadow(primaryAgent, opts = {}) {
+      await ensureReady(client);
+      const ok = client.bindAsShadow(primaryAgent, { speakOn: opts.speakOn as any });
+      return boolResult(ok, 'bind as shadow');
+    },
+
+    async unbindAsShadow(primaryAgent) {
+      await ensureReady(client);
+      const ok = client.unbindAsShadow(primaryAgent);
+      return boolResult(ok, 'unbind shadow');
+    },
+
+    async createProposal(opts) {
+      await ensureReady(client);
+      const envelope: Envelope = {
+        v: PROTOCOL_VERSION,
+        type: 'PROPOSAL_CREATE',
+        id: randomUUID(),
+        ts: Date.now(),
+        payload: {
+          id: opts.id,
+          description: opts.description,
+          options: opts.options,
+          votingMethod: opts.votingMethod ?? 'majority',
+          deadline: opts.deadline,
+        },
+      };
+
+      const ok = (client as any).send?.(envelope) ?? false;
+      return boolResult(ok, 'create proposal');
+    },
+
+    async vote(opts) {
+      await ensureReady(client);
+      const envelope: Envelope = {
+        v: PROTOCOL_VERSION,
+        type: 'VOTE',
+        id: randomUUID(),
+        ts: Date.now(),
+        payload: {
+          proposalId: opts.proposalId,
+          vote: opts.vote,
+          reason: opts.reason,
+        },
+      };
+
+      const ok = (client as any).send?.(envelope) ?? false;
+      return boolResult(ok, 'vote');
+    },
+
+    async spawn(options) {
+      await ensureReady(client);
+      return client.spawn(options);
+    },
+
+    async release(name, reason) {
+      await ensureReady(client);
+      // Type assertion needed until SDK is published with reason parameter
+      // SDK 2.1.13 has: release(name, timeoutMs?)
+      // SDK 2.1.14+ has: release(name, reason?, timeoutMs?)
+      return (client as any).release(name, reason);
+    },
+
+    async getStatus() {
+      try {
+        await ensureReady(client);
+        const status = await client.getStatus();
+        return {
+          connected: true,
+          agentName: ctx.agentName,
+          project,
+          socketPath,
+          daemonVersion: status.version,
+          uptime: status.uptime ? `${Math.floor(status.uptime / 1000)}s` : undefined,
+        };
+      } catch {
+        return {
+          connected: false,
+          agentName: ctx.agentName,
+          project,
+          socketPath,
+        };
+      }
+    },
+
+    async getInbox(options = {}) {
+      await ensureReady(client);
+      const messages: InboxMessage[] = await client.getInbox({
+        limit: options.limit,
+        unreadOnly: options.unread_only,
+        from: options.from,
+        channel: options.channel,
+      });
+
+      return messages.map((m) => ({
+        id: m.id,
+        from: m.from,
+        content: m.body,
+        channel: m.channel,
+        thread: m.thread,
+      }));
+    },
+
+    async listAgents(options = {}) {
+      await ensureReady(client);
+      return client.listAgents({
+        includeIdle: options.include_idle,
+        project: options.project,
+      });
+    },
+
+    async listConnectedAgents(options = {}) {
+      await ensureReady(client);
+      return client.listConnectedAgents({
+        project: options.project,
+      });
+    },
+
+    async removeAgent(name, options = {}) {
+      await ensureReady(client);
+      return client.removeAgent(name, { removeMessages: options.removeMessages });
+    },
+
+    async getHealth(options = {}) {
+      await ensureReady(client);
+      return client.getHealth({
+        includeCrashes: options.include_crashes,
+        includeAlerts: options.include_alerts,
+      });
+    },
+
+    async getMetrics(options = {}) {
+      await ensureReady(client);
+      return client.getMetrics({ agent: options.agent });
+    },
+
+    async queryMessages(options = {}) {
+      await ensureReady(client);
+      const response = await client.queryMessages({
+        limit: options.limit,
+        sinceTs: options.sinceTs ?? options.since_ts,
+        from: options.from,
+        to: options.to,
+        thread: options.thread,
+        order: options.order,
+      });
+      return response || [];
+    },
+
+    async sendLog(data: string) {
+      await ensureReady(client);
+      const ok = client.sendLog(data);
+      if (!ok) throw new Error('Failed to send log');
+    },
+  };
+}
+
+export interface RelayClientOptions {
+  agentName: string;
+  socketPath?: string;
+  project?: string;
+  quiet?: boolean;
+  timeout?: number;
+}
+
+/**
+ * Factory that creates an SDK RelayClient and wraps it with the MCP adapter.
+ */
+export function createRelayClient(options: RelayClientOptions): RelayClient {
+  const sdkClient = new SdkRelayClient({
+    agentName: options.agentName,
+    socketPath: options.socketPath,
+    quiet: options.quiet,
+    reconnect: true,
+  });
+
+  return createRelayClientAdapter(sdkClient, {
+    agentName: options.agentName,
+    project: options.project,
+    socketPath: options.socketPath,
+  });
+}