agent-relay 2.0.25 → 2.0.26

package/packages/mcp/dist/client.js

@@ -1,48 +1,15 @@
 /**
  * RelayClient - Client for connecting to the Agent Relay daemon
+ *
+ * This module uses @agent-relay/protocol for wire format handling
+ * to avoid code duplication with the SDK.
  */
 import { createConnection } from 'node:net';
 import { randomUUID } from 'node:crypto';
 import { discoverSocket } from './cloud.js';
 import { DaemonNotRunningError } from './errors.js';
-// Protocol version
-const PROTOCOL_VERSION = 1;
-/**
- * Encode a message envelope into a length-prefixed frame (legacy format).
- * Format: 4-byte big-endian length + JSON payload
- */
-function encodeFrame(envelope) {
-    const json = JSON.stringify(envelope);
-    const data = Buffer.from(json, 'utf-8');
-    const header = Buffer.alloc(4);
-    header.writeUInt32BE(data.length, 0);
-    return Buffer.concat([header, data]);
-}
-/**
- * Frame parser for length-prefixed messages.
- */
-class FrameParser {
-    buffer = Buffer.alloc(0);
-    push(data) {
-        this.buffer = Buffer.concat([this.buffer, data]);
-        const frames = [];
-        while (this.buffer.length >= 4) {
-            const frameLength = this.buffer.readUInt32BE(0);
-            const totalLength = 4 + frameLength;
-            if (this.buffer.length < totalLength)
-                break;
-            const payload = this.buffer.subarray(4, totalLength);
-            this.buffer = this.buffer.subarray(totalLength);
-            try {
-                frames.push(JSON.parse(payload.toString('utf-8')));
-            }
-            catch {
-                // Skip malformed frames
-            }
-        }
-        return frames;
-    }
-}
+// Import shared protocol types and framing utilities
+import { encodeFrameLegacy, FrameParser, PROTOCOL_VERSION, } from '@agent-relay/protocol';
 export function createRelayClient(options) {
     const { agentName, project = 'default', timeout = 5000 } = options;
     // Prefer explicit socketPath option over discovery to avoid finding wrong daemon
@@ -55,9 +22,6 @@ export function createRelayClient(options) {
     /**
      * Fire-and-forget: Send a message without waiting for any response.
      * Used for SEND and SPAWN where we don't expect daemon to reply.
-     * @param type Message type
-     * @param payload Message payload (for SEND: must be SendPayload with kind, body, etc.)
-     * @param envelopeProps Envelope-level routing (from, to) - NOT in payload!
      */
     function fireAndForget(type, payload, envelopeProps) {
         return new Promise((resolve, reject) => {
@@ -68,15 +32,12 @@ export function createRelayClient(options) {
                 id,
                 ts: Date.now(),
                 payload,
+                from: envelopeProps?.from,
+                to: envelopeProps?.to,
             };
-            // Add from/to at envelope level (required for SEND messages)
-            if (envelopeProps?.from)
-                envelope.from = envelopeProps.from;
-            if (envelopeProps?.to)
-                envelope.to = envelopeProps.to;
             const socket = createConnection(socketPath);
             socket.on('connect', () => {
-                socket.write(encodeFrame(envelope));
+                socket.write(encodeFrameLegacy(envelope));
                 socket.end();
                 resolve();
             });
@@ -94,34 +55,26 @@ export function createRelayClient(options) {
     /**
      * Request-response: Send a message and wait for daemon to respond.
      * Used for queries (STATUS, INBOX, etc.) and blocking sends (waits for ACK).
-     * @param type Message type
-     * @param payload Message payload (for SEND: must be SendPayload with kind, body, etc.)
-     * @param customTimeout Optional timeout override
-     * @param payloadMeta Optional sync metadata for blocking sends
-     * @param envelopeProps Envelope-level routing (from, to) - NOT in payload!
      */
     async function request(type, payload, customTimeout, payloadMeta, envelopeProps) {
         return new Promise((resolve, reject) => {
             const id = generateId();
             const correlationId = payloadMeta?.sync?.correlationId;
-            // Build a proper protocol envelope
             const envelope = {
                 v: PROTOCOL_VERSION,
                 type,
                 id,
                 ts: Date.now(),
                 payload,
+                from: envelopeProps?.from,
+                to: envelopeProps?.to,
             };
-            // Add from/to at envelope level (required for SEND messages)
-            if (envelopeProps?.from)
-                envelope.from = envelopeProps.from;
-            if (envelopeProps?.to)
-                envelope.to = envelopeProps.to;
             if (payloadMeta) {
                 envelope.payload_meta = payloadMeta;
             }
             let timedOut = false;
             const parser = new FrameParser();
+            parser.setLegacyMode(true); // Use legacy 4-byte header format
             const socket = createConnection(socketPath);
             const effectiveTimeout = customTimeout ?? timeout;
             const timeoutId = setTimeout(() => {
@@ -129,22 +82,20 @@ export function createRelayClient(options) {
                 socket.destroy();
                 reject(new Error(`Request timeout after ${effectiveTimeout}ms`));
             }, effectiveTimeout);
-            socket.on('connect', () => socket.write(encodeFrame(envelope)));
+            socket.on('connect', () => socket.write(encodeFrameLegacy(envelope)));
             socket.on('data', (data) => {
-                // Ignore data if we've already timed out
                 if (timedOut)
                     return;
                 const frames = parser.push(data);
                 for (const response of frames) {
                     const responsePayload = response.payload;
-                    // Check if this is a response to our request (by id, replyTo, or correlationId for blocking sends)
+                    // Check if this is a response to our request
                     const isMatchingResponse = response.id === id ||
                         responsePayload?.replyTo === id ||
                         (correlationId && responsePayload?.correlationId === correlationId);
                     if (isMatchingResponse) {
                         clearTimeout(timeoutId);
                         socket.end();
-                        // Handle error responses
                         if (response.type === 'ERROR') {
                             reject(new Error(responsePayload?.message || responsePayload?.code || 'Unknown error'));
                         }
@@ -160,7 +111,6 @@ export function createRelayClient(options) {
             });
             socket.on('error', (err) => {
                 clearTimeout(timeoutId);
-                // Provide user-friendly error for common connection failures
                 const errno = err.code;
                 if (errno === 'ECONNREFUSED' || errno === 'ENOENT') {
                     reject(new DaemonNotRunningError(`Cannot connect to daemon at ${socketPath}`));
@@ -173,30 +123,106 @@ export function createRelayClient(options) {
     }
     return {
         async send(to, message, opts = {}) {
-            // Fire-and-forget: daemon doesn't respond to non-blocking SEND
-            // from/to must be at envelope level, kind/body/thread in payload
-            await fireAndForget('SEND', { kind: 'message', body: message, thread: opts.thread }, { from: agentName, to });
+            const payload = { kind: 'message', body: message, thread: opts.thread };
+            await fireAndForget('SEND', payload, { from: agentName, to });
         },
         async sendAndWait(to, message, opts = {}) {
-            // Use proper SEND with sync.blocking - daemon handles the wait and returns ACK
-            // from/to must be at envelope level, kind/body/thread in payload
             const waitTimeout = opts.timeoutMs || 30000;
             const correlationId = randomUUID();
-            const r = await request('SEND', {
-                kind: 'message',
-                body: message,
-                thread: opts.thread,
-            }, waitTimeout + 5000, {
-                sync: {
-                    blocking: true,
-                    correlationId,
-                    timeoutMs: waitTimeout,
-                },
-            }, { from: agentName, to });
+            const payload = { kind: 'message', body: message, thread: opts.thread };
+            const r = await request('SEND', payload, waitTimeout + 5000, { sync: { blocking: true, correlationId, timeoutMs: waitTimeout } }, { from: agentName, to });
             return { from: r.from ?? to, content: r.response ?? '', thread: opts.thread };
         },
+        async broadcast(message, opts = {}) {
+            const payload = { kind: opts.kind || 'message', body: message };
+            await fireAndForget('SEND', payload, { from: agentName, to: '*' });
+        },
+        async subscribe(topic) {
+            try {
+                await fireAndForget('SUBSCRIBE', { topic }, { from: agentName });
+                return { success: true };
+            }
+            catch (e) {
+                return { success: false, error: e instanceof Error ? e.message : String(e) };
+            }
+        },
+        async unsubscribe(topic) {
+            try {
+                await fireAndForget('UNSUBSCRIBE', { topic }, { from: agentName });
+                return { success: true };
+            }
+            catch (e) {
+                return { success: false, error: e instanceof Error ? e.message : String(e) };
+            }
+        },
+        async joinChannel(channel, displayName) {
+            try {
+                await fireAndForget('CHANNEL_JOIN', { channel, displayName }, { from: agentName });
+                return { success: true };
+            }
+            catch (e) {
+                return { success: false, error: e instanceof Error ? e.message : String(e) };
+            }
+        },
+        async leaveChannel(channel, reason) {
+            try {
+                await fireAndForget('CHANNEL_LEAVE', { channel, reason }, { from: agentName });
+                return { success: true };
+            }
+            catch (e) {
+                return { success: false, error: e instanceof Error ? e.message : String(e) };
+            }
+        },
+        async sendChannelMessage(channel, message, opts = {}) {
+            await fireAndForget('CHANNEL_MESSAGE', { channel, body: message, thread: opts.thread }, { from: agentName });
+        },
+        async bindAsShadow(primaryAgent, opts = {}) {
+            try {
+                await fireAndForget('SHADOW_BIND', { primaryAgent, speakOn: opts.speakOn }, { from: agentName });
+                return { success: true };
+            }
+            catch (e) {
+                return { success: false, error: e instanceof Error ? e.message : String(e) };
+            }
+        },
+        async unbindAsShadow(primaryAgent) {
+            try {
+                await fireAndForget('SHADOW_UNBIND', { primaryAgent }, { from: agentName });
+                return { success: true };
+            }
+            catch (e) {
+                return { success: false, error: e instanceof Error ? e.message : String(e) };
+            }
+        },
+        async createProposal(opts) {
+            try {
+                await fireAndForget('PROPOSAL_CREATE', {
+                    id: opts.id,
+                    description: opts.description,
+                    options: opts.options,
+                    votingMethod: opts.votingMethod || 'majority',
+                    deadline: opts.deadline,
+                }, { from: agentName });
+                return { success: true };
+            }
+            catch (e) {
+                return { success: false, error: e instanceof Error ? e.message : String(e) };
+            }
+        },
+        async vote(opts) {
+            try {
+                await fireAndForget('VOTE', {
+                    proposalId: opts.proposalId,
+                    vote: opts.vote,
+                    reason: opts.reason,
+                }, { from: agentName });
+                return { success: true };
+            }
+            catch (e) {
+                return { success: false, error: e instanceof Error ? e.message : String(e) };
+            }
+        },
         async spawn(opts) {
-            // Fire-and-forget: daemon handles spawning, agent will message when ready
             try {
                 const payload = {
                     name: opts.name,
@@ -204,7 +230,7 @@ export function createRelayClient(options) {
                     task: opts.task,
                     model: opts.model,
                     cwd: opts.cwd,
-                    spawnerName: agentName, // Parent agent making the spawn request
+                    spawnerName: agentName,
                 };
                 await fireAndForget('SPAWN', payload);
                 return { success: true };

package/packages/mcp/dist/server.js

@@ -1,7 +1,7 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { relaySendTool, relaySendSchema, handleRelaySend, relayInboxTool, relayInboxSchema, handleRelayInbox, relayWhoTool, relayWhoSchema, handleRelayWho, relaySpawnTool, relaySpawnSchema, handleRelaySpawn, relayReleaseTool, relayReleaseSchema, handleRelayRelease, relayStatusTool, relayStatusSchema, handleRelayStatus, relayLogsTool, relayLogsSchema, handleRelayLogs, relayMetricsTool, relayMetricsSchema, handleRelayMetrics, relayHealthTool, relayHealthSchema, handleRelayHealth, relayContinuityTool, relayContinuitySchema, handleRelayContinuity, relayConnectedTool, relayConnectedSchema, handleRelayConnected, relayRemoveAgentTool, relayRemoveAgentSchema, handleRelayRemoveAgent, } from './tools/index.js';
+import { relaySendTool, relaySendSchema, handleRelaySend, relayInboxTool, relayInboxSchema, handleRelayInbox, relayWhoTool, relayWhoSchema, handleRelayWho, relaySpawnTool, relaySpawnSchema, handleRelaySpawn, relayReleaseTool, relayReleaseSchema, handleRelayRelease, relayStatusTool, relayStatusSchema, handleRelayStatus, relayLogsTool, relayLogsSchema, handleRelayLogs, relayMetricsTool, relayMetricsSchema, handleRelayMetrics, relayHealthTool, relayHealthSchema, handleRelayHealth, relayContinuityTool, relayContinuitySchema, handleRelayContinuity, relayConnectedTool, relayConnectedSchema, handleRelayConnected, relayRemoveAgentTool, relayRemoveAgentSchema, handleRelayRemoveAgent, relayBroadcastTool, relayBroadcastSchema, handleRelayBroadcast, relaySubscribeTool, relaySubscribeSchema, handleRelaySubscribe, relayUnsubscribeTool, relayUnsubscribeSchema, handleRelayUnsubscribe, relayChannelJoinTool, relayChannelJoinSchema, handleRelayChannelJoin, relayChannelLeaveTool, relayChannelLeaveSchema, handleRelayChannelLeave, relayChannelMessageTool, relayChannelMessageSchema, handleRelayChannelMessage, relayShadowBindTool, relayShadowBindSchema, handleRelayShadowBind, relayShadowUnbindTool, relayShadowUnbindSchema, handleRelayShadowUnbind, relayProposalTool, relayProposalSchema, handleRelayProposal, relayVoteTool, relayVoteSchema, handleRelayVote, } from './tools/index.js';
 import { protocolPrompt, getProtocolPrompt } from './prompts/index.js';
 import { agentsResource, getAgentsResource, inboxResource, getInboxResource, projectResource, getProjectResource, } from './resources/index.js';
 /**
@@ -20,6 +20,16 @@ const TOOLS = [
     relayMetricsTool,
     relayHealthTool,
     relayContinuityTool,
+    relayBroadcastTool,
+    relaySubscribeTool,
+    relayUnsubscribeTool,
+    relayChannelJoinTool,
+    relayChannelLeaveTool,
+    relayChannelMessageTool,
+    relayShadowBindTool,
+    relayShadowUnbindTool,
+    relayProposalTool,
+    relayVoteTool,
 ];
 /**
  * All available prompts
@@ -115,6 +125,56 @@ export function createMCPServer(client, config) {
                     result = await handleRelayContinuity(client, input);
                     break;
                 }
+                case 'relay_broadcast': {
+                    const input = relayBroadcastSchema.parse(args);
+                    result = await handleRelayBroadcast(client, input);
+                    break;
+                }
+                case 'relay_subscribe': {
+                    const input = relaySubscribeSchema.parse(args);
+                    result = await handleRelaySubscribe(client, input);
+                    break;
+                }
+                case 'relay_unsubscribe': {
+                    const input = relayUnsubscribeSchema.parse(args);
+                    result = await handleRelayUnsubscribe(client, input);
+                    break;
+                }
+                case 'relay_channel_join': {
+                    const input = relayChannelJoinSchema.parse(args);
+                    result = await handleRelayChannelJoin(client, input);
+                    break;
+                }
+                case 'relay_channel_leave': {
+                    const input = relayChannelLeaveSchema.parse(args);
+                    result = await handleRelayChannelLeave(client, input);
+                    break;
+                }
+                case 'relay_channel_message': {
+                    const input = relayChannelMessageSchema.parse(args);
+                    result = await handleRelayChannelMessage(client, input);
+                    break;
+                }
+                case 'relay_shadow_bind': {
+                    const input = relayShadowBindSchema.parse(args);
+                    result = await handleRelayShadowBind(client, input);
+                    break;
+                }
+                case 'relay_shadow_unbind': {
+                    const input = relayShadowUnbindSchema.parse(args);
+                    result = await handleRelayShadowUnbind(client, input);
+                    break;
+                }
+                case 'relay_proposal': {
+                    const input = relayProposalSchema.parse(args);
+                    result = await handleRelayProposal(client, input);
+                    break;
+                }
+                case 'relay_vote': {
+                    const input = relayVoteSchema.parse(args);
+                    result = await handleRelayVote(client, input);
+                    break;
+                }
                 default:
                     return {
                         content: [

package/packages/mcp/dist/tools/index.d.ts

@@ -10,4 +10,9 @@ export { relayHealthTool, relayHealthSchema, handleRelayHealth, type RelayHealth
 export { relayContinuityTool, relayContinuitySchema, handleRelayContinuity, type RelayContinuityInput, } from './relay-continuity.js';
 export { relayConnectedTool, relayConnectedSchema, handleRelayConnected, type RelayConnectedInput, } from './relay-connected.js';
 export { relayRemoveAgentTool, relayRemoveAgentSchema, handleRelayRemoveAgent, type RelayRemoveAgentInput, } from './relay-remove-agent.js';
+export { relayBroadcastTool, relayBroadcastSchema, handleRelayBroadcast, type RelayBroadcastInput, } from './relay-broadcast.js';
+export { relaySubscribeTool, relaySubscribeSchema, handleRelaySubscribe, type RelaySubscribeInput, relayUnsubscribeTool, relayUnsubscribeSchema, handleRelayUnsubscribe, type RelayUnsubscribeInput, } from './relay-subscribe.js';
+export { relayChannelJoinTool, relayChannelJoinSchema, handleRelayChannelJoin, type RelayChannelJoinInput, relayChannelLeaveTool, relayChannelLeaveSchema, handleRelayChannelLeave, type RelayChannelLeaveInput, relayChannelMessageTool, relayChannelMessageSchema, handleRelayChannelMessage, type RelayChannelMessageInput, } from './relay-channel.js';
+export { relayShadowBindTool, relayShadowBindSchema, handleRelayShadowBind, type RelayShadowBindInput, relayShadowUnbindTool, relayShadowUnbindSchema, handleRelayShadowUnbind, type RelayShadowUnbindInput, } from './relay-shadow.js';
+export { relayProposalTool, relayProposalSchema, handleRelayProposal, type RelayProposalInput, relayVoteTool, relayVoteSchema, handleRelayVote, type RelayVoteInput, } from './relay-consensus.js';
 //# sourceMappingURL=index.d.ts.map

package/packages/mcp/dist/tools/index.js

@@ -10,4 +10,9 @@ export { relayHealthTool, relayHealthSchema, handleRelayHealth, } from './relay-
 export { relayContinuityTool, relayContinuitySchema, handleRelayContinuity, } from './relay-continuity.js';
 export { relayConnectedTool, relayConnectedSchema, handleRelayConnected, } from './relay-connected.js';
 export { relayRemoveAgentTool, relayRemoveAgentSchema, handleRelayRemoveAgent, } from './relay-remove-agent.js';
+export { relayBroadcastTool, relayBroadcastSchema, handleRelayBroadcast, } from './relay-broadcast.js';
+export { relaySubscribeTool, relaySubscribeSchema, handleRelaySubscribe, relayUnsubscribeTool, relayUnsubscribeSchema, handleRelayUnsubscribe, } from './relay-subscribe.js';
+export { relayChannelJoinTool, relayChannelJoinSchema, handleRelayChannelJoin, relayChannelLeaveTool, relayChannelLeaveSchema, handleRelayChannelLeave, relayChannelMessageTool, relayChannelMessageSchema, handleRelayChannelMessage, } from './relay-channel.js';
+export { relayShadowBindTool, relayShadowBindSchema, handleRelayShadowBind, relayShadowUnbindTool, relayShadowUnbindSchema, handleRelayShadowUnbind, } from './relay-shadow.js';
+export { relayProposalTool, relayProposalSchema, handleRelayProposal, relayVoteTool, relayVoteSchema, handleRelayVote, } from './relay-consensus.js';
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,20 @@
+/**
+ * relay_broadcast - Broadcast a message to all connected agents
+ */
+import { z } from 'zod';
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+import type { RelayClient } from '../client.js';
+export declare const relayBroadcastSchema: z.ZodObject<{
+    message: z.ZodString;
+    kind: z.ZodOptional<z.ZodEnum<["message", "action", "state", "thinking"]>>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    kind?: "message" | "action" | "state" | "thinking" | undefined;
+}, {
+    message: string;
+    kind?: "message" | "action" | "state" | "thinking" | undefined;
+}>;
+export type RelayBroadcastInput = z.infer<typeof relayBroadcastSchema>;
+export declare const relayBroadcastTool: Tool;
+export declare function handleRelayBroadcast(client: RelayClient, input: RelayBroadcastInput): Promise<string>;
+//# sourceMappingURL=relay-broadcast.d.ts.map

package/packages/mcp/dist/tools/relay-broadcast.js

@@ -0,0 +1,25 @@
+/**
+ * relay_broadcast - Broadcast a message to all connected agents
+ */
+import { z } from 'zod';
+export const relayBroadcastSchema = z.object({
+    message: z.string().describe('The message to broadcast to all agents'),
+    kind: z.enum(['message', 'action', 'state', 'thinking']).optional().describe('Message kind (default: message)'),
+});
+export const relayBroadcastTool = {
+    name: 'relay_broadcast',
+    description: 'Broadcast a message to ALL connected agents at once. Use this when you need to send the same message to everyone.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            message: { type: 'string', description: 'The message to broadcast to all agents' },
+            kind: { type: 'string', enum: ['message', 'action', 'state', 'thinking'], description: 'Message kind (default: message)' },
+        },
+        required: ['message'],
+    },
+};
+export async function handleRelayBroadcast(client, input) {
+    await client.broadcast(input.message, { kind: input.kind });
+    return 'Message broadcast to all agents';
+}
+//# sourceMappingURL=relay-broadcast.js.map

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

@@ -0,0 +1,49 @@
+/**
+ * relay_channel_join / relay_channel_leave / relay_channel_message - Channel operations
+ */
+import { z } from 'zod';
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+import type { RelayClient } from '../client.js';
+export declare const relayChannelJoinSchema: z.ZodObject<{
+    channel: z.ZodString;
+    display_name: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    channel: string;
+    display_name?: string | undefined;
+}, {
+    channel: string;
+    display_name?: string | undefined;
+}>;
+export type RelayChannelJoinInput = z.infer<typeof relayChannelJoinSchema>;
+export declare const relayChannelJoinTool: Tool;
+export declare function handleRelayChannelJoin(client: RelayClient, input: RelayChannelJoinInput): Promise<string>;
+export declare const relayChannelLeaveSchema: z.ZodObject<{
+    channel: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    channel: string;
+    reason?: string | undefined;
+}, {
+    channel: string;
+    reason?: string | undefined;
+}>;
+export type RelayChannelLeaveInput = z.infer<typeof relayChannelLeaveSchema>;
+export declare const relayChannelLeaveTool: Tool;
+export declare function handleRelayChannelLeave(client: RelayClient, input: RelayChannelLeaveInput): Promise<string>;
+export declare const relayChannelMessageSchema: z.ZodObject<{
+    channel: z.ZodString;
+    message: z.ZodString;
+    thread: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    channel: string;
+    thread?: string | undefined;
+}, {
+    message: string;
+    channel: string;
+    thread?: string | undefined;
+}>;
+export type RelayChannelMessageInput = z.infer<typeof relayChannelMessageSchema>;
+export declare const relayChannelMessageTool: Tool;
+export declare function handleRelayChannelMessage(client: RelayClient, input: RelayChannelMessageInput): Promise<string>;
+//# sourceMappingURL=relay-channel.d.ts.map

package/packages/mcp/dist/tools/relay-channel.js

@@ -0,0 +1,76 @@
+/**
+ * relay_channel_join / relay_channel_leave / relay_channel_message - Channel operations
+ */
+import { z } from 'zod';
+// Join channel
+export const relayChannelJoinSchema = z.object({
+    channel: z.string().describe('The channel name to join (e.g., "#general")'),
+    display_name: z.string().optional().describe('Optional display name to use in the channel'),
+});
+export const relayChannelJoinTool = {
+    name: 'relay_channel_join',
+    description: 'Join a channel to participate in group conversations. Channels start with #.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            channel: { type: 'string', description: 'The channel name to join (e.g., "#general")' },
+            display_name: { type: 'string', description: 'Optional display name to use in the channel' },
+        },
+        required: ['channel'],
+    },
+};
+export async function handleRelayChannelJoin(client, input) {
+    const result = await client.joinChannel(input.channel, input.display_name);
+    if (result.success) {
+        return `Joined channel "${input.channel}"`;
+    }
+    return `Failed to join channel: ${result.error}`;
+}
+// Leave channel
+export const relayChannelLeaveSchema = z.object({
+    channel: z.string().describe('The channel name to leave'),
+    reason: z.string().optional().describe('Optional reason for leaving'),
+});
+export const relayChannelLeaveTool = {
+    name: 'relay_channel_leave',
+    description: 'Leave a channel you are currently in.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            channel: { type: 'string', description: 'The channel name to leave' },
+            reason: { type: 'string', description: 'Optional reason for leaving' },
+        },
+        required: ['channel'],
+    },
+};
+export async function handleRelayChannelLeave(client, input) {
+    const result = await client.leaveChannel(input.channel, input.reason);
+    if (result.success) {
+        return `Left channel "${input.channel}"`;
+    }
+    return `Failed to leave channel: ${result.error}`;
+}
+// Send channel message
+export const relayChannelMessageSchema = z.object({
+    channel: z.string().describe('The channel to send the message to'),
+    message: z.string().describe('The message content'),
+    thread: z.string().optional().describe('Optional thread ID for threaded conversations'),
+});
+export const relayChannelMessageTool = {
+    name: 'relay_channel_message',
+    description: 'Send a message to a channel. You must be a member of the channel.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            channel: { type: 'string', description: 'The channel to send the message to' },
+            message: { type: 'string', description: 'The message content' },
+            thread: { type: 'string', description: 'Optional thread ID for threaded conversations' },
+        },
+        required: ['channel', 'message'],
+    },
+};
+export async function handleRelayChannelMessage(client, input) {
+    await client.sendChannelMessage(input.channel, input.message, { thread: input.thread });
+    return `Message sent to channel "${input.channel}"`;
+}
+//# sourceMappingURL=relay-channel.js.map

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

@@ -0,0 +1,45 @@
+/**
+ * relay_proposal / relay_vote - Consensus/voting operations
+ */
+import { z } from 'zod';
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+import type { RelayClient } from '../client.js';
+export declare const relayProposalSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    options: z.ZodArray<z.ZodString, "many">;
+    voting_method: z.ZodOptional<z.ZodEnum<["majority", "supermajority", "unanimous", "weighted", "quorum"]>>;
+    deadline: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    description: string;
+    options: string[];
+    deadline?: number | undefined;
+    voting_method?: "majority" | "supermajority" | "unanimous" | "weighted" | "quorum" | undefined;
+}, {
+    id: string;
+    description: string;
+    options: string[];
+    deadline?: number | undefined;
+    voting_method?: "majority" | "supermajority" | "unanimous" | "weighted" | "quorum" | undefined;
+}>;
+export type RelayProposalInput = z.infer<typeof relayProposalSchema>;
+export declare const relayProposalTool: Tool;
+export declare function handleRelayProposal(client: RelayClient, input: RelayProposalInput): Promise<string>;
+export declare const relayVoteSchema: z.ZodObject<{
+    proposal_id: z.ZodString;
+    vote: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    vote: string;
+    proposal_id: string;
+    reason?: string | undefined;
+}, {
+    vote: string;
+    proposal_id: string;
+    reason?: string | undefined;
+}>;
+export type RelayVoteInput = z.infer<typeof relayVoteSchema>;
+export declare const relayVoteTool: Tool;
+export declare function handleRelayVote(client: RelayClient, input: RelayVoteInput): Promise<string>;
+//# sourceMappingURL=relay-consensus.d.ts.map