@aipack-ai/multi-agent 1.0.2 → 1.1.0

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { Result, Tool, Request, Runtime, RuntimeOptions } from '@aipack-ai/agent';
+import { McpServerHost } from '@aipack-ai/mcp';
 
 /**
  * core/types.ts - 多Agent编排核心类型
@@ -450,7 +451,14 @@ interface MCPToolCallResult {
  *
  * // 处理工具调用
  * const result = await bridge.handleCall({ name: 'ma_run', arguments: { input: '...' } });
+ *
+ * // M3：经标准 stdio MCP Server 暴露（补齐传输层，供 Claude Desktop 等拉起）
+ * import { runStdioServer } from '@aipack-ai/mcp';
+ * await runStdioServer(bridge.toMcpServerHost());
  * ```
+ *
+ * M3 起，run/status 核心逻辑在 handleCall（legacy）与 asTools（统一路径）间共享，
+ * 避免与 packages/mcp 的协议实现重复。
  */
 declare class MCPBridge {
     private graph;
@@ -461,13 +469,46 @@ declare class MCPBridge {
         name: string;
         version: string;
     };
-    /** 列出所有可用 MCP 工具 */
+    /** 列出所有可用 MCP 工具（legacy 形状：MCPToolDefinition[]） */
     listTools(): MCPToolDefinition[];
-    /** 处理 MCP 工具调用 */
+    /** run 工具核心：执行图并序列化为 MCP 形状结果 */
+    private runTool;
+    /** status 工具核心：图执行状态序列化为 MCP 形状结果 */
+    private statusTool;
+    /** 处理 MCP 工具调用（legacy API，行为保持不变） */
     handleCall(request: MCPToolCallRequest): Promise<MCPToolCallResult>;
+    /**
+     * 将 AgentGraph 暴露为 agent 原生 `Tool[]`（JSON Schema 参数 + execute）。
+     * 可直接喂给 `@aipack-ai/mcp` 的 `createMcpServerHost({ tools })`，
+     * 再经 `runStdioServer` 拉起为标准 stdio MCP Server——补齐 MCPBridge
+     * 原本缺失的传输层（"由宿主环境负责实际的 MCP 传输" 这一缺口）。
+     *
+     * 工具 `${prefix}run` / `${prefix}status` 与 legacy `listTools()`/`handleCall()`
+     * 共享 `runTool` / `statusTool` 核心，语义一致。
+     */
+    asTools(): Tool[];
+    /**
+     * 构建一个 `McpServerHost`（来自 `@aipack-ai/mcp`），把本 AgentGraph 作为
+     * 标准 MCP Server 暴露。配合 `runStdioServer(host)` 即可经 stdin/stdout
+     * 服务外部 MCP 客户端（Claude Desktop / Cursor）。
+     *
+     * 与 legacy `handleCall()` 共享 `runTool` / `statusTool` 核心，保证语义一致。
+     */
+    toMcpServerHost(): McpServerHost;
 }
 /** 创建 MCPBridge */
 declare function createMCPBridge(graph: AgentGraph, opts?: MCPBridgeOpts): MCPBridge;
+/**
+ * 便捷工厂：从 AgentGraph 直接构建一个 `McpServerHost`（@aipack-ai/mcp），
+ * 供 `runStdioServer(host)` 拉起为标准 stdio MCP Server。
+ *
+ * ```typescript
+ * import { runStdioServer } from '@aipack-ai/mcp';
+ * const host = createMultiAgentMcpServerHost(graph, { serverName: 'my-graph' });
+ * await runStdioServer(host);
+ * ```
+ */
+declare function createMultiAgentMcpServerHost(graph: AgentGraph, opts?: MCPBridgeOpts): McpServerHost;
 
 /**
  * extensions/debug.ts - 可视化调试扩展
@@ -520,4 +561,4 @@ declare class GraphDebugger {
 /** 创建 GraphDebugger */
 declare function createDebugger(graph: AgentGraph): GraphDebugger;
 
-export { type AgentEdge, type AgentGraph, type AgentNode, type DebateOpts, type EventBus, type EventListener, GraphDebugger, type GraphExecutionState, type GraphTrace, MCPBridge, type MCPBridgeOpts, type MCPToolCallRequest, type MCPToolCallResult, type MCPToolDefinition, type MCPToolParameter, type MapReduceOpts, type MultiAgentEvent, type MultiAgentResult, type NodeExecutionState, type PipelineOpts, type RouterOpts, type ScheduleMode, type SharedContext, SimpleEventBus, SimpleToolRegistry, type SupervisorOpts, type ToolRegistry, type TraceStep, createAgentGraph, createDebate, createDebugger, createMCPBridge, createMapReduce, createPipeline, createRouter, createSharedContext, createSupervisor };
+export { type AgentEdge, type AgentGraph, type AgentNode, type DebateOpts, type EventBus, type EventListener, GraphDebugger, type GraphExecutionState, type GraphTrace, MCPBridge, type MCPBridgeOpts, type MCPToolCallRequest, type MCPToolCallResult, type MCPToolDefinition, type MCPToolParameter, type MapReduceOpts, type MultiAgentEvent, type MultiAgentResult, type NodeExecutionState, type PipelineOpts, type RouterOpts, type ScheduleMode, type SharedContext, SimpleEventBus, SimpleToolRegistry, type SupervisorOpts, type ToolRegistry, type TraceStep, createAgentGraph, createDebate, createDebugger, createMCPBridge, createMapReduce, createMultiAgentMcpServerHost, createPipeline, createRouter, createSharedContext, createSupervisor };

package/dist/index.js

@@ -1086,6 +1086,9 @@ var AgentRuntime = class _AgentRuntime {
     }
     return this;
   }
+  unregisterTool(name) {
+    return this._globalTools.delete(name);
+  }
   setModel(model) {
     this._model = model;
     return this;
@@ -3570,6 +3573,392 @@ function createMapReduce(mapper, reducer, opts) {
   return new MapReduceGraphImpl(mapper, reducer, opts);
 }
 
+// ../mcp/src/client/jsonrpc.ts
+var METHOD_NOT_FOUND = -32601;
+var INVALID_PARAMS = -32602;
+var INTERNAL_ERROR = -32603;
+function createNotification(method, params) {
+  const n = { jsonrpc: "2.0", method };
+  if (params !== void 0) n.params = params;
+  return n;
+}
+function createSuccessResponse(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+function createErrorResponse(id, code, message, data) {
+  const err = { jsonrpc: "2.0", id, error: { code, message } };
+  if (data !== void 0) err.error.data = data;
+  return err;
+}
+function hasOwn(o, k) {
+  return typeof o === "object" && o !== null && Object.prototype.hasOwnProperty.call(o, k);
+}
+function classify(obj) {
+  if (typeof obj !== "object" || obj === null) return null;
+  const o = obj;
+  if (o.jsonrpc !== "2.0") return null;
+  if (hasOwn(o, "result") || hasOwn(o, "error")) {
+    return o;
+  }
+  if (hasOwn(o, "method") && typeof o.method === "string") {
+    if (hasOwn(o, "id") && o.id !== null) return o;
+    if (!hasOwn(o, "id") || o.id === null) return o;
+  }
+  return null;
+}
+function isResponse(m) {
+  return "result" in m || "error" in m;
+}
+function isRequest(m) {
+  return !isResponse(m) && "id" in m && m.id !== null;
+}
+function isNotification(m) {
+  return !isResponse(m) && !("id" in m && m.id !== null);
+}
+
+// ../mcp/src/client/protocol.ts
+var MCP_PROTOCOL_VERSION = "2025-06-18";
+function createListChangedNotification() {
+  return createNotification("notifications/tools/list_changed");
+}
+function parseToolCallParams(params) {
+  const p = params ?? {};
+  return {
+    name: typeof p.name === "string" ? p.name : void 0,
+    arguments: p.arguments
+  };
+}
+function parseResourceReadParams(params) {
+  const p = params ?? {};
+  return { uri: typeof p.uri === "string" ? p.uri : void 0 };
+}
+function parsePromptGetParams(params) {
+  const p = params ?? {};
+  return {
+    name: typeof p.name === "string" ? p.name : void 0,
+    arguments: p.arguments
+  };
+}
+function createInitializeResult(serverInfo, capabilities) {
+  return {
+    protocolVersion: MCP_PROTOCOL_VERSION,
+    capabilities,
+    serverInfo
+  };
+}
+function buildToolsListResult(tools, nextCursor) {
+  const list = tools.map((t) => {
+    const out = { name: t.name };
+    if (t.description !== void 0) out.description = t.description;
+    out.inputSchema = t.inputSchema ?? { type: "object", properties: {} };
+    return out;
+  });
+  const r = { tools: list };
+  if (nextCursor) r.nextCursor = nextCursor;
+  return r;
+}
+function buildToolCallResult(content, isError) {
+  const r = { content: content.length ? content : [{ type: "text", text: "[empty result]" }] };
+  if (isError) r.isError = true;
+  return r;
+}
+function buildResourcesListResult(resources, nextCursor) {
+  const list = resources.map((r0) => {
+    const out = { uri: r0.uri };
+    if (r0.name !== void 0) out.name = r0.name;
+    if (r0.description !== void 0) out.description = r0.description;
+    if (r0.mimeType !== void 0) out.mimeType = r0.mimeType;
+    return out;
+  });
+  const r = { resources: list };
+  if (nextCursor) r.nextCursor = nextCursor;
+  return r;
+}
+function buildResourceReadResult(resource) {
+  const contents = { uri: resource.uri };
+  if (resource.mimeType !== void 0) contents.mimeType = resource.mimeType;
+  if (resource.text !== void 0) contents.text = resource.text;
+  else if (resource.blob !== void 0) contents.blob = resource.blob;
+  return { contents: [contents] };
+}
+function buildPromptsListResult(prompts, nextCursor) {
+  const list = prompts.map((p0) => {
+    const out = { name: p0.name };
+    if (p0.description !== void 0) out.description = p0.description;
+    if (p0.arguments !== void 0) out.arguments = p0.arguments;
+    return out;
+  });
+  const r = { prompts: list };
+  if (nextCursor) r.nextCursor = nextCursor;
+  return r;
+}
+function buildPromptGetResult(messages) {
+  return { messages: messages ?? [] };
+}
+function parseCreateMessageResult(payload) {
+  const r = payload ?? {};
+  const content = r.content ?? { type: "text", text: "" };
+  return {
+    role: "assistant",
+    content: typeof content.type === "string" ? content : { type: "text", text: "" },
+    model: typeof r.model === "string" ? r.model : "unknown",
+    stopReason: r.stopReason,
+    stopSequence: typeof r.stopSequence === "string" ? r.stopSequence : void 0,
+    usage: r.usage
+  };
+}
+
+// ../mcp/src/server/host.ts
+function mapAgentContentToMcp(blocks) {
+  const out = [];
+  for (const b of blocks) {
+    out.push(mapOneAgentBlock(b));
+  }
+  return out.length ? out : [{ type: "text", text: "[empty result]" }];
+}
+function mapOneAgentBlock(b) {
+  if (b.type === "text") {
+    const t = b;
+    return { type: "text", text: t.text };
+  }
+  if (b.type === "image") {
+    const img = b;
+    if (typeof img.data === "string" && typeof img.mimeType === "string") {
+      return { type: "image", data: img.data, mimeType: img.mimeType };
+    }
+    return { type: "text", text: "[image: missing data/mimeType]" };
+  }
+  return { type: "text", text: JSON.stringify(b) };
+}
+function toolResultToMcpCallResult(result) {
+  const isError = isToolResultError(result);
+  return { content: mapAgentContentToMcp(result.content ?? []), isError: isError ? true : void 0 };
+}
+function isToolResultError(result) {
+  const d = result.details;
+  if (d && typeof d === "object" && "error" in d) {
+    const e = d.error;
+    return !!e || typeof e === "string";
+  }
+  return false;
+}
+var McpServerHost = class {
+  serverInfo;
+  toolsResolver;
+  resourcesResolver;
+  promptsResolver;
+  authorize;
+  toolTimeoutMs;
+  onNotification;
+  samplingEnabled;
+  outboundRequest;
+  capabilities;
+  constructor(options) {
+    this.serverInfo = { name: options.name, version: options.version ?? "0.1.0" };
+    this.toolsResolver = typeof options.tools === "function" ? options.tools : () => options.tools;
+    if (options.resources) {
+      this.resourcesResolver = typeof options.resources === "function" ? options.resources : () => options.resources;
+    }
+    if (options.prompts) {
+      this.promptsResolver = typeof options.prompts === "function" ? options.prompts : () => options.prompts;
+    }
+    this.authorize = options.authorize;
+    this.toolTimeoutMs = options.toolTimeoutMs;
+    this.onNotification = options.onNotification;
+    this.outboundRequest = options.onOutboundRequest;
+    this.samplingEnabled = options.sampling === true || !!options.onOutboundRequest;
+    this.capabilities = this.computeCapabilities();
+  }
+  getServerInfo() {
+    return { ...this.serverInfo };
+  }
+  getCapabilities() {
+    return { ...this.capabilities };
+  }
+  computeCapabilities() {
+    const caps = { tools: {} };
+    if (this.resourcesResolver) caps.resources = {};
+    if (this.promptsResolver) caps.prompts = {};
+    if (this.samplingEnabled) caps.sampling = {};
+    return caps;
+  }
+  /** 主动通知客户端工具列表已变更 */
+  notifyToolsListChanged() {
+    this.onNotification?.(createListChangedNotification());
+  }
+  /**
+   * 注入出站请求通道（由传输层如 stdio-runner 调用）：写入 JSON-RPC 请求
+   * 并关联响应。注入后 `sampleLLM` 可向外部 client 请求 LLM 补全。
+   */
+  setOutboundRequest(fn) {
+    this.outboundRequest = fn;
+    if (!this.samplingEnabled) {
+      this.samplingEnabled = true;
+      this.capabilities = this.computeCapabilities();
+    }
+  }
+  /**
+   * 经出站通道向外部 client 请求 LLM 补全（sampling/createMessage）。
+   * 需传输层（stdio-runner）已注入出站通道；未注入则抛错。
+   */
+  async sampleLLM(params) {
+    if (!this.outboundRequest) {
+      throw new Error("sampling unavailable: outbound request channel not attached");
+    }
+    const raw = await this.outboundRequest("sampling/createMessage", params);
+    return parseCreateMessageResult(raw);
+  }
+  /**
+   * 处理一条入站 JSON-RPC 消息。
+   * - 请求 → 返回响应（JsonRpcResponse）
+   * - 通知 → 返回 null（不回写）
+   * - 响应 / 非法消息 → 返回 null
+   */
+  async handleRequest(input) {
+    const msg = classify(input);
+    if (!msg) return null;
+    if (isResponse(msg)) return null;
+    if (isNotification(msg)) {
+      return null;
+    }
+    if (!isRequest(msg)) return null;
+    return this.onRequest(msg);
+  }
+  async onRequest(req) {
+    try {
+      switch (req.method) {
+        case "initialize":
+          return createSuccessResponse(
+            req.id,
+            createInitializeResult(this.serverInfo, this.capabilities)
+          );
+        case "notifications/initialized":
+          return createSuccessResponse(req.id, {});
+        case "tools/list":
+          return createSuccessResponse(
+            req.id,
+            buildToolsListResult(await this.toToolInfos(await this.toolsResolver()))
+          );
+        case "tools/call":
+          return createSuccessResponse(req.id, await this.handleToolCall(req));
+        case "ping":
+          return createSuccessResponse(req.id, {});
+        case "resources/list":
+          if (!this.resourcesResolver) break;
+          return createSuccessResponse(
+            req.id,
+            buildResourcesListResult(await this.resourcesResolver())
+          );
+        case "resources/read": {
+          if (!this.resourcesResolver) break;
+          const { uri } = parseResourceReadParams(req.params);
+          if (!uri) return createErrorResponse(req.id, INVALID_PARAMS, "resources/read requires uri");
+          const found = (await this.resourcesResolver()).find((r) => r.uri === uri);
+          if (!found) return createErrorResponse(req.id, INVALID_PARAMS, `resource not found: ${uri}`);
+          return createSuccessResponse(req.id, buildResourceReadResult(found));
+        }
+        case "prompts/list":
+          if (!this.promptsResolver) break;
+          return createSuccessResponse(
+            req.id,
+            buildPromptsListResult(await this.promptsResolver())
+          );
+        case "prompts/get": {
+          if (!this.promptsResolver) break;
+          const { name } = parsePromptGetParams(req.params);
+          if (!name) return createErrorResponse(req.id, INVALID_PARAMS, "prompts/get requires name");
+          const found = (await this.promptsResolver()).find((p) => p.name === name);
+          if (!found) return createErrorResponse(req.id, INVALID_PARAMS, `prompt not found: ${name}`);
+          return createSuccessResponse(req.id, buildPromptGetResult(found.messages ?? []));
+        }
+        default:
+          break;
+      }
+      return createErrorResponse(
+        req.id,
+        METHOD_NOT_FOUND,
+        `method not found: ${req.method}`
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return createErrorResponse(req.id, INTERNAL_ERROR, message);
+    }
+  }
+  async handleToolCall(req) {
+    const { name, arguments: args } = parseToolCallParams(req.params);
+    if (!name) {
+      return buildToolCallResult(
+        [{ type: "text", text: "tools/call requires name" }],
+        true
+      );
+    }
+    const tools = await this.toolsResolver();
+    const tool = tools.find((t) => t.name === name);
+    if (!tool) {
+      return buildToolCallResult(
+        [{ type: "text", text: `unknown tool: ${name}` }],
+        true
+      );
+    }
+    const prepared = tool.prepareArguments ? tool.prepareArguments(args) : args;
+    if (this.authorize) {
+      const allowed = await this.authorize({
+        toolName: tool.name,
+        permissions: tool.permissions ?? [],
+        args: prepared
+      });
+      if (!allowed) {
+        return buildToolCallResult(
+          [{ type: "text", text: `permission denied: ${tool.name}` }],
+          true
+        );
+      }
+    }
+    let result;
+    try {
+      result = await this.callWithTimeout(tool, prepared);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return buildToolCallResult(
+        [{ type: "text", text: `tool execution failed: ${message}` }],
+        true
+      );
+    }
+    const mapped = toolResultToMcpCallResult(result);
+    return buildToolCallResult(mapped.content, mapped.isError);
+  }
+  callWithTimeout(tool, args) {
+    if (!this.toolTimeoutMs) return tool.execute("mcp", args);
+    return new Promise((resolve, reject) => {
+      const ac = new AbortController();
+      const timer = setTimeout(() => {
+        ac.abort();
+        reject(new Error(`tools/call timeout: ${tool.name} (${this.toolTimeoutMs}ms)`));
+      }, this.toolTimeoutMs);
+      tool.execute("mcp", args, ac.signal).then(
+        (r) => {
+          clearTimeout(timer);
+          resolve(r);
+        },
+        (e) => {
+          clearTimeout(timer);
+          reject(e);
+        }
+      );
+    });
+  }
+  toToolInfos(tools) {
+    return tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: t.parameters
+    }));
+  }
+};
+function createMcpServerHost(options) {
+  return new McpServerHost(options);
+}
+
 // extensions/mcp-bridge.ts
 var MCPBridge = class {
   graph;
@@ -3589,7 +3978,7 @@ var MCPBridge = class {
       version: this.opts.serverVersion
     };
   }
-  /** 列出所有可用 MCP 工具 */
+  /** 列出所有可用 MCP 工具（legacy 形状：MCPToolDefinition[]） */
   listTools() {
     const prefix = this.opts.toolPrefix;
     return [
@@ -3612,53 +4001,62 @@ var MCPBridge = class {
       }
     ];
   }
-  /** 处理 MCP 工具调用 */
+  // ─── 核心逻辑（handleCall 与 asTools 共享，单一来源）──────────────
+  /** run 工具核心：执行图并序列化为 MCP 形状结果 */
+  async runTool(input) {
+    const inputText = input;
+    if (!inputText) {
+      return {
+        isError: true,
+        content: [{ type: "text", text: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570: input" }]
+      };
+    }
+    const result = await this.graph.run(inputText);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: result.success,
+            content: result.content,
+            lastAgentId: result.lastAgentId,
+            stepsCompleted: result.stepsCompleted,
+            stopReason: result.stopReason,
+            totalUsage: result.totalUsage
+          }, null, 2)
+        }
+      ]
+    };
+  }
+  /** status 工具核心：图执行状态序列化为 MCP 形状结果 */
+  statusTool() {
+    const state = this.graph.getState();
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            currentAgentId: state.currentAgentId,
+            stepsCompleted: state.stepsCompleted,
+            finished: state.finished,
+            error: state.error,
+            nodeStates: Object.fromEntries(state.nodeStates)
+          }, null, 2)
+        }
+      ]
+    };
+  }
+  /** 处理 MCP 工具调用（legacy API，行为保持不变） */
   async handleCall(request) {
     const prefix = this.opts.toolPrefix;
-    const runTool = `${prefix}run`;
-    const statusTool = `${prefix}status`;
+    const runToolName = `${prefix}run`;
+    const statusToolName = `${prefix}status`;
     try {
-      if (request.name === runTool) {
-        const input = request.arguments.input;
-        if (!input) {
-          return {
-            isError: true,
-            content: [{ type: "text", text: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570: input" }]
-          };
-        }
-        const result = await this.graph.run(input);
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                success: result.success,
-                content: result.content,
-                lastAgentId: result.lastAgentId,
-                stepsCompleted: result.stepsCompleted,
-                stopReason: result.stopReason,
-                totalUsage: result.totalUsage
-              }, null, 2)
-            }
-          ]
-        };
+      if (request.name === runToolName) {
+        return await this.runTool(request.arguments.input);
       }
-      if (request.name === statusTool) {
-        const state = this.graph.getState();
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                currentAgentId: state.currentAgentId,
-                stepsCompleted: state.stepsCompleted,
-                finished: state.finished,
-                error: state.error,
-                nodeStates: Object.fromEntries(state.nodeStates)
-              }, null, 2)
-            }
-          ]
-        };
+      if (request.name === statusToolName) {
+        return this.statusTool();
       }
       return {
         isError: true,
@@ -3676,10 +4074,70 @@ var MCPBridge = class {
       };
     }
   }
+  // ─── M3 统一：暴露为 agent 原生 Tool[]，接入 McpServerHost / stdio 传输 ──
+  /**
+   * 将 AgentGraph 暴露为 agent 原生 `Tool[]`（JSON Schema 参数 + execute）。
+   * 可直接喂给 `@aipack-ai/mcp` 的 `createMcpServerHost({ tools })`，
+   * 再经 `runStdioServer` 拉起为标准 stdio MCP Server——补齐 MCPBridge
+   * 原本缺失的传输层（"由宿主环境负责实际的 MCP 传输" 这一缺口）。
+   *
+   * 工具 `${prefix}run` / `${prefix}status` 与 legacy `listTools()`/`handleCall()`
+   * 共享 `runTool` / `statusTool` 核心，语义一致。
+   */
+  asTools() {
+    const prefix = this.opts.toolPrefix;
+    return [
+      {
+        name: `${prefix}run`,
+        description: "\u8FD0\u884C\u591AAgent\u7F16\u6392\u56FE\uFF0C\u4F20\u5165\u7528\u6237\u8F93\u5165\uFF0C\u8FD4\u56DE\u6267\u884C\u7ED3\u679C",
+        parameters: {
+          type: "object",
+          properties: { input: { type: "string", description: "\u7528\u6237\u8F93\u5165\u6587\u672C" } },
+          required: ["input"]
+        },
+        permissions: [],
+        execute: async (_id, args) => {
+          const input = args?.input;
+          return toToolResult(await this.runTool(input));
+        }
+      },
+      {
+        name: `${prefix}status`,
+        description: "\u83B7\u53D6\u5F53\u524D\u56FE\u6267\u884C\u72B6\u6001",
+        parameters: { type: "object", properties: {} },
+        permissions: [],
+        execute: async () => toToolResult(this.statusTool())
+      }
+    ];
+  }
+  /**
+   * 构建一个 `McpServerHost`（来自 `@aipack-ai/mcp`），把本 AgentGraph 作为
+   * 标准 MCP Server 暴露。配合 `runStdioServer(host)` 即可经 stdin/stdout
+   * 服务外部 MCP 客户端（Claude Desktop / Cursor）。
+   *
+   * 与 legacy `handleCall()` 共享 `runTool` / `statusTool` 核心，保证语义一致。
+   */
+  toMcpServerHost() {
+    return createMcpServerHost({
+      name: this.opts.serverName,
+      version: this.opts.serverVersion,
+      tools: this.asTools()
+    });
+  }
 };
+function toToolResult(r) {
+  const isError = r.isError === true;
+  return {
+    content: r.content,
+    details: isError ? { error: r.content[0]?.text ?? "error" } : void 0
+  };
+}
 function createMCPBridge(graph, opts) {
   return new MCPBridge(graph, opts);
 }
+function createMultiAgentMcpServerHost(graph, opts) {
+  return new MCPBridge(graph, opts).toMcpServerHost();
+}
 
 // extensions/debug.ts
 var GraphDebugger = class {
@@ -3847,6 +4305,7 @@ export {
   createDebugger,
   createMCPBridge,
   createMapReduce,
+  createMultiAgentMcpServerHost,
   createPipeline,
   createRouter,
   createSharedContext,