第 57 章：MCP 的双面

// 请求
{ "jsonrpc": "2.0", "id": 1, "method": "tools/list", "params": {} }

// 响应
{ "jsonrpc": "2.0", "id": 1, "result": { "tools": [...] } }

// 错误
{ "jsonrpc": "2.0", "id": 1, "error": { "code": -32601, "message": "Method not found" } }

// 通知（无 id，无响应）
{ "jsonrpc": "2.0", "method": "notifications/initialized" }

// → src/my-agent/mcp/server.ts
import { createInterface } from "node:readline";

interface McpTool {
  name: string;
  description: string;
  inputSchema: {
    type: "object";
    properties: Record<string, unknown>;
    required?: string[];
  };
  handler: (args: Record<string, unknown>) => Promise<McpToolResult>;
}

interface McpToolResult {
  content: Array<{ type: "text"; text: string }>;
  isError?: boolean;
}

export class McpServer {
  private tools = new Map<string, McpTool>();
  private initialized = false;

  registerTool(tool: McpTool): void {
    this.tools.set(tool.name, tool);
  }

  async start(): Promise<void> {
    const rl = createInterface({ input: process.stdin });

    for await (const line of rl) {
      if (!line.trim()) continue;
      const message = JSON.parse(line);
      await this.handleMessage(message);
    }
  }

  private async handleMessage(msg: JsonRpcMessage): Promise<void> {
    switch (msg.method) {
      case "initialize":
        this.send({
          jsonrpc: "2.0", id: msg.id,
          result: {
            protocolVersion: "2025-11-25",
            capabilities: {
              tools: { listChanged: false },
            },
            serverInfo: {
              name: "my-agent-mcp-server",
              version: "1.0.0",
            },
          },
        });
        break;

      case "notifications/initialized":
        this.initialized = true;
        break;

      case "tools/list":
        this.send({
          jsonrpc: "2.0", id: msg.id,
          result: {
            tools: Array.from(this.tools.values()).map(t => ({
              name: t.name,
              description: t.description,
              inputSchema: t.inputSchema,
            })),
          },
        });
        break;

      case "tools/call":
        const tool = this.tools.get(msg.params.name);
        if (!tool) {
          this.send({
            jsonrpc: "2.0", id: msg.id,
            error: { code: -32602, message: `Unknown tool: ${msg.params.name}` },
          });
          return;
        }
        try {
          const result = await tool.handler(msg.params.arguments);
          this.send({ jsonrpc: "2.0", id: msg.id, result });
        } catch (err) {
          this.send({
            jsonrpc: "2.0", id: msg.id,
            result: {
              content: [{ type: "text", text: `Error: ${(err as Error).message}` }],
              isError: true,
            },
          });
        }
        break;

      default:
        this.send({
          jsonrpc: "2.0", id: msg.id,
          error: { code: -32601, message: `Method not found: ${msg.method}` },
        });
    }
  }

  private send(message: JsonRpcMessage): void {
    process.stdout.write(JSON.stringify(message) + "\\n");
  }
}

// → src/my-agent/mcp/client.ts
import { spawn, ChildProcess } from "node:child_process";
import { createInterface } from "node:readline";

export class McpClient {
  private process: ChildProcess;
  private requestId = 0;
  private pending = new Map<number, {
    resolve: (value: unknown) => void;
    reject: (error: Error) => void;
  }>();
  private tools: McpToolInfo[] = [];

  constructor(command: string, args: string[]) {
    this.process = spawn(command, args, {
      stdio: ["pipe", "pipe", "inherit"],  // stdin, stdout, stderr
    });

    const rl = createInterface({ input: this.process.stdout! });
    rl.on("line", (line) => {
      if (!line.trim()) return;
      const msg = JSON.parse(line);
      if (msg.id && this.pending.has(msg.id)) {
        const { resolve, reject } = this.pending.get(msg.id)!;
        this.pending.delete(msg.id);
        if (msg.error) reject(new Error(msg.error.message));
        else resolve(msg.result);
      }
    });
  }

  async initialize(): Promise<void> {
    const result = await this.sendRequest("initialize", {
      protocolVersion: "2025-11-25",
      capabilities: {},
      clientInfo: { name: "my-agent", version: "1.0.0" },
    }) as InitializeResult;

    // 发送 initialized 通知
    this.sendNotification("notifications/initialized");
  }

  async listTools(): Promise<McpToolInfo[]> {
    const result = await this.sendRequest("tools/list", {}) as ListToolsResult;
    this.tools = result.tools;
    return this.tools;
  }

  async callTool(name: string, args: Record<string, unknown>): Promise<McpToolResult> {
    return this.sendRequest("tools/call", {
      name,
      arguments: args,
    }) as Promise<McpToolResult>;
  }

  private sendRequest(method: string, params: unknown): Promise<unknown> {
    const id = ++this.requestId;
    const message = { jsonrpc: "2.0", id, method, params };
    this.process.stdin!.write(JSON.stringify(message) + "\\n");

    return new Promise((resolve, reject) => {
      this.pending.set(id, { resolve, reject });
      // 5 秒超时
      setTimeout(() => {
        if (this.pending.has(id)) {
          this.pending.delete(id);
          reject(new Error(`Request ${method} timed out`));
        }
      }, 5000);
    });
  }

  private sendNotification(method: string, params?: unknown): void {
    const message = { jsonrpc: "2.0", method, params };
    this.process.stdin!.write(JSON.stringify(message) + "\\n");
  }

  close(): void {
    this.process.kill();
  }
}

// → src/my-agent/mcp/bridge.ts
export function mcpToolsToApiTools(mcpTools: McpToolInfo[]): ToolDefinition[] {
  return mcpTools.map(t => ({
    name: `mcp__${t.name}`,
    description: t.description,
    input_schema: t.inputSchema,
  }));
}

export async function executeMcpTool(
  client: McpClient,
  toolName: string,    // 已经是 mcp__ 前缀的
  args: Record<string, unknown>
): Promise<ToolResultBlock> {
  const realName = toolName.replace("mcp__", "");
  const result = await client.callTool(realName, args);

  return {
    type: "tool_result",
    tool_use_id: "",  // 调用者填充
    content: result.content.map(c => c.text).join("\\n"),
    is_error: result.isError,
  };
}

// → src/my-agent/mcp/http-client.ts
export class HttpMcpClient {
  constructor(
    private baseUrl: string,
    private sessionId?: string
  ) {}

  async initialize(): Promise<void> {
    const response = await fetch(this.baseUrl, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Accept": "application/json, text/event-stream",
        "MCP-Protocol-Version": "2025-11-25",
      },
      body: JSON.stringify({
        jsonrpc: "2.0", id: 1, method: "initialize",
        params: {
          protocolVersion: "2025-11-25",
          capabilities: {},
          clientInfo: { name: "my-agent", version: "1.0.0" },
        },
      }),
    });

    const result = await response.json();
    this.sessionId = response.headers.get("MCP-Session-Id") ?? undefined;

    // 发送 initialized（带上 session ID）
    await this.post({
      jsonrpc: "2.0",
      method: "notifications/initialized",
    });
  }

  private async post(message: JsonRpcMessage): Promise<Response> {
    const headers: Record<string, string> = {
      "Content-Type": "application/json",
      "Accept": "application/json, text/event-stream",
      "MCP-Protocol-Version": "2025-11-25",
    };
    if (this.sessionId) {
      headers["MCP-Session-Id"] = this.sessionId;
    }
    return fetch(this.baseUrl, {
      method: "POST",
      headers,
      body: JSON.stringify(message),
    });
  }

  async close(): Promise<void> {
    if (this.sessionId) {
      await fetch(this.baseUrl, {
        method: "DELETE",
        headers: { "MCP-Session-Id": this.sessionId },
      });
    }
  }
}