MCP 集成

export type McpResponse =  | { ok: true; result: unknown }  | { ok: false; error: { code: number; message: string } };export interface McpTransport {  request(method: string, params: unknown, signal: AbortSignal): Promise<McpResponse>;  close(): Promise<void>;}

export class FakeTransport implements McpTransport {  readonly calls: { method: string; params: unknown }[] = [];  closed = false;  constructor(private readonly handlers: Record<string, (params: unknown) => McpResponse>) {}  async request(method: string, params: unknown, signal: AbortSignal): Promise<McpResponse> {    this.calls.push({ method, params });    if (signal.aborted) return { ok: false, error: { code: -32_800, message: "cancelled" } };    const handler = this.handlers[method];    if (!handler) return { ok: false, error: { code: -32_601, message: "method_not_found" } };    return handler(params);  }  async close(): Promise<void> {    this.closed = true;  }}

export interface McpToolDescriptor {  server: string;  remoteName: string;  description: string;  inputSchema: unknown;}export const SUPPORTED_PROTOCOL_VERSIONS = ["2025-06-18", "2025-03-26"] as const;/** context 中的 signal 与 timeoutMs 由调用方注入，不来自服务端。 */export async function initializeServer(  transport: McpTransport,  context: McpRequestContext,): Promise<{ protocolVersion: string }> {  const request = {    protocolVersion: "2025-06-18",    capabilities: { tools: {} },    clientInfo: { name: "agent-from-scratch", version: "0.1.0" },  };  const response = await transport.request("initialize", request, context.signal);  if (!response.ok) throw new Error("mcp_initialize_failed: " + response.error.message);  const protocolVersion = asRecord(response.result).protocolVersion;  if (typeof protocolVersion !== "string" || !SUPPORTED_PROTOCOL_VERSIONS.some((v) => v === protocolVersion)) {    throw new Error("unsupported_protocol_version: " + String(protocolVersion));  }  await transport.request("notifications/initialized", {}, context.signal);  return { protocolVersion };}export async function listTools(  server: string,  transport: McpTransport,  context: McpRequestContext,): Promise<McpToolDescriptor[]> {  const response = await transport.request("tools/list", {}, context.signal);  if (!response.ok) throw new Error("mcp_tools_list_failed: " + response.error.message);  const tools = asRecord(response.result).tools;  if (!Array.isArray(tools)) throw new Error("invalid_tools_list");  return tools.map((tool) => {    const record = asRecord(tool);    if (typeof record.name !== "string" || !record.name) throw new Error("invalid_tool_name");    if (typeof record.description !== "string") throw new Error("invalid_tool_description");    return { server, remoteName: record.name, description: record.description, inputSchema: record.inputSchema };  });}

import { z, type ZodType } from "zod";const ALLOWED_KEYWORDS = new Set([  "type", "properties", "required", "additionalProperties", "items", "enum", "const",  "description", "default", "minimum", "maximum", "minLength", "maxLength", "oneOf", "anyOf",]);export function toLocalSchema(inputSchema: unknown): { schema: ZodType; parameters: Record<string, unknown> } {  if (!isSupportedJsonSchema(inputSchema)) throw new Error("unsupported_input_schema");  const schema = z.fromJSONSchema(inputSchema);  const { $schema: _, ...parameters } = z.toJSONSchema(schema);  return { schema, parameters };}export function isSupportedJsonSchema(value: unknown): boolean {  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;  return Object.keys(value).every((keyword) => ALLOWED_KEYWORDS.has(keyword));}

const tool = defineTool({  name: "mcp__" + descriptor.server + "__" + descriptor.remoteName,  description: descriptor.description,  schema,  effect: "external",  execute: (input, context) => callRemoteTool(descriptor, input, context),});

const prepared = tool.prepare(rawInput);const decision = authorize(tool, prepared.input, policyContext);if (decision.type === "deny") return observation(callId, { ok: false, error: "policy_denied", reason: decision.reason });if (decision.type === "ask" && !(await store.consumeApprovalGrant(state.runId, decision.request.actionDigest))) {  await store.saveApprovalRequest(state.runId, decision.request);  return { type: "waiting", requestId: decision.request.id, reason: "approval_required" };}return executeInSandbox(() => prepared.execute(toolContext), { network: policyContext.network });

async function callRemoteTool(  descriptor: McpToolDescriptor,  input: unknown,  context: ToolContext,): Promise<unknown> {  const response = await transport.request(    "tools/call",    { name: descriptor.remoteName, arguments: input },    context.signal,  );  if (!response.ok) return { ok: false, error: "mcp_error", code: response.error.code };  const result = asRecord(response.result);  if (result.isError === true) return { ok: false, error: "mcp_tool_error", content: result.content };  return { ok: true, content: result.content };}

it("maps remote tools into namespaced external tools", async () => {  const transport = new FakeTransport({    initialize: () => ok({ protocolVersion: "2025-06-18" }),    "tools/list": () => ok({ tools: [{ name: "search", description: "Docs search", inputSchema: OBJECT_SCHEMA }] }),  });  await initializeServer(transport, context);  const tools = await listTools("docs", transport, context);  const registry = new ToolRegistry();  registerMcpTools(registry, tools.map(toLocalTool));  expect(registry.names()).toEqual(["mcp__docs__search"]);  expect(registry.get("mcp__docs__search")?.effect).toBe("external");  expect(transport.calls.map((call) => call.method)).toEqual(["initialize", "notifications/initialized", "tools/list"]);});