@dudamel/mcp-peers 0.0.0-stage → 2026.1104.1

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { createPeersServer } from './server.js';
+export type { McpPeersConfig } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,265 @@
+// src/server.ts
+import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// ../common/dist/http-client.js
+function parseApiErrorBody(body) {
+  try {
+    const parsed = JSON.parse(body);
+    if (typeof parsed !== "object" || parsed === null || !("error" in parsed))
+      return void 0;
+    const error = parsed.error;
+    if (typeof error === "object" && error !== null && typeof error.code === "string" && typeof error.message === "string") {
+      return error;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+var DudamelApiError = class extends Error {
+  status;
+  statusText;
+  body;
+  /** Stable machine-readable code from the API error body, or 'UNKNOWN' for non-conforming bodies. */
+  code;
+  /** Per-field validation errors, when the API provided them. */
+  details;
+  /** Extra machine-readable data (e.g. `inputsSchema` on execute validation failures). */
+  context;
+  constructor(status, statusText, body) {
+    const apiError = parseApiErrorBody(body);
+    const lines = [
+      apiError ? `Dudamel API error ${status} ${statusText}: ${apiError.code}: ${apiError.message}` : `Dudamel API error ${status} ${statusText}: ${body}`
+    ];
+    if (apiError?.details?.length) {
+      lines.push(...apiError.details.map((d) => `  - ${d.path}: ${d.message}`));
+    }
+    if (apiError?.context?.["inputsSchema"] !== void 0) {
+      lines.push(`Expected inputs schema: ${JSON.stringify(apiError.context["inputsSchema"])}`);
+    }
+    super(lines.join("\n"));
+    this.status = status;
+    this.statusText = statusText;
+    this.body = body;
+    this.name = "DudamelApiError";
+    this.code = apiError?.code ?? "UNKNOWN";
+    this.details = apiError?.details;
+    this.context = apiError?.context;
+  }
+};
+var DudamelApiClient = class {
+  baseUrl;
+  headers;
+  constructor(baseUrl, apiKey, authScheme) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.headers = {
+      Authorization: `${authScheme ?? "ApiKey"} ${apiKey}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async get(path, params) {
+    const url = this.buildUrl(path, params);
+    return this.request(url, { method: "GET" });
+  }
+  async post(path, body, params) {
+    const url = this.buildUrl(path, params);
+    return this.request(url, {
+      method: "POST",
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  }
+  async put(path, body, params) {
+    const url = this.buildUrl(path, params);
+    return this.request(url, {
+      method: "PUT",
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  }
+  async delete(path, params) {
+    const url = this.buildUrl(path, params);
+    return this.request(url, { method: "DELETE" });
+  }
+  buildUrl(path, params) {
+    const url = new URL(path, this.baseUrl);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== "") {
+          url.searchParams.set(key, value);
+        }
+      }
+    }
+    return url.toString();
+  }
+  async request(url, init) {
+    const response = await fetch(url, {
+      ...init,
+      headers: this.headers
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new DudamelApiError(response.status, response.statusText, body);
+    }
+    const text = await response.text();
+    if (!text) {
+      return void 0;
+    }
+    return JSON.parse(text);
+  }
+};
+
+// ../common/dist/read-only-filter.js
+function withReadOnlyFilter(server, readOnly) {
+  if (!readOnly)
+    return server;
+  const original = server.registerTool.bind(server);
+  const filtered = (...args) => {
+    const config = args[1];
+    if (config?.annotations?.readOnlyHint === false) {
+      return void 0;
+    }
+    return original(...args);
+  };
+  return new Proxy(server, {
+    get(target, prop, receiver) {
+      if (prop === "registerTool")
+        return filtered;
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+
+// ../common/dist/create-server.js
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// ../common/dist/util.js
+function jsonResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+function errorResult(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true
+  };
+}
+
+// src/tools/peers.ts
+import { z } from "zod";
+
+// src/poll.ts
+var GET_TASK_MAX_WAIT_SECONDS = 120;
+var INITIAL_POLL_INTERVAL_MS = 2e3;
+var MAX_POLL_INTERVAL_MS = 1e4;
+function isTerminal(task) {
+  const status = task?.status;
+  return status === "completed" || status === "failed";
+}
+async function pollTask(fetchTask, options) {
+  const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const now = options.now ?? Date.now;
+  const deadline = now() + options.waitMs;
+  let interval = INITIAL_POLL_INTERVAL_MS;
+  for (; ; ) {
+    const task = await fetchTask();
+    if (isTerminal(task)) return task;
+    const remaining = deadline - now();
+    if (remaining <= 0) return task;
+    await sleep(Math.min(interval, remaining));
+    interval = Math.min(interval * 1.5, MAX_POLL_INTERVAL_MS);
+  }
+}
+
+// src/tools/peers.ts
+function registerPeerTools(server, client, config) {
+  server.registerTool(
+    "list-agents",
+    {
+      description: "List the dudamel agents you can message, as agent cards: name, description and skills. The `name` is what send-message takes. Read the cards to decide WHO to delegate to \u2014 an empty list means no other agent is active, not an error.",
+      inputSchema: {},
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      try {
+        return jsonResult(await client.get("/api/conversations/peers"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server.registerTool(
+    "send-message",
+    {
+      description: "Send a message to another dudamel agent. Returns a task: in async mode (the default) it comes back `submitted` immediately \u2014 tell the user you delegated and end your turn; the answer arrives later as an `a2a-task-completed` system message (or poll it with get-task if you have no conversation). `sync` blocks and returns the task `completed` with the answer \u2014 only for short questions. Every response carries a `contextId`: pass it back on the next send-message to CONTINUE that conversation with the peer (it keeps its full history); omit it to start fresh.",
+      inputSchema: {
+        agentName: z.string().min(1).describe("Peer agent to message \u2014 a `name` from list-agents"),
+        message: z.string().min(1).describe(
+          "The message. Be specific and self-contained: the peer does not see your conversation"
+        ),
+        contextId: z.string().optional().describe("contextId from a previous exchange \u2014 continues that same thread"),
+        mode: z.enum(["async", "sync"]).optional().describe("async (default): fire and get notified. sync: wait for the answer inline")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    async ({ agentName, message, contextId, mode }) => {
+      try {
+        return jsonResult(
+          await client.post("/api/conversations/peers/messages", {
+            agentName,
+            message,
+            ...contextId ? { contextId } : {},
+            mode: mode ?? "async",
+            // Infrastructure correlation — from the env the bridge injects, never
+            // model-visible parameters (Plan 44, decisión 6).
+            ...config.conversationId ? { callerConversationId: config.conversationId } : {},
+            ...config.responseTarget ? { callerResponseTarget: config.responseTarget } : {},
+            chain: config.agentChain ?? []
+          })
+        );
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server.registerTool(
+    "get-task",
+    {
+      description: `Status and result of a send-message task by its \`taskId\`. Statuses: submitted (the peer has not answered yet), completed (\`result\` holds the answer), failed (\`errorSummary\` says why). Use it when you sent async and no completion message can reach you (e.g. you run outside a dudamel conversation). Pass \`waitSeconds\` (max ${GET_TASK_MAX_WAIT_SECONDS}) to have the tool poll internally and return as soon as the task goes terminal \u2014 if it is still submitted at the deadline, call again later instead of looping yourself.`,
+      inputSchema: {
+        taskId: z.string().min(1).describe("The `taskId` a send-message response returned"),
+        waitSeconds: z.number().int().min(0).max(GET_TASK_MAX_WAIT_SECONDS).optional().describe("Keep polling internally up to this many seconds (default 0: one look)")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ taskId, waitSeconds }) => {
+      try {
+        const task = await pollTask(
+          () => client.get(`/api/conversations/tasks/${encodeURIComponent(taskId)}`),
+          { waitMs: Math.min(waitSeconds ?? 0, GET_TASK_MAX_WAIT_SECONDS) * 1e3 }
+        );
+        return jsonResult(task);
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+}
+
+// src/server.ts
+function createPeersServer(config) {
+  const server = new McpServer2(
+    { name: "dudamel-peers", version: "0.1.0" },
+    {
+      capabilities: { tools: {} },
+      instructions: "Dudamel Peers MCP \u2014 message other dudamel agents. Flow: list-agents to see who exists and what they are good at \u2192 send-message (async by default: tell the user you delegated, end your turn, and react when the a2a-task-completed system message arrives; sync only for short questions) \u2192 re-send with the returned contextId to continue the same thread, where the peer remembers everything. These are OTHER agents of this dudamel instance, reached over the platform \u2014 NOT your own sub-agents."
+    }
+  );
+  const client = new DudamelApiClient(config.apiUrl, config.apiKey, config.authScheme);
+  const host = withReadOnlyFilter(server, config.readOnly ?? false);
+  registerPeerTools(host, client, config);
+  return server;
+}
+export {
+  createPeersServer
+};

package/dist/poll.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Hard ceiling on the wait. A conversational turn has a 5-minute inactivity watchdog
+ * (`TURN_STALLED`): a tool call that stays silent longer kills the CALLER's turn, so
+ * the cap must sit well under it. Waits longer than this mean the answer should come
+ * through the completion event (conversations) or a later get-task (terminal).
+ */
+export declare const GET_TASK_MAX_WAIT_SECONDS = 120;
+export interface PollOptions {
+    waitMs: number;
+    /** Injectable for tests — defaults to a real timer. */
+    sleep?: (ms: number) => Promise<void>;
+    /** Injectable clock for tests. */
+    now?: () => number;
+}
+/**
+ * Fetch the task, and — within `waitMs` — keep re-fetching with backoff until it goes
+ * terminal. Always returns the LAST snapshot: a task still `submitted` at the deadline
+ * is handed back as-is for the caller to decide (poll later, or give up).
+ */
+export declare function pollTask(fetchTask: () => Promise<unknown>, options: PollOptions): Promise<unknown>;
+//# sourceMappingURL=poll.d.ts.map

package/dist/poll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"poll.d.ts","sourceRoot":"","sources":["../src/poll.ts"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAK7C,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,uDAAuD;IACvD,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC,kCAAkC;IAClC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAOD;;;;GAIG;AACH,wBAAsB,QAAQ,CAC5B,SAAS,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,EACjC,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,OAAO,CAAC,CAelB"}

package/dist/server.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpPeersConfig } from './types.js';
+export declare function createPeersServer(config: McpPeersConfig): McpServer;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAGpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,cAAc,GAAG,SAAS,CAuBnE"}

package/dist/stdio-server.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=stdio-server.d.ts.map

package/dist/stdio-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio-server.d.ts","sourceRoot":"","sources":["../src/stdio-server.ts"],"names":[],"mappings":""}

package/dist/stdio-server.js

@@ -0,0 +1,309 @@
+#!/usr/bin/env node
+
+// src/stdio-server.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../common/dist/http-client.js
+function parseApiErrorBody(body) {
+  try {
+    const parsed = JSON.parse(body);
+    if (typeof parsed !== "object" || parsed === null || !("error" in parsed))
+      return void 0;
+    const error = parsed.error;
+    if (typeof error === "object" && error !== null && typeof error.code === "string" && typeof error.message === "string") {
+      return error;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+var DudamelApiError = class extends Error {
+  status;
+  statusText;
+  body;
+  /** Stable machine-readable code from the API error body, or 'UNKNOWN' for non-conforming bodies. */
+  code;
+  /** Per-field validation errors, when the API provided them. */
+  details;
+  /** Extra machine-readable data (e.g. `inputsSchema` on execute validation failures). */
+  context;
+  constructor(status, statusText, body) {
+    const apiError = parseApiErrorBody(body);
+    const lines = [
+      apiError ? `Dudamel API error ${status} ${statusText}: ${apiError.code}: ${apiError.message}` : `Dudamel API error ${status} ${statusText}: ${body}`
+    ];
+    if (apiError?.details?.length) {
+      lines.push(...apiError.details.map((d) => `  - ${d.path}: ${d.message}`));
+    }
+    if (apiError?.context?.["inputsSchema"] !== void 0) {
+      lines.push(`Expected inputs schema: ${JSON.stringify(apiError.context["inputsSchema"])}`);
+    }
+    super(lines.join("\n"));
+    this.status = status;
+    this.statusText = statusText;
+    this.body = body;
+    this.name = "DudamelApiError";
+    this.code = apiError?.code ?? "UNKNOWN";
+    this.details = apiError?.details;
+    this.context = apiError?.context;
+  }
+};
+var DudamelApiClient = class {
+  baseUrl;
+  headers;
+  constructor(baseUrl, apiKey2, authScheme) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.headers = {
+      Authorization: `${authScheme ?? "ApiKey"} ${apiKey2}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async get(path, params) {
+    const url = this.buildUrl(path, params);
+    return this.request(url, { method: "GET" });
+  }
+  async post(path, body, params) {
+    const url = this.buildUrl(path, params);
+    return this.request(url, {
+      method: "POST",
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  }
+  async put(path, body, params) {
+    const url = this.buildUrl(path, params);
+    return this.request(url, {
+      method: "PUT",
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  }
+  async delete(path, params) {
+    const url = this.buildUrl(path, params);
+    return this.request(url, { method: "DELETE" });
+  }
+  buildUrl(path, params) {
+    const url = new URL(path, this.baseUrl);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== "") {
+          url.searchParams.set(key, value);
+        }
+      }
+    }
+    return url.toString();
+  }
+  async request(url, init) {
+    const response = await fetch(url, {
+      ...init,
+      headers: this.headers
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new DudamelApiError(response.status, response.statusText, body);
+    }
+    const text = await response.text();
+    if (!text) {
+      return void 0;
+    }
+    return JSON.parse(text);
+  }
+};
+
+// ../common/dist/read-only-filter.js
+function withReadOnlyFilter(server2, readOnly2) {
+  if (!readOnly2)
+    return server2;
+  const original = server2.registerTool.bind(server2);
+  const filtered = (...args) => {
+    const config = args[1];
+    if (config?.annotations?.readOnlyHint === false) {
+      return void 0;
+    }
+    return original(...args);
+  };
+  return new Proxy(server2, {
+    get(target, prop, receiver) {
+      if (prop === "registerTool")
+        return filtered;
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+
+// ../common/dist/create-server.js
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// ../common/dist/stdio.js
+function resolveStdioContext() {
+  return {
+    apiUrl: process.env["DUDAMEL_API_URL"] ?? "http://localhost:3000",
+    apiKey: process.env["DUDAMEL_API_KEY"],
+    envRole: process.env["DUDAMEL_USER_ROLE"],
+    // read/write access is per agent-assignment; the spawner injects the mode.
+    readOnly: process.env["DUDAMEL_MCP_MODE"] === "readonly",
+    agentName: process.env["DUDAMEL_AGENT_NAME"]
+  };
+}
+
+// ../common/dist/util.js
+function jsonResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+function errorResult(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true
+  };
+}
+
+// src/server.ts
+import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/tools/peers.ts
+import { z } from "zod";
+
+// src/poll.ts
+var GET_TASK_MAX_WAIT_SECONDS = 120;
+var INITIAL_POLL_INTERVAL_MS = 2e3;
+var MAX_POLL_INTERVAL_MS = 1e4;
+function isTerminal(task) {
+  const status = task?.status;
+  return status === "completed" || status === "failed";
+}
+async function pollTask(fetchTask, options) {
+  const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const now = options.now ?? Date.now;
+  const deadline = now() + options.waitMs;
+  let interval = INITIAL_POLL_INTERVAL_MS;
+  for (; ; ) {
+    const task = await fetchTask();
+    if (isTerminal(task)) return task;
+    const remaining = deadline - now();
+    if (remaining <= 0) return task;
+    await sleep(Math.min(interval, remaining));
+    interval = Math.min(interval * 1.5, MAX_POLL_INTERVAL_MS);
+  }
+}
+
+// src/tools/peers.ts
+function registerPeerTools(server2, client, config) {
+  server2.registerTool(
+    "list-agents",
+    {
+      description: "List the dudamel agents you can message, as agent cards: name, description and skills. The `name` is what send-message takes. Read the cards to decide WHO to delegate to \u2014 an empty list means no other agent is active, not an error.",
+      inputSchema: {},
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      try {
+        return jsonResult(await client.get("/api/conversations/peers"));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.registerTool(
+    "send-message",
+    {
+      description: "Send a message to another dudamel agent. Returns a task: in async mode (the default) it comes back `submitted` immediately \u2014 tell the user you delegated and end your turn; the answer arrives later as an `a2a-task-completed` system message (or poll it with get-task if you have no conversation). `sync` blocks and returns the task `completed` with the answer \u2014 only for short questions. Every response carries a `contextId`: pass it back on the next send-message to CONTINUE that conversation with the peer (it keeps its full history); omit it to start fresh.",
+      inputSchema: {
+        agentName: z.string().min(1).describe("Peer agent to message \u2014 a `name` from list-agents"),
+        message: z.string().min(1).describe(
+          "The message. Be specific and self-contained: the peer does not see your conversation"
+        ),
+        contextId: z.string().optional().describe("contextId from a previous exchange \u2014 continues that same thread"),
+        mode: z.enum(["async", "sync"]).optional().describe("async (default): fire and get notified. sync: wait for the answer inline")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    async ({ agentName, message, contextId, mode }) => {
+      try {
+        return jsonResult(
+          await client.post("/api/conversations/peers/messages", {
+            agentName,
+            message,
+            ...contextId ? { contextId } : {},
+            mode: mode ?? "async",
+            // Infrastructure correlation — from the env the bridge injects, never
+            // model-visible parameters (Plan 44, decisión 6).
+            ...config.conversationId ? { callerConversationId: config.conversationId } : {},
+            ...config.responseTarget ? { callerResponseTarget: config.responseTarget } : {},
+            chain: config.agentChain ?? []
+          })
+        );
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server2.registerTool(
+    "get-task",
+    {
+      description: `Status and result of a send-message task by its \`taskId\`. Statuses: submitted (the peer has not answered yet), completed (\`result\` holds the answer), failed (\`errorSummary\` says why). Use it when you sent async and no completion message can reach you (e.g. you run outside a dudamel conversation). Pass \`waitSeconds\` (max ${GET_TASK_MAX_WAIT_SECONDS}) to have the tool poll internally and return as soon as the task goes terminal \u2014 if it is still submitted at the deadline, call again later instead of looping yourself.`,
+      inputSchema: {
+        taskId: z.string().min(1).describe("The `taskId` a send-message response returned"),
+        waitSeconds: z.number().int().min(0).max(GET_TASK_MAX_WAIT_SECONDS).optional().describe("Keep polling internally up to this many seconds (default 0: one look)")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ taskId, waitSeconds }) => {
+      try {
+        const task = await pollTask(
+          () => client.get(`/api/conversations/tasks/${encodeURIComponent(taskId)}`),
+          { waitMs: Math.min(waitSeconds ?? 0, GET_TASK_MAX_WAIT_SECONDS) * 1e3 }
+        );
+        return jsonResult(task);
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+}
+
+// src/server.ts
+function createPeersServer(config) {
+  const server2 = new McpServer2(
+    { name: "dudamel-peers", version: "0.1.0" },
+    {
+      capabilities: { tools: {} },
+      instructions: "Dudamel Peers MCP \u2014 message other dudamel agents. Flow: list-agents to see who exists and what they are good at \u2192 send-message (async by default: tell the user you delegated, end your turn, and react when the a2a-task-completed system message arrives; sync only for short questions) \u2192 re-send with the returned contextId to continue the same thread, where the peer remembers everything. These are OTHER agents of this dudamel instance, reached over the platform \u2014 NOT your own sub-agents."
+    }
+  );
+  const client = new DudamelApiClient(config.apiUrl, config.apiKey, config.authScheme);
+  const host = withReadOnlyFilter(server2, config.readOnly ?? false);
+  registerPeerTools(host, client, config);
+  return server2;
+}
+
+// src/stdio-server.ts
+function parseJsonEnv(name) {
+  const raw = process.env[name];
+  if (!raw) return void 0;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    process.stderr.write(`Warning: ${name} is not valid JSON \u2014 ignored.
+`);
+    return void 0;
+  }
+}
+var { apiUrl, apiKey, readOnly } = resolveStdioContext();
+var conversationId = process.env["DUDAMEL_CONVERSATION_ID"];
+var responseTarget = parseJsonEnv("DUDAMEL_RESPONSE_TARGET");
+var agentChain = parseJsonEnv("DUDAMEL_AGENT_CHAIN");
+if (!apiKey) {
+  process.stderr.write("Error: DUDAMEL_API_KEY environment variable is required.\n");
+  process.exit(1);
+}
+var server = createPeersServer({
+  apiUrl,
+  apiKey,
+  readOnly,
+  conversationId,
+  responseTarget,
+  agentChain
+});
+await server.connect(new StdioServerTransport());

package/dist/tools/peers.d.ts

@@ -0,0 +1,5 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { DudamelApiClient } from '@dudamel/mcp-common';
+import type { McpPeersConfig } from '../types.js';
+export declare function registerPeerTools(server: Pick<McpServer, 'registerTool'>, client: DudamelApiClient, config: McpPeersConfig): void;
+//# sourceMappingURL=peers.d.ts.map

package/dist/tools/peers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"peers.d.ts","sourceRoot":"","sources":["../../src/tools/peers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAG5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,IAAI,CAAC,SAAS,EAAE,cAAc,CAAC,EACvC,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,cAAc,GACrB,IAAI,CA0GN"}

package/dist/types.d.ts

@@ -0,0 +1,19 @@
+export interface McpPeersConfig {
+    apiUrl: string;
+    apiKey: string;
+    authScheme?: 'ApiKey' | 'Bearer';
+    /** From `DUDAMEL_MCP_MODE=readonly` — hides `send-message`. */
+    readOnly?: boolean;
+    /**
+     * The conversation this turn serves (`DUDAMEL_CONVERSATION_ID`, injected by the
+     * bridge). Sent as the async reply target — absent (a terminal, a workflow step) the
+     * result is recovered with `get-task` instead.
+     */
+    conversationId?: string;
+    /** `DUDAMEL_RESPONSE_TARGET` JSON — where the caller's turn is answering, captured so
+     *  the completion event can reach that channel later. */
+    responseTarget?: Record<string, unknown>;
+    /** `DUDAMEL_AGENT_CHAIN` JSON — the causal agent chain, forwarded for the loop guard. */
+    agentChain?: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IACjC,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;6DACyD;IACzD,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzC,yFAAyF;IACzF,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB"}

package/dist/util.d.ts

@@ -0,0 +1,2 @@
+export { jsonResult, errorResult } from '@dudamel/mcp-common';
+//# sourceMappingURL=util.d.ts.map

package/dist/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC"}

package/package.json

@@ -1,6 +1,45 @@
 {
   "name": "@dudamel/mcp-peers",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "2026.1104.1",
+  "description": "Dudamel Peers MCP — stdio client for messaging the dudamel agents of an org (A2A-shaped tasks) over its REST API.",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "dudamel-mcp-peers": "./dist/stdio-server.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agents-squad/dudamel.git",
+    "directory": "packages/mcp/peers"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.31.0",
+    "zod": "^3.24.4"
+  },
+  "devDependencies": {
+    "esbuild": "^0.25.0",
+    "@dudamel/mcp-common": "0.1.0",
+    "@dudamel/mcp-tool-contract": "0.1.0"
+  },
+  "scripts": {
+    "build": "esbuild src/stdio-server.ts src/index.ts --bundle --platform=node --target=node22 --format=esm --outdir=dist --external:@modelcontextprotocol/sdk --external:zod && tsc --emitDeclarationOnly",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "test": "vitest run --passWithNoTests",
+    "clean": "rm -rf dist"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.