@faapi/mcp 0.0.0-canary.0

package/dist/index.js

@@ -0,0 +1,1414 @@
+// src/mcpServer.ts
+import { z, toJSONSchema } from "zod";
+
+// src/jsonRpc.ts
+var ErrorCode = {
+  // JSON-RPC 标准错误码
+  ParseError: -32700,
+  InvalidRequest: -32600,
+  MethodNotFound: -32601,
+  InvalidParams: -32602,
+  InternalError: -32603,
+  // MCP 扩展错误码
+  ConnectionClosed: -32e3,
+  RequestTimeout: -32001
+};
+function isRequest(msg) {
+  return "method" in msg && "id" in msg && !("result" in msg) && !("error" in msg);
+}
+function isNotification(msg) {
+  return "method" in msg && !("id" in msg);
+}
+function isResultResponse(msg) {
+  return "result" in msg && "id" in msg;
+}
+function isErrorResponse(msg) {
+  return "error" in msg && "id" in msg;
+}
+function createResultResponse(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+function createErrorResponse(id, code, message, data) {
+  const error = { code, message };
+  if (data !== void 0) error.data = data;
+  return { jsonrpc: "2.0", id, error };
+}
+function parseJsonRpcMessage(data) {
+  if (Array.isArray(data)) {
+    if (data.length === 0) {
+      throw new JsonRpcParseError("Invalid Request: empty batch");
+    }
+    return data.map((item) => parseSingleMessage(item));
+  }
+  return [parseSingleMessage(data)];
+}
+var JsonRpcParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "JsonRpcParseError";
+  }
+};
+function parseSingleMessage(data) {
+  if (typeof data !== "object" || data === null) {
+    throw new JsonRpcParseError("Invalid Request: not an object");
+  }
+  const obj = data;
+  if (obj.jsonrpc !== "2.0") {
+    throw new JsonRpcParseError('Invalid Request: jsonrpc must be "2.0"');
+  }
+  if (typeof obj.method === "string" && (typeof obj.id === "string" || typeof obj.id === "number")) {
+    return {
+      jsonrpc: "2.0",
+      id: obj.id,
+      method: obj.method,
+      ...obj.params !== void 0 && { params: obj.params }
+    };
+  }
+  if (typeof obj.method === "string" && obj.id === void 0) {
+    return {
+      jsonrpc: "2.0",
+      method: obj.method,
+      ...obj.params !== void 0 && { params: obj.params }
+    };
+  }
+  if ("result" in obj && (typeof obj.id === "string" || typeof obj.id === "number")) {
+    return {
+      jsonrpc: "2.0",
+      id: obj.id,
+      result: obj.result
+    };
+  }
+  if ("error" in obj && obj.error !== null && typeof obj.error === "object") {
+    return {
+      jsonrpc: "2.0",
+      id: obj.id ?? null,
+      error: obj.error
+    };
+  }
+  throw new JsonRpcParseError("Invalid Request: unknown message shape");
+}
+
+// src/session.ts
+import { randomUUID } from "crypto";
+var LOGGING_LEVEL_ORDER = {
+  debug: 10,
+  info: 20,
+  notice: 30,
+  warning: 40,
+  error: 50,
+  critical: 60,
+  alert: 70,
+  emergency: 80
+};
+var DEFAULT_TTL = 30 * 60 * 1e3;
+var SessionManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  ttl;
+  constructor(ttl = DEFAULT_TTL) {
+    this.ttl = ttl;
+  }
+  /** 是否启用 TTL 过期检查(ttl > 0) */
+  get ttlEnabled() {
+    return this.ttl > 0;
+  }
+  /** 创建新会话，返回 session 对象 */
+  create() {
+    if (this.ttlEnabled) this.cleanupExpired();
+    const now = Date.now();
+    const session = {
+      id: randomUUID(),
+      initialized: false,
+      protocolVersion: "",
+      createdAt: now,
+      lastActivity: now,
+      loggingLevel: "info",
+      subscribers: /* @__PURE__ */ new Set(),
+      subscribedResources: /* @__PURE__ */ new Set()
+    };
+    this.sessions.set(session.id, session);
+    return session;
+  }
+  /** 按 ID 获取会话（更新最后活动时间，过期返回 undefined） */
+  get(id) {
+    const session = this.sessions.get(id);
+    if (!session) return void 0;
+    if (this.ttlEnabled && Date.now() - session.lastActivity > this.ttl) {
+      this.closeSubscribers(session);
+      this.sessions.delete(id);
+      return void 0;
+    }
+    session.lastActivity = Date.now();
+    return session;
+  }
+  /** 是否存在（不更新活动时间，过期会话返回 false） */
+  has(id) {
+    const session = this.sessions.get(id);
+    if (!session) return false;
+    if (this.ttlEnabled && Date.now() - session.lastActivity > this.ttl) {
+      this.closeSubscribers(session);
+      this.sessions.delete(id);
+      return false;
+    }
+    return true;
+  }
+  /** 销毁会话(关闭所有 SSE 订阅者) */
+  delete(id) {
+    const session = this.sessions.get(id);
+    if (session) {
+      this.closeSubscribers(session);
+    }
+    return this.sessions.delete(id);
+  }
+  /** 当前会话数（含可能尚未清理的过期会话） */
+  get size() {
+    return this.sessions.size;
+  }
+  /** 获取所有 session ID 列表(用于全局广播通知) */
+  allSessionIds() {
+    return [...this.sessions.keys()];
+  }
+  /** 清空所有会话 */
+  clear() {
+    for (const session of this.sessions.values()) {
+      this.closeSubscribers(session);
+    }
+    this.sessions.clear();
+  }
+  /** 注册 SSE 订阅者到 session */
+  addSubscriber(sessionId, controller) {
+    const session = this.get(sessionId);
+    if (!session) return void 0;
+    const subscriber = { controller, sessionId };
+    session.subscribers.add(subscriber);
+    return subscriber;
+  }
+  /** 注销 SSE 订阅者 */
+  removeSubscriber(subscriber) {
+    const session = this.sessions.get(subscriber.sessionId);
+    if (session) {
+      session.subscribers.delete(subscriber);
+    }
+  }
+  /** 向 session 的所有订阅者推送 SSE 数据 */
+  broadcastToSession(sessionId, data) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    const encoder = new TextEncoder();
+    for (const sub of session.subscribers) {
+      try {
+        sub.controller.enqueue(encoder.encode(data));
+      } catch {
+        session.subscribers.delete(sub);
+      }
+    }
+  }
+  /** 判断指定级别的日志是否应该推送(>= session.loggingLevel) */
+  shouldLog(sessionId, level) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return false;
+    return LOGGING_LEVEL_ORDER[level] >= LOGGING_LEVEL_ORDER[session.loggingLevel];
+  }
+  /** 添加资源订阅(将 uri 加入 session.subscribedResources) */
+  subscribeResource(sessionId, uri) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return false;
+    session.subscribedResources.add(uri);
+    return true;
+  }
+  /** 取消资源订阅(从 session.subscribedResources 移除 uri) */
+  unsubscribeResource(sessionId, uri) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return false;
+    session.subscribedResources.delete(uri);
+    return true;
+  }
+  /** 找出所有订阅了指定 URI 的 session id 列表 */
+  findSubscribersOfUri(uri) {
+    const result = [];
+    for (const session of this.sessions.values()) {
+      if (session.subscribedResources.has(uri)) {
+        result.push(session.id);
+      }
+    }
+    return result;
+  }
+  /** 关闭 session 的所有订阅者(用于 session 销毁/过期) */
+  closeSubscribers(session) {
+    for (const sub of session.subscribers) {
+      try {
+        sub.controller.close();
+      } catch {
+      }
+    }
+    session.subscribers.clear();
+  }
+  /** 清理所有过期会话 */
+  cleanupExpired() {
+    if (!this.ttlEnabled) return;
+    const now = Date.now();
+    for (const [id, session] of this.sessions) {
+      if (now - session.lastActivity > this.ttl) {
+        this.closeSubscribers(session);
+        this.sessions.delete(id);
+      }
+    }
+  }
+};
+
+// src/mcpServer.ts
+var PROTOCOL_VERSION = "2025-06-18";
+var SUPPORTED_PROTOCOL_VERSIONS = ["2025-06-18", "2025-03-26"];
+var BUILTIN_METHODS = /* @__PURE__ */ new Set([
+  "initialize",
+  "ping",
+  "notifications/initialized",
+  "notifications/cancelled",
+  "tools/list",
+  "tools/call",
+  "resources/list",
+  "resources/read",
+  "resources/templates/list",
+  "resources/subscribe",
+  "resources/unsubscribe",
+  "prompts/list",
+  "prompts/get",
+  "logging/setLevel",
+  "completion/complete"
+]);
+var DEFAULT_PAGE_SIZE = 100;
+function encodeCursor(offset) {
+  return Buffer.from(String(offset)).toString("base64");
+}
+function decodeCursor(cursor) {
+  const decoded = Buffer.from(cursor, "base64").toString("utf-8");
+  const offset = Number.parseInt(decoded, 10);
+  if (!Number.isFinite(offset) || offset < 0 || decoded !== String(offset)) {
+    throw new Error(`Invalid cursor: ${cursor}`);
+  }
+  return offset;
+}
+function paginate(items, cursor, pageSize) {
+  const offset = cursor ? decodeCursor(cursor) : 0;
+  if (offset > items.length) {
+    throw new Error(`cursor out of range: offset ${offset} > total ${items.length}`);
+  }
+  const slice = items.slice(offset, offset + pageSize);
+  const nextOffset = offset + pageSize;
+  const nextCursor = nextOffset < items.length ? encodeCursor(nextOffset) : void 0;
+  return { items: slice, nextCursor };
+}
+var VAR_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var PLACEHOLDER_RE = /\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
+function compileUriTemplate(uriTemplate) {
+  const paramNames = [];
+  let match;
+  PLACEHOLDER_RE.lastIndex = 0;
+  while ((match = PLACEHOLDER_RE.exec(uriTemplate)) !== null) {
+    const name = match[1];
+    if (!VAR_NAME_RE.test(name)) {
+      throw new Error(`Invalid URI template variable name: ${name}`);
+    }
+    paramNames.push(name);
+  }
+  if (paramNames.length === 0) {
+    throw new Error(`URI template must contain at least one {var} placeholder: ${uriTemplate}`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of paramNames) {
+    if (seen.has(name)) {
+      throw new Error(`Duplicate URI template variable: ${name}`);
+    }
+    seen.add(name);
+  }
+  const isSingle = paramNames.length === 1;
+  const parts = [];
+  let lastIdx = 0;
+  PLACEHOLDER_RE.lastIndex = 0;
+  let m;
+  while ((m = PLACEHOLDER_RE.exec(uriTemplate)) !== null) {
+    const literal = uriTemplate.slice(lastIdx, m.index);
+    parts.push(escapeRegex(literal));
+    parts.push(isSingle ? "(.+)" : "([^/]+)");
+    lastIdx = m.index + m[0].length;
+  }
+  parts.push(escapeRegex(uriTemplate.slice(lastIdx)));
+  const regex = new RegExp(`^${parts.join("")}$`);
+  return { regex, paramNames };
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function matchUriTemplate(regex, paramNames, uri) {
+  const m = regex.exec(uri);
+  if (!m) return null;
+  const params = {};
+  for (let i = 0; i < paramNames.length; i++) {
+    params[paramNames[i]] = m[i + 1];
+  }
+  return params;
+}
+var McpServer = class {
+  constructor(options) {
+    this.options = options;
+    this.sessions = new SessionManager(this.options.sessionTtl);
+    this.pageSize = this.options.defaultPageSize ?? DEFAULT_PAGE_SIZE;
+    this.toolsListChanged = this.options.toolsListChanged ?? false;
+    this.resourcesListChanged = this.options.resourcesListChanged ?? false;
+    this.promptsListChanged = this.options.promptsListChanged ?? false;
+  }
+  options;
+  tools = /* @__PURE__ */ new Map();
+  resources = /* @__PURE__ */ new Map();
+  resourceTemplates = /* @__PURE__ */ new Map();
+  prompts = /* @__PURE__ */ new Map();
+  completions = /* @__PURE__ */ new Map();
+  methods = /* @__PURE__ */ new Map();
+  sessions;
+  pageSize;
+  toolsListChanged;
+  resourcesListChanged;
+  promptsListChanged;
+  /** 注册 tool */
+  tool(name, definition) {
+    if (this.tools.has(name)) {
+      throw new Error(`Tool "${name}" is already registered`);
+    }
+    let inputSchema;
+    let jsonSchema;
+    if (definition.input) {
+      inputSchema = buildZodObject(definition.input);
+      jsonSchema = toJSONSchema(inputSchema, { target: "draft-7" });
+      delete jsonSchema.$schema;
+      delete jsonSchema.additionalProperties;
+    }
+    this.tools.set(name, { name, definition, inputSchema, jsonSchema });
+  }
+  /** 注册 resource */
+  resource(uri, definition) {
+    if (this.resources.has(uri)) {
+      throw new Error(`Resource "${uri}" is already registered`);
+    }
+    this.resources.set(uri, { uri, definition });
+  }
+  /** 注册 resource template(RFC 6570 URI 模板) */
+  resourceTemplate(uriTemplate, definition) {
+    if (this.resourceTemplates.has(uriTemplate)) {
+      throw new Error(`Resource template "${uriTemplate}" is already registered`);
+    }
+    const { regex, paramNames } = compileUriTemplate(uriTemplate);
+    this.resourceTemplates.set(uriTemplate, {
+      uriTemplate,
+      regex,
+      paramNames,
+      definition
+    });
+  }
+  /** 注册 prompt */
+  prompt(name, definition) {
+    if (this.prompts.has(name)) {
+      throw new Error(`Prompt "${name}" is already registered`);
+    }
+    this.prompts.set(name, { name, definition });
+  }
+  /**
+   * 注册参数补全 handler
+   *
+   * - `ref`:`{ type: 'ref/prompt', name }` 或 `{ type: 'ref/resource', uri }`(对资源模板,uri 是模板字符串)
+   * - `argumentName`:补全的参数名(对应 prompt arguments 中的 name,或 resource template URI 模板中的变量名)
+   * - 同一 (ref, argumentName) 重复注册抛错
+   */
+  completion(ref, argumentName, handler) {
+    const refType = ref.type;
+    const refId = refType === "ref/prompt" ? ref.name : ref.uri;
+    const key = completionKey(refType, refId, argumentName);
+    if (this.completions.has(key)) {
+      throw new Error(
+        `Completion for ${refType} "${refId}" argument "${argumentName}" is already registered`
+      );
+    }
+    this.completions.set(key, { refType, refId, argumentName, handler });
+  }
+  /**
+   * 注册自定义 JSON-RPC 方法 handler(业务拓展)
+   *
+   * - 方法名建议使用 `appName/action` 格式,避免与 MCP 标准方法冲突
+   * - 与 MCP 内置方法(initialize/ping/tools/* 等)冲突时抛错
+   * - 重复注册同名方法抛错
+   *
+   * handler 返回值规则:
+   * - 返回普通对象:作为 JSON-RPC result 字段
+   * - 返回 JsonRpcErrorResponse(含 error 字段):作为错误响应
+   */
+  method(name, handler) {
+    if (BUILTIN_METHODS.has(name)) {
+      throw new Error(`Cannot register built-in method "${name}": it is reserved by MCP protocol`);
+    }
+    if (this.methods.has(name)) {
+      throw new Error(`Method "${name}" is already registered`);
+    }
+    this.methods.set(name, { name, handler });
+  }
+  /** 获取已注册 tool 名称列表 */
+  listTools() {
+    return [...this.tools.keys()];
+  }
+  /** 获取已注册 resource URI 列表 */
+  listResources() {
+    return [...this.resources.keys()];
+  }
+  /** 获取已注册 prompt 名称列表 */
+  listPrompts() {
+    return [...this.prompts.keys()];
+  }
+  /** 获取已注册自定义方法名列表(业务拓展) */
+  listMethods() {
+    return [...this.methods.keys()];
+  }
+  // ─── remove 方法(运行时删除注册项) ───────────────────
+  /**
+   * 删除已注册 tool
+   *
+   * - `toolsListChanged: true` 时自动推送 `notifications/tools/list_changed`
+   * - `toolsListChanged: false` 时静默删除(用于 dev 热替换,客户端不感知)
+   */
+  removeTool(name) {
+    const deleted = this.tools.delete(name);
+    if (deleted && this.toolsListChanged) {
+      this.notifyToolsListChanged();
+    }
+    return deleted;
+  }
+  /**
+   * 删除已注册 resource
+   *
+   * - `resourcesListChanged: true` 时自动推送 `notifications/resources/list_changed`
+   */
+  removeResource(uri) {
+    const deleted = this.resources.delete(uri);
+    if (deleted && this.resourcesListChanged) {
+      this.notifyResourcesListChanged();
+    }
+    return deleted;
+  }
+  /**
+   * 删除已注册 resource template
+   *
+   * - `resourcesListChanged: true` 时自动推送 `notifications/resources/list_changed`
+   */
+  removeResourceTemplate(uriTemplate) {
+    const deleted = this.resourceTemplates.delete(uriTemplate);
+    if (deleted && this.resourcesListChanged) {
+      this.notifyResourcesListChanged();
+    }
+    return deleted;
+  }
+  /**
+   * 删除已注册 prompt
+   *
+   * - `promptsListChanged: true` 时自动推送 `notifications/prompts/list_changed`
+   */
+  removePrompt(name) {
+    const deleted = this.prompts.delete(name);
+    if (deleted && this.promptsListChanged) {
+      this.notifyPromptsListChanged();
+    }
+    return deleted;
+  }
+  /**
+   * 删除已注册 completion handler
+   *
+   * - completion 无 list_changed 通知机制(客户端按需请求,无需感知列表变化)
+   */
+  removeCompletion(ref, argumentName) {
+    const refType = ref.type;
+    const refId = refType === "ref/prompt" ? ref.name : ref.uri;
+    const key = completionKey(refType, refId, argumentName);
+    return this.completions.delete(key);
+  }
+  /** 删除已注册自定义方法 */
+  removeMethod(name) {
+    return this.methods.delete(name);
+  }
+  // ─── list_changed 通知 ───────────────────────────────
+  /**
+   * 推送 `notifications/tools/list_changed` 到所有 session 的 SSE 订阅者
+   *
+   * 客户端收到后应重新调用 `tools/list` 拉取最新列表。
+   * `removeTool` 在 `toolsListChanged: true` 时自动调用本方法,
+   * 业务方也可手动调用(如批量删除后只推送一次)。
+   */
+  notifyToolsListChanged() {
+    this.broadcastNotificationToAllSessions("notifications/tools/list_changed");
+  }
+  /** 推送 `notifications/resources/list_changed` 到所有 session 的 SSE 订阅者 */
+  notifyResourcesListChanged() {
+    this.broadcastNotificationToAllSessions("notifications/resources/list_changed");
+  }
+  /** 推送 `notifications/prompts/list_changed` 到所有 session 的 SSE 订阅者 */
+  notifyPromptsListChanged() {
+    this.broadcastNotificationToAllSessions("notifications/prompts/list_changed");
+  }
+  /**
+   * 向所有 session 的所有 SSE 订阅者广播通知(内部工具方法)
+   *
+   * 用于 list_changed 这种"全局广播"语义——所有 session 都应感知列表变化。
+   */
+  broadcastNotificationToAllSessions(method, params) {
+    const notification = {
+      jsonrpc: "2.0",
+      method
+    };
+    if (params !== void 0) {
+      notification.params = params;
+    }
+    const sseData = `data: ${JSON.stringify(notification)}
+
+`;
+    for (const sessionId of this.sessions.allSessionIds()) {
+      this.sessions.broadcastToSession(sessionId, sseData);
+    }
+  }
+  /** 获取会话管理器 */
+  getSessionManager() {
+    return this.sessions;
+  }
+  /** 获取 GET SSE 流心跳间隔(毫秒) */
+  getSseHeartbeatMs() {
+    return this.options.sseHeartbeatMs ?? 3e4;
+  }
+  /**
+   * 处理 JSON-RPC 请求，返回响应消息
+   *
+   * 通知（无 id）不返回响应，返回 null。
+   */
+  async handleJsonRpc(message, session) {
+    if (isNotification(message)) {
+      return this.handleNotification(message, session);
+    }
+    if ("id" in message && "method" in message && !("result" in message) && !("error" in message)) {
+      return this.handleRequest(message, session);
+    }
+    return null;
+  }
+  handleNotification(message, session) {
+    switch (message.method) {
+      case "notifications/initialized":
+        if (session) session.initialized = true;
+        break;
+      case "notifications/cancelled":
+        break;
+    }
+    return null;
+  }
+  async handleRequest(request, session) {
+    try {
+      switch (request.method) {
+        case "initialize":
+          return this.handleInitialize(request, session);
+        case "ping":
+          return createResultResponse(request.id, {});
+        case "tools/list":
+          return this.handleToolsList(request);
+        case "tools/call":
+          return await this.handleToolsCall(request, session);
+        case "resources/list":
+          return this.handleResourcesList(request);
+        case "resources/read":
+          return await this.handleResourcesRead(request, session);
+        case "prompts/list":
+          return this.handlePromptsList(request);
+        case "prompts/get":
+          return await this.handlePromptsGet(request, session);
+        case "logging/setLevel":
+          return this.handleLoggingSetLevel(request, session);
+        case "resources/subscribe":
+          return this.handleResourcesSubscribe(request, session);
+        case "resources/unsubscribe":
+          return this.handleResourcesUnsubscribe(request, session);
+        case "resources/templates/list":
+          return this.handleResourcesTemplatesList(request);
+        case "completion/complete":
+          return await this.handleCompletionComplete(request);
+        default:
+          if (this.methods.has(request.method)) {
+            return await this.handleCustomMethod(request, session);
+          }
+          return createErrorResponse(
+            request.id,
+            ErrorCode.MethodNotFound,
+            `Method not found: ${request.method}`
+          );
+      }
+    } catch (err) {
+      return createErrorResponse(
+        request.id,
+        ErrorCode.InternalError,
+        err instanceof Error ? err.message : String(err)
+      );
+    }
+  }
+  // ─── initialize ──────────────────────────────────────
+  handleInitialize(request, session) {
+    const params = request.params ?? {};
+    const requestedVersion = params.protocolVersion ?? PROTOCOL_VERSION;
+    const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(
+      requestedVersion
+    ) ? requestedVersion : PROTOCOL_VERSION;
+    if (!session) {
+      session = this.sessions.create();
+    }
+    session.protocolVersion = protocolVersion;
+    session.clientInfo = params.clientInfo;
+    const capabilities = {
+      tools: { listChanged: this.toolsListChanged },
+      // logging capability 始终声明——服务端内置日志推送能力
+      logging: {}
+    };
+    if (this.resources.size > 0 || this.resourceTemplates.size > 0) {
+      capabilities.resources = { listChanged: this.resourcesListChanged, subscribe: true };
+    }
+    if (this.prompts.size > 0) {
+      capabilities.prompts = { listChanged: this.promptsListChanged };
+    }
+    const result = {
+      protocolVersion,
+      capabilities,
+      serverInfo: {
+        name: this.options.name,
+        version: this.options.version,
+        ...this.options.title && { title: this.options.title }
+      },
+      ...this.options.instructions && { instructions: this.options.instructions }
+    };
+    return createResultResponse(request.id, result);
+  }
+  // ─── tools/list ──────────────────────────────────────
+  handleToolsList(request) {
+    const params = request.params ?? {};
+    const allTools = Array.from(this.tools.values()).map((tool) => ({
+      name: tool.name,
+      ...tool.definition.description && { description: tool.definition.description },
+      inputSchema: tool.jsonSchema ?? { type: "object", properties: {} },
+      ...tool.definition.annotations && { annotations: tool.definition.annotations }
+    }));
+    let paged;
+    try {
+      paged = paginate(allTools, params.cursor, this.pageSize);
+    } catch (err) {
+      return createErrorResponse(
+        request.id,
+        ErrorCode.InvalidParams,
+        err instanceof Error ? err.message : "Invalid cursor"
+      );
+    }
+    return createResultResponse(request.id, {
+      tools: paged.items,
+      ...paged.nextCursor && { nextCursor: paged.nextCursor }
+    });
+  }
+  // ─── tools/call ──────────────────────────────────────
+  async handleToolsCall(request, session) {
+    const params = request.params ?? {};
+    if (!params.name) {
+      return createErrorResponse(
+        request.id,
+        ErrorCode.InvalidParams,
+        "Missing required parameter: name"
+      );
+    }
+    const tool = this.tools.get(params.name);
+    if (!tool) {
+      return createErrorResponse(
+        request.id,
+        ErrorCode.InvalidParams,
+        `Unknown tool: ${params.name}`
+      );
+    }
+    const args = params.arguments ?? {};
+    if (tool.inputSchema) {
+      const parsed = tool.inputSchema.safeParse(args);
+      if (!parsed.success) {
+        return createErrorResponse(
+          request.id,
+          ErrorCode.InvalidParams,
+          "Invalid tool arguments",
+          parsed.error.issues
+        );
+      }
+      Object.assign(args, parsed.data);
+    }
+    const progressToken = params._meta?.progressToken;
+    const extra = {
+      sessionId: session?.id ?? "",
+      sendLogging: (level, data, logger) => {
+        if (session) this.sendLogging(session.id, level, data, logger);
+      },
+      sendProgress: (progress, total) => {
+        if (session) this.sendProgress(session.id, progressToken, progress, total);
+      }
+    };
+    let result;
+    try {
+      result = await tool.definition.handler(args, extra);
+    } catch (err) {
+      result = {
+        content: [
+          {
+            type: "text",
+            text: `Tool execution failed: ${err instanceof Error ? err.message : String(err)}`
+          }
+        ],
+        isError: true
+      };
+    }
+    return createResultResponse(request.id, result);
+  }
+  // ─── resources/list ─────────────────────────────────
+  handleResourcesList(request) {
+    const params = request.params ?? {};
+    const allResources = Array.from(this.resources.values()).map((r) => ({
+      uri: r.uri,
+      name: r.definition.name,
+      ...r.definition.description && { description: r.definition.description },
+      ...r.definition.mimeType && { mimeType: r.definition.mimeType }
+    }));
+    let paged;
+    try {
+      paged = paginate(allResources, params.cursor, this.pageSize);
+    } catch (err) {
+      return createErrorResponse(
+        request.id,
+        ErrorCode.InvalidParams,
+        err instanceof Error ? err.message : "Invalid cursor"
+      );
+    }
+    return createResultResponse(request.id, {
+      resources: paged.items,
+      ...paged.nextCursor && { nextCursor: paged.nextCursor }
+    });
+  }
+  // ─── resources/read ─────────────────────────────────
+  async handleResourcesRead(request, session) {
+    const params = request.params ?? {};
+    if (!params.uri) {
+      return createErrorResponse(
+        request.id,
+        ErrorCode.InvalidParams,
+        "Missing required parameter: uri"
+      );
+    }
+    const progressToken = params._meta?.progressToken;
+    const sendProgressFn = (progress, total) => {
+      if (session) this.sendProgress(session.id, progressToken, progress, total);
+    };
+    const extra = {
+      sessionId: session?.id ?? "",
+      sendLogging: (level, data, logger) => {
+        if (session) this.sendLogging(session.id, level, data, logger);
+      },
+      sendProgress: sendProgressFn
+    };
+    const resource = this.resources.get(params.uri);
+    if (resource) {
+      const result = await resource.definition.read(params.uri, extra);
+      return createResultResponse(request.id, result);
+    }
+    for (const tpl of this.resourceTemplates.values()) {
+      const params2 = matchUriTemplate(tpl.regex, tpl.paramNames, params.uri);
+      if (params2) {
+        const tplExtra = {
+          sessionId: session?.id ?? "",
+          sendLogging: (level, data, logger) => {
+            if (session) this.sendLogging(session.id, level, data, logger);
+          },
+          sendProgress: sendProgressFn
+        };
+        const result = await tpl.definition.read(params.uri, params2, tplExtra);
+        return createResultResponse(request.id, result);
+      }
+    }
+    return createErrorResponse(
+      request.id,
+      ErrorCode.InvalidParams,
+      `Unknown resource: ${params.uri}`
+    );
+  }
+  // ─── resources/templates/list ──────────────────────
+  handleResourcesTemplatesList(request) {
+    const params = request.params ?? {};
+    const allTemplates = Array.from(this.resourceTemplates.values()).map((t) => ({
+      uriTemplate: t.uriTemplate,
+      name: t.definition.name,
+      ...t.definition.description && { description: t.definition.description },
+      ...t.definition.mimeType && { mimeType: t.definition.mimeType }
+    }));
+    let paged;
+    try {
+      paged = paginate(allTemplates, params.cursor, this.pageSize);
+    } catch (err) {
+      return createErrorResponse(
+        request.id,
+        ErrorCode.InvalidParams,
+        err instanceof Error ? err.message : "Invalid cursor"
+      );
+    }
+    return createResultResponse(request.id, {
+      resourceTemplates: paged.items,
+      ...paged.nextCursor && { nextCursor: paged.nextCursor }
+    });
+  }
+  // ─── prompts/list ───────────────────────────────────
+  handlePromptsList(request) {
+    const params = request.params ?? {};
+    const allPrompts = Array.from(this.prompts.values()).map((p) => ({
+      name: p.name,
+      ...p.definition.description && { description: p.definition.description },
+      ...p.definition.arguments && { arguments: p.definition.arguments }
+    }));
+    let paged;
+    try {
+      paged = paginate(allPrompts, params.cursor, this.pageSize);
+    } catch (err) {
+      return createErrorResponse(
+        request.id,
+        ErrorCode.InvalidParams,
+        err instanceof Error ? err.message : "Invalid cursor"
+      );
+    }
+    return createResultResponse(request.id, {
+      prompts: paged.items,
+      ...paged.nextCursor && { nextCursor: paged.nextCursor }
+    });
+  }
+  // ─── prompts/get ────────────────────────────────────
+  async handlePromptsGet(request, session) {
+    const params = request.params ?? {};
+    if (!params.name) {
+      return createErrorResponse(
+        request.id,
+        ErrorCode.InvalidParams,
+        "Missing required parameter: name"
+      );
+    }
+    const prompt = this.prompts.get(params.name);
+    if (!prompt) {
+      return createErrorResponse(
+        request.id,
+        ErrorCode.InvalidParams,
+        `Unknown prompt: ${params.name}`
+      );
+    }
+    const progressToken = params._meta?.progressToken;
+    const extra = {
+      sessionId: session?.id ?? "",
+      sendLogging: (level, data, logger) => {
+        if (session) this.sendLogging(session.id, level, data, logger);
+      },
+      sendProgress: (progress, total) => {
+        if (session) this.sendProgress(session.id, progressToken, progress, total);
+      }
+    };
+    const args = params.arguments ?? {};
+    const result = await prompt.definition.get(args, extra);
+    return createResultResponse(request.id, result);
+  }
+  // ─── logging/setLevel ──────────────────────────────
+  handleLoggingSetLevel(request, session) {
+    const params = request.params ?? {};
+    if (!params.level) {
+      return createErrorResponse(
+        request.id,
+        ErrorCode.InvalidParams,
+        "Missing required parameter: level"
+      );
+    }
+    const validLevels = [
+      "debug",
+      "info",
+      "notice",
+      "warning",
+      "error",
+      "critical",
+      "alert",
+      "emergency"
+    ];
+    if (!validLevels.includes(params.level)) {
+      return createErrorResponse(
+        request.id,
+        ErrorCode.InvalidParams,
+        `Invalid logging level: ${params.level}`
+      );
+    }
+    if (session) {
+      session.loggingLevel = params.level;
+    }
+    return createResultResponse(request.id, {});
+  }
+  // ─── resources/subscribe ───────────────────────────
+  handleResourcesSubscribe(request, session) {
+    const params = request.params ?? {};
+    if (!params.uri) {
+      return createErrorResponse(
+        request.id,
+        ErrorCode.InvalidParams,
+        "Missing required parameter: uri"
+      );
+    }
+    if (!session) {
+      return createErrorResponse(request.id, ErrorCode.InvalidRequest, "No session for subscribe");
+    }
+    this.sessions.subscribeResource(session.id, params.uri);
+    return createResultResponse(request.id, {});
+  }
+  // ─── resources/unsubscribe ─────────────────────────
+  handleResourcesUnsubscribe(request, session) {
+    const params = request.params ?? {};
+    if (!params.uri) {
+      return createErrorResponse(
+        request.id,
+        ErrorCode.InvalidParams,
+        "Missing required parameter: uri"
+      );
+    }
+    if (!session) {
+      return createErrorResponse(
+        request.id,
+        ErrorCode.InvalidRequest,
+        "No session for unsubscribe"
+      );
+    }
+    this.sessions.unsubscribeResource(session.id, params.uri);
+    return createResultResponse(request.id, {});
+  }
+  // ─── completion/complete ───────────────────────────
+  async handleCompletionComplete(request) {
+    const params = request.params ?? {};
+    if (!params.ref || !params.argument) {
+      return createErrorResponse(
+        request.id,
+        ErrorCode.InvalidParams,
+        "Missing required parameter: ref and argument"
+      );
+    }
+    const ref = params.ref;
+    let refType;
+    let refId;
+    if (ref.type === "ref/prompt" && typeof ref.name === "string") {
+      refType = "ref/prompt";
+      refId = ref.name;
+    } else if (ref.type === "ref/resource" && typeof ref.uri === "string") {
+      refType = "ref/resource";
+      refId = ref.uri;
+    } else {
+      return createErrorResponse(
+        request.id,
+        ErrorCode.InvalidParams,
+        `Invalid ref: ${JSON.stringify(ref)}`
+      );
+    }
+    if (typeof params.argument.name !== "string") {
+      return createErrorResponse(
+        request.id,
+        ErrorCode.InvalidParams,
+        "Missing required parameter: argument.name"
+      );
+    }
+    const key = completionKey(refType, refId, params.argument.name);
+    const completion = this.completions.get(key);
+    if (!completion) {
+      return createErrorResponse(
+        request.id,
+        ErrorCode.MethodNotFound,
+        `No completion handler for ${refType} "${refId}" argument "${params.argument.name}"`
+      );
+    }
+    const value = params.argument.value ?? "";
+    const context = {
+      arguments: params.arguments ?? {}
+    };
+    let result;
+    try {
+      result = await completion.handler(value, context);
+    } catch (err) {
+      return createErrorResponse(
+        request.id,
+        ErrorCode.InternalError,
+        err instanceof Error ? err.message : String(err)
+      );
+    }
+    return createResultResponse(request.id, { completion: result });
+  }
+  // ─── 自定义方法分发(业务拓展) ───────────────────────
+  async handleCustomMethod(request, session) {
+    const registered = this.methods.get(request.method);
+    if (!registered) {
+      return createErrorResponse(
+        request.id,
+        ErrorCode.MethodNotFound,
+        `Method not found: ${request.method}`
+      );
+    }
+    const extra = {
+      sessionId: session?.id ?? "",
+      sendLogging: (level, data, logger) => {
+        if (session) this.sendLogging(session.id, level, data, logger);
+      },
+      sendProgress: (progress, total) => {
+        if (session) this.sendProgress(session.id, void 0, progress, total);
+      }
+    };
+    let result;
+    try {
+      result = await registered.handler(request.params, session, extra);
+    } catch (err) {
+      return createErrorResponse(
+        request.id,
+        ErrorCode.InternalError,
+        err instanceof Error ? err.message : String(err)
+      );
+    }
+    if (result !== null && typeof result === "object" && "error" in result && result.error !== null && typeof result.error === "object") {
+      const errResp = result;
+      return { ...errResp, jsonrpc: "2.0", id: request.id };
+    }
+    return createResultResponse(request.id, result);
+  }
+  // ─── sendLogging(应用级 + handler extra 共用) ─────
+  /**
+   * 推送 notifications/message 到 session 的所有 SSE 订阅者
+   *
+   * - 无 session 或无订阅者:静默丢弃
+   * - level 低于 session.loggingLevel:静默丢弃
+   * - SSE 行格式:`data: ${JSON.stringify(notification)}\n\n`
+   */
+  sendLogging(sessionId, level, data, logger) {
+    if (!this.sessions.shouldLog(sessionId, level)) return;
+    const notification = {
+      jsonrpc: "2.0",
+      method: "notifications/message",
+      params: { level, data }
+    };
+    if (logger !== void 0) {
+      notification.params.logger = logger;
+    }
+    const sseData = `data: ${JSON.stringify(notification)}
+
+`;
+    this.sessions.broadcastToSession(sessionId, sseData);
+  }
+  /**
+   * 推送 notifications/resources/updated 到所有订阅了该 URI 的 session
+   *
+   * - 找出所有 subscribedResources 包含该 URI 的 session
+   * - 对每个 session 的所有 SSE 订阅者推送通知
+   * - 无订阅者的 session 静默跳过
+   */
+  sendResourceUpdated(uri) {
+    const sessionIds = this.sessions.findSubscribersOfUri(uri);
+    if (sessionIds.length === 0) return;
+    const notification = {
+      jsonrpc: "2.0",
+      method: "notifications/resources/updated",
+      params: { uri }
+    };
+    const sseData = `data: ${JSON.stringify(notification)}
+
+`;
+    for (const sessionId of sessionIds) {
+      this.sessions.broadcastToSession(sessionId, sseData);
+    }
+  }
+  /**
+   * 推送 notifications/progress 到 session 的所有 SSE 订阅者
+   *
+   * - 无 session 或无订阅者:静默丢弃
+   * - progressToken 为 undefined/null:静默丢弃(无法关联进度与请求)
+   *
+   * @param sessionId 会话 ID
+   * @param progressToken 客户端在请求 _meta.progressToken 中传入的 token(任意 JSON 值)
+   * @param progress 当前进度(数值)
+   * @param total 总数(可选)
+   */
+  sendProgress(sessionId, progressToken, progress, total) {
+    if (progressToken === void 0 || progressToken === null) return;
+    const params = { progressToken, progress };
+    if (total !== void 0) {
+      params.total = total;
+    }
+    const notification = {
+      jsonrpc: "2.0",
+      method: "notifications/progress",
+      params
+    };
+    const sseData = `data: ${JSON.stringify(notification)}
+
+`;
+    this.sessions.broadcastToSession(sessionId, sseData);
+  }
+  /**
+   * 通用通知推送(业务拓展)——向指定 session 的所有 SSE 订阅者推送任意通知
+   *
+   * - 无 session 或无订阅者:静默丢弃
+   * - 不校验 method 是否符合 MCP 规范——业务方自行负责
+   * - SSE 行格式:`data: ${JSON.stringify(notification)}\n\n`
+   *
+   * @param sessionId 目标 session ID
+   * @param method 通知方法名(如 `notifications/myapp/sync`)
+   * @param params 通知参数(可选)
+   */
+  sendNotification(sessionId, method, params) {
+    const notification = {
+      jsonrpc: "2.0",
+      method
+    };
+    if (params !== void 0) {
+      notification.params = params;
+    }
+    const sseData = `data: ${JSON.stringify(notification)}
+
+`;
+    this.sessions.broadcastToSession(sessionId, sseData);
+  }
+};
+function buildZodObject(shape) {
+  return z.object(shape);
+}
+function completionKey(refType, refId, argumentName) {
+  return `${refType}:${refId}:${argumentName}`;
+}
+function createMcpServer(options) {
+  return new McpServer(options);
+}
+
+// src/streamableHttp.ts
+var DEFAULT_SSE_HEARTBEAT_MS = 3e4;
+async function handleMcpRequest(request, server) {
+  switch (request.method) {
+    case "POST":
+      return handlePost(request, server);
+    case "GET":
+      return handleGet(server, request);
+    case "DELETE":
+      return handleDelete(request, server);
+    default:
+      return new Response(null, { status: 405 });
+  }
+}
+function handleGet(server, request) {
+  const heartbeatMs = server.getSseHeartbeatMs() ?? DEFAULT_SSE_HEARTBEAT_MS;
+  const encoder = new TextEncoder();
+  let interval;
+  let subscriber;
+  const sessionId = request.headers.get("mcp-session-id") ?? void 0;
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(encoder.encode(": connected\n\n"));
+      if (sessionId) {
+        subscriber = server.getSessionManager().addSubscriber(sessionId, controller);
+      }
+      interval = setInterval(() => {
+        try {
+          controller.enqueue(encoder.encode(`: keepalive ${Date.now()}
+
+`));
+        } catch {
+          if (interval) clearInterval(interval);
+        }
+      }, heartbeatMs);
+    },
+    cancel() {
+      if (interval) clearInterval(interval);
+      if (subscriber) {
+        server.getSessionManager().removeSubscriber(subscriber);
+      }
+    }
+  });
+  return new Response(stream, {
+    status: 200,
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    }
+  });
+}
+async function handlePost(request, server) {
+  let body;
+  try {
+    body = await request.json();
+  } catch {
+    return jsonResponse(
+      400,
+      createErrorResponse(null, ErrorCode.ParseError, "Parse error: Invalid JSON")
+    );
+  }
+  let messages;
+  try {
+    messages = parseJsonRpcMessage(body);
+  } catch (err) {
+    const message = err instanceof JsonRpcParseError ? err.message : "Invalid JSON-RPC message";
+    return jsonResponse(400, createErrorResponse(null, ErrorCode.ParseError, message));
+  }
+  const requests = messages.filter(isRequest);
+  const notifications = messages.filter(isNotification);
+  const hasInitialize = requests.some((r) => r.method === "initialize");
+  if (!hasInitialize) {
+    const acceptHeader = request.headers.get("accept") ?? "";
+    const accepts = acceptHeader.split(",").map((s) => s.trim().toLowerCase()).filter((s) => s.length > 0);
+    const hasJson = accepts.some(
+      (s) => s === "application/json" || s.startsWith("application/json;")
+    );
+    const hasSse = accepts.some(
+      (s) => s === "text/event-stream" || s.startsWith("text/event-stream;")
+    );
+    if (!hasJson || !hasSse) {
+      return jsonResponse(
+        400,
+        createErrorResponse(
+          null,
+          ErrorCode.InvalidRequest,
+          "Accept header must include both application/json and text/event-stream"
+        )
+      );
+    }
+  }
+  const sessionId = request.headers.get("mcp-session-id") ?? void 0;
+  const sessionManager = server.getSessionManager();
+  let session = sessionId ? sessionManager.get(sessionId) : void 0;
+  if (hasInitialize) {
+    if (session) {
+      return jsonResponse(
+        400,
+        createErrorResponse(null, ErrorCode.InvalidRequest, "Server already initialized")
+      );
+    }
+    session = sessionManager.create();
+  } else if (requests.length > 0 && !session && sessionId) {
+    return jsonResponse(
+      404,
+      createErrorResponse(null, ErrorCode.RequestTimeout, "Session not found")
+    );
+  }
+  for (const notification of notifications) {
+    await server.handleJsonRpc(notification, session);
+  }
+  const responses = [];
+  for (const req of requests) {
+    const response = await server.handleJsonRpc(req, session);
+    if (response !== null) {
+      responses.push(response);
+    }
+  }
+  if (requests.length === 0) {
+    return new Response(null, { status: 202 });
+  }
+  const responseHeaders = {
+    "Content-Type": "application/json"
+  };
+  if (hasInitialize && session) {
+    responseHeaders["Mcp-Session-Id"] = session.id;
+  }
+  const responseBody = responses.length === 1 ? responses[0] : responses;
+  return new Response(JSON.stringify(responseBody), {
+    status: 200,
+    headers: responseHeaders
+  });
+}
+function handleDelete(request, server) {
+  const sessionId = request.headers.get("mcp-session-id");
+  if (!sessionId) {
+    return Promise.resolve(
+      jsonResponse(
+        400,
+        createErrorResponse(null, ErrorCode.InvalidRequest, "Missing Mcp-Session-Id header")
+      )
+    );
+  }
+  const deleted = server.getSessionManager().delete(sessionId);
+  if (!deleted) {
+    return Promise.resolve(
+      jsonResponse(404, createErrorResponse(null, ErrorCode.RequestTimeout, "Session not found"))
+    );
+  }
+  return Promise.resolve(new Response(null, { status: 200 }));
+}
+function jsonResponse(status, body) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+
+// src/faapiAdapter.ts
+import { Readable } from "stream";
+function createMcpHandler(mcp) {
+  const handler = async (ctx) => {
+    return handleMcpRequest(ctx.request, mcp);
+  };
+  return { POST: handler, GET: handler, DELETE: handler };
+}
+function createMcpNodeHandler(mcp) {
+  return async (req, res) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(req.headers)) {
+      if (Array.isArray(value)) {
+        for (const v of value) headers.set(key, v);
+      } else if (value !== void 0) {
+        headers.set(key, value);
+      }
+    }
+    const method = req.method ?? "GET";
+    const hasBody = method !== "GET" && method !== "HEAD" && method !== "DELETE";
+    const body = hasBody ? Readable.toWeb(req) : void 0;
+    const request = new Request(url, {
+      method,
+      headers,
+      ...body && { body, duplex: "half" }
+    });
+    const response = await handleMcpRequest(request, mcp);
+    res.statusCode = response.status;
+    response.headers.forEach((value, key) => {
+      res.setHeader(key, value);
+    });
+    if (response.body) {
+      const nodeStream = Readable.fromWeb(response.body);
+      await new Promise((resolve, reject) => {
+        let settled = false;
+        const settle = (err) => {
+          if (settled) return;
+          settled = true;
+          if (err) reject(err);
+          else resolve();
+        };
+        nodeStream.on("error", (err) => settle(err));
+        res.on("error", (err) => settle(err));
+        res.on("finish", () => settle());
+        res.on("close", () => settle());
+        nodeStream.pipe(res);
+      });
+      return;
+    }
+    res.end();
+  };
+}
+export {
+  ErrorCode,
+  JsonRpcParseError,
+  McpServer,
+  PROTOCOL_VERSION,
+  SUPPORTED_PROTOCOL_VERSIONS,
+  SessionManager,
+  createErrorResponse,
+  createMcpHandler,
+  createMcpNodeHandler,
+  createMcpServer,
+  createResultResponse,
+  handleMcpRequest,
+  isErrorResponse,
+  isNotification,
+  isRequest,
+  isResultResponse,
+  parseJsonRpcMessage
+};
+//# sourceMappingURL=index.js.map