@mcp-ts/sdk 2.4.5 → 2.5.1

package/dist/index.mjs

@@ -162,6 +162,59 @@ var SOFTWARE_VERSION = "2.3.4";
 var MCP_CLIENT_NAME = "mcp-ts-oauth-client";
 var MCP_CLIENT_VERSION = "2.0";
 
+// src/server/storage/tool-policy.ts
+function createToolId(serverId, toolName) {
+  return `${serverId}::${toolName}`;
+}
+function normalizeToolIds(input) {
+  if (!Array.isArray(input)) return [];
+  return Array.from(new Set(
+    input.filter((id) => typeof id === "string").map((id) => id.trim()).filter(Boolean)
+  ));
+}
+function normalizeToolPolicy(input, now = Date.now()) {
+  if (!input || typeof input !== "object") {
+    return void 0;
+  }
+  const mode = input.mode === "allowlist" || input.mode === "denylist" ? input.mode : "all";
+  const updatedAt = typeof input.updatedAt === "number" && Number.isFinite(input.updatedAt) ? input.updatedAt : now;
+  if (mode === "all") {
+    return { mode: "all", toolIds: [], updatedAt };
+  }
+  return { mode, toolIds: normalizeToolIds(input.toolIds), updatedAt };
+}
+function normalizeToolPolicyForUpdate(input, now = Date.now()) {
+  return normalizeToolPolicy(input, now) ?? { mode: "all", toolIds: [], updatedAt: now };
+}
+function isToolAllowed(policy, toolName, serverId) {
+  if (!policy || policy.mode === "all") return true;
+  if (!serverId) return false;
+  const toolId = createToolId(serverId, toolName);
+  if (policy.mode === "allowlist") {
+    return policy.toolIds.includes(toolId);
+  }
+  return !policy.toolIds.includes(toolId);
+}
+function assertToolAllowed(policy, toolName, serverId) {
+  if (isToolAllowed(policy, toolName, serverId)) return;
+  throw new Error(`Tool "${toolName}" is not allowed for this MCP session`);
+}
+function filterToolsByPolicy(tools, policy, serverId) {
+  if (!policy || policy.mode === "all") return tools;
+  return tools.filter((tool) => isToolAllowed(policy, tool.name, serverId));
+}
+function validateToolPolicyAgainstTools(policy, tools, serverId) {
+  if (policy.mode === "all") return;
+  if (!serverId) {
+    throw new Error("Cannot validate MCP tool policy without a serverId");
+  }
+  const availableIds = new Set(tools.map((tool) => createToolId(serverId, tool.name)));
+  const unknownIds = policy.toolIds.filter((id) => !availableIds.has(id));
+  if (unknownIds.length > 0) {
+    throw new Error(`Unknown tool id(s) for this MCP session: ${unknownIds.join(", ")}`);
+  }
+}
+
 // src/server/storage/session-lifecycle.ts
 function resolveSessionExpiresAt(status = "pending", referenceTime = Date.now()) {
   return status === "active" ? null : referenceTime + STATE_EXPIRATION_MS;
@@ -178,7 +231,8 @@ function normalizeNewSession(session, now = Date.now()) {
     status,
     createdAt,
     updatedAt,
-    expiresAt: resolveSessionExpiresAt(status, status === "active" ? updatedAt : createdAt)
+    expiresAt: resolveSessionExpiresAt(status, status === "active" ? updatedAt : createdAt),
+    toolPolicy: normalizeToolPolicy(session.toolPolicy, updatedAt)
   };
 }
 function mergeSessionUpdate(current, data, now = Date.now()) {
@@ -192,7 +246,8 @@ function mergeSessionUpdate(current, data, now = Date.now()) {
   return {
     ...updated,
     status,
-    expiresAt: resolveSessionExpiresAt(status, updatedAt)
+    expiresAt: resolveSessionExpiresAt(status, updatedAt),
+    toolPolicy: normalizeToolPolicy(updated.toolPolicy, updatedAt)
   };
 }
 function normalizeStoredSession(session) {
@@ -205,7 +260,8 @@ function normalizeStoredSession(session) {
     status,
     createdAt,
     updatedAt,
-    expiresAt
+    expiresAt,
+    toolPolicy: normalizeToolPolicy(session.toolPolicy, updatedAt)
   };
 }
 function isSessionExpired(session, now = Date.now()) {
@@ -1063,7 +1119,8 @@ var SupabaseStorageBackend = class {
       userId: row.user_id,
       headers: decryptObject(row.headers),
       authUrl: row.auth_url,
-      status: row.status ?? "pending"
+      status: row.status ?? "pending",
+      toolPolicy: normalizeToolPolicy(row.tool_policy)
     };
   }
   mapRowToCredentials(row, userId, sessionId) {
@@ -1087,7 +1144,7 @@ var SupabaseStorageBackend = class {
     const createdAt = new Date(session.createdAt || Date.now()).toISOString();
     const updatedAt = new Date(session.updatedAt ?? session.createdAt ?? Date.now()).toISOString();
     const expiresAt = resolveSessionExpiresAt(status, new Date(createdAt).getTime());
-    const { error } = await this.supabase.from("mcp_sessions").insert({
+    const insertData = {
       session_id: sessionId,
       user_id: userId,
       server_id: session.serverId,
@@ -1101,7 +1158,12 @@ var SupabaseStorageBackend = class {
       auth_url: session.authUrl ?? null,
       status,
       expires_at: expiresAt === null ? null : new Date(expiresAt).toISOString()
-    });
+    };
+    const toolPolicy = normalizeToolPolicy(session.toolPolicy);
+    if (toolPolicy) {
+      insertData.tool_policy = toolPolicy;
+    }
+    const { error } = await this.supabase.from("mcp_sessions").insert(insertData);
     if (error) {
       if (error.code === "23505") {
         throw new Error(`Session ${sessionId} already exists`);
@@ -1126,6 +1188,7 @@ var SupabaseStorageBackend = class {
     }
     if ("headers" in data) updateData.headers = encryptObject(data.headers);
     if ("authUrl" in data) updateData.auth_url = data.authUrl ?? null;
+    if ("toolPolicy" in data) updateData.tool_policy = normalizeToolPolicy(data.toolPolicy);
     const shouldUpdateSession = Object.keys(updateData).some((key) => key !== "updated_at");
     let updatedRows = null;
     if (shouldUpdateSession) {
@@ -1298,7 +1361,8 @@ var NeonStorageBackend = class {
       userId: row.user_id,
       headers: decryptObject(row.headers),
       authUrl: row.auth_url ?? void 0,
-      status: row.status ?? "pending"
+      status: row.status ?? "pending",
+      toolPolicy: normalizeToolPolicy(row.tool_policy)
     };
   }
   mapRowToCredentials(row, userId, sessionId) {
@@ -1321,42 +1385,48 @@ var NeonStorageBackend = class {
     const status = session.status ?? "pending";
     const createdAt = new Date(session.createdAt || Date.now()).toISOString();
     const updatedAt = new Date(session.updatedAt ?? session.createdAt ?? Date.now()).toISOString();
-    const expiresAt = resolveSessionExpiresAt(status, new Date(createdAt).getTime());
+    const createdAtMs = new Date(createdAt).getTime();
+    const expiresAt = resolveSessionExpiresAt(status, createdAtMs);
+    const toolPolicy = normalizeToolPolicy(session.toolPolicy, createdAtMs);
+    const columns = [
+      "session_id",
+      "user_id",
+      "server_id",
+      "server_name",
+      "server_url",
+      "transport_type",
+      "callback_url",
+      "created_at",
+      "updated_at",
+      "headers",
+      "auth_url",
+      "status",
+      "expires_at"
+    ];
+    const values = [
+      sessionId,
+      userId,
+      session.serverId,
+      session.serverName,
+      session.serverUrl,
+      session.transportType,
+      session.callbackUrl,
+      createdAt,
+      updatedAt,
+      encryptObject(session.headers),
+      session.authUrl ?? null,
+      status,
+      expiresAt === null ? null : new Date(expiresAt).toISOString()
+    ];
+    if (toolPolicy) {
+      columns.push("tool_policy");
+      values.push(toolPolicy);
+    }
+    const placeholders = values.map((_, i) => `$${i + 1}`);
     try {
       await this.sql.query(
-        `INSERT INTO ${this.tableName} (
-                    session_id,
-                    user_id,
-                    server_id,
-                    server_name,
-                    server_url,
-                    transport_type,
-                    callback_url,
-                    created_at,
-                    updated_at,
-                    headers,
-                    auth_url,
-                    status,
-                    expires_at
-                ) VALUES (
-                    $1, $2, $3, $4, $5, $6, $7, $8,
-                    $9, $10, $11, $12, $13
-                )`,
-        [
-          sessionId,
-          userId,
-          session.serverId,
-          session.serverName,
-          session.serverUrl,
-          session.transportType,
-          session.callbackUrl,
-          createdAt,
-          updatedAt,
-          encryptObject(session.headers),
-          session.authUrl ?? null,
-          status,
-          expiresAt === null ? null : new Date(expiresAt).toISOString()
-        ]
+        `INSERT INTO ${this.tableName} (${columns.join(", ")}) VALUES (${placeholders.join(", ")})`,
+        values
       );
     } catch (error) {
       if (error.code === "23505") {
@@ -1373,36 +1443,36 @@ var NeonStorageBackend = class {
     const updatedSession = { ...currentSession, ...data };
     const status = updatedSession.status ?? "pending";
     const expiresAt = resolveSessionExpiresAt(status);
-    const shouldUpdateSession = "serverId" in data || "serverName" in data || "serverUrl" in data || "transportType" in data || "callbackUrl" in data || "status" in data || "headers" in data || "authUrl" in data;
+    const shouldUpdateSession = "serverId" in data || "serverName" in data || "serverUrl" in data || "transportType" in data || "callbackUrl" in data || "status" in data || "headers" in data || "authUrl" in data || "toolPolicy" in data;
     if (shouldUpdateSession) {
+      const setClauses = [];
+      const values = [];
+      let paramIndex = 1;
+      const addSet = (column, value) => {
+        setClauses.push(`${column} = $${paramIndex++}`);
+        values.push(value);
+      };
+      addSet("server_id", updatedSession.serverId);
+      addSet("server_name", updatedSession.serverName);
+      addSet("server_url", updatedSession.serverUrl);
+      addSet("transport_type", updatedSession.transportType);
+      addSet("callback_url", updatedSession.callbackUrl);
+      addSet("status", status);
+      addSet("headers", encryptObject(updatedSession.headers));
+      addSet("auth_url", updatedSession.authUrl ?? null);
+      addSet("expires_at", expiresAt === null ? null : new Date(expiresAt).toISOString());
+      if ("toolPolicy" in data) {
+        const policyUpdatedAt = updatedSession.updatedAt ?? Date.now();
+        const toolPolicy = normalizeToolPolicy(updatedSession.toolPolicy, policyUpdatedAt) ?? { mode: "all", toolIds: [], updatedAt: policyUpdatedAt };
+        addSet("tool_policy", toolPolicy);
+      }
+      setClauses.push("updated_at = now()");
       const updatedRows = await this.sql.query(
         `UPDATE ${this.tableName}
-                 SET
-                    server_id = $1,
-                    server_name = $2,
-                    server_url = $3,
-                    transport_type = $4,
-                    callback_url = $5,
-                    status = $6,
-                    headers = $7,
-                    auth_url = $8,
-                    expires_at = $9,
-                    updated_at = now()
-                 WHERE user_id = $10 AND session_id = $11
+                 SET ${setClauses.join(", ")}
+                 WHERE user_id = $${paramIndex++} AND session_id = $${paramIndex++}
                  RETURNING id`,
-        [
-          updatedSession.serverId,
-          updatedSession.serverName,
-          updatedSession.serverUrl,
-          updatedSession.transportType,
-          updatedSession.callbackUrl,
-          status,
-          encryptObject(updatedSession.headers),
-          updatedSession.authUrl ?? null,
-          expiresAt === null ? null : new Date(expiresAt).toISOString(),
-          userId,
-          sessionId
-        ]
+        [...values, userId, sessionId]
       );
       if (updatedRows.length === 0) {
         throw new Error(`Session ${sessionId} not found for userId ${userId}`);
@@ -2684,6 +2754,19 @@ var MCPClient = class {
       throw lastError;
     }
   }
+  /**
+   * Lists all available tools from the connected MCP server without emitting discovery events.
+   * Gateways use this to apply policy before publishing tools to agents or UI state.
+   */
+  async fetchTools() {
+    const request = {
+      method: "tools/list",
+      params: {}
+    };
+    return await this.withRetry(
+      () => this.client.request(request, ListToolsResultSchema)
+    );
+  }
   /**
    * Lists all available tools from the connected MCP server
    * @returns List of tools with their schemas and descriptions
@@ -2692,13 +2775,7 @@ var MCPClient = class {
   async listTools() {
     this.emitStateChange("DISCOVERING");
     try {
-      const request = {
-        method: "tools/list",
-        params: {}
-      };
-      const result = await this.withRetry(
-        () => this.client.request(request, ListToolsResultSchema)
-      );
+      const result = await this.fetchTools();
       if (this.serverId) {
         this._onConnectionEvent.fire({
           type: "tools_discovered",
@@ -3025,6 +3102,66 @@ var MCPClient = class {
   }
 };
 
+// src/server/mcp/tool-policy-gateway.ts
+var ToolPolicyGateway = class {
+  constructor(userId, sessionId, client) {
+    this.userId = userId;
+    this.sessionId = sessionId;
+    this.client = client;
+  }
+  isConnected() {
+    return this.client.isConnected();
+  }
+  getServerId() {
+    return this.client.getServerId?.();
+  }
+  getServerName() {
+    return this.client.getServerName?.();
+  }
+  getServerUrl() {
+    return this.client.getServerUrl?.();
+  }
+  getSessionId() {
+    return this.client.getSessionId?.() ?? this.sessionId;
+  }
+  async listTools() {
+    const session = await this.getSession();
+    const result = await this.client.fetchTools();
+    const tools = this.filterTools(session, result.tools);
+    return {
+      ...result,
+      tools
+    };
+  }
+  async listAllTools() {
+    return await this.client.fetchTools();
+  }
+  async callTool(name, args) {
+    const session = await this.getSession();
+    this.assertAllowed(session, name);
+    return await this.client.callTool(name, args);
+  }
+  filterTools(session, tools) {
+    return filterToolsByPolicy(tools, session.toolPolicy, this.getPolicyServerId(session));
+  }
+  assertAllowed(session, toolName) {
+    assertToolAllowed(session.toolPolicy, toolName, this.getPolicyServerId(session));
+  }
+  async getSession() {
+    const session = await sessions.get(this.userId, this.sessionId);
+    if (!session) {
+      throw new Error("Session not found");
+    }
+    return session;
+  }
+  getPolicyServerId(session) {
+    return this.client.getServerId?.() ?? session.serverId;
+  }
+};
+function createToolPolicyGateway(userId, sessionId, client) {
+  return new ToolPolicyGateway(userId, sessionId, client);
+}
+
 // src/server/mcp/multi-session-client.ts
 var DEFAULT_TIMEOUT_MS = 15e3;
 var DEFAULT_MAX_RETRIES = 2;
@@ -3090,7 +3227,9 @@ var MultiSessionClient = class {
    * or to route a tool call to the right client by `serverId`.
    */
   getClients() {
-    return this.clients;
+    return this.clients.map(
+      (client) => createToolPolicyGateway(this.userId, client.getSessionId(), client)
+    );
   }
   /**
    * Removes and disconnects a single session by ID.
@@ -3319,12 +3458,21 @@ var SSEConnectionManager = class {
         case "connect":
           result = await this.connect(request.params);
           break;
+        case "reconnect":
+          result = await this.reconnect(request.params);
+          break;
         case "disconnect":
           result = await this.disconnect(request.params);
           break;
         case "listTools":
           result = await this.listTools(request.params);
           break;
+        case "setToolPolicy":
+          result = await this.setToolPolicy(request.params);
+          break;
+        case "getToolPolicy":
+          result = await this.getToolPolicy(request.params);
+          break;
         case "callTool":
           result = await this.callTool(request.params);
           break;
@@ -3381,7 +3529,8 @@ var SSEConnectionManager = class {
         transport: s.transportType,
         createdAt: s.createdAt,
         updatedAt: s.updatedAt ?? s.createdAt,
-        status: s.status ?? "pending"
+        status: s.status ?? "pending",
+        toolPolicy: s.toolPolicy
       }))
     };
   }
@@ -3429,7 +3578,7 @@ var SSEConnectionManager = class {
         this.sendEvent(event);
       });
       await client.connect();
-      await client.listTools();
+      await this.listPolicyFilteredTools(sessionId);
       return {
         sessionId,
         success: true
@@ -3454,6 +3603,66 @@ var SSEConnectionManager = class {
       throw error;
     }
   }
+  /**
+   * Reconnect to an MCP server — tears down the active client transport/connection
+   * and creates a fresh connection while reusing the existing session credentials in a single RPC call.
+   */
+  async reconnect(params) {
+    const { serverId: rawServerId, serverName, serverUrl, callbackUrl, transportType } = params;
+    const headers = normalizeHeaders(params.headers);
+    const serverId = rawServerId && rawServerId.length <= 12 ? rawServerId : generateServerId();
+    const existingSessions = await sessions.list(this.userId);
+    const duplicate = existingSessions.find(
+      (s) => s.serverId === serverId || s.serverUrl === serverUrl
+    );
+    const sessionId = duplicate ? duplicate.sessionId : await sessions.generateSessionId();
+    if (duplicate) {
+      const existingClient = this.clients.get(duplicate.sessionId);
+      if (existingClient) {
+        await existingClient.disconnect();
+        this.clients.delete(duplicate.sessionId);
+      }
+    }
+    try {
+      const clientMetadata = await this.getResolvedClientMetadata();
+      const client = new MCPClient({
+        userId: this.userId,
+        sessionId,
+        serverId,
+        serverName,
+        serverUrl,
+        callbackUrl,
+        transportType,
+        headers,
+        ...clientMetadata
+      });
+      this.clients.set(sessionId, client);
+      client.onConnectionEvent((event) => {
+        this.emitConnectionEvent(event);
+      });
+      client.onObservabilityEvent((event) => {
+        this.sendEvent(event);
+      });
+      await client.connect();
+      await this.listPolicyFilteredTools(sessionId);
+      return { sessionId, success: true };
+    } catch (error) {
+      if (error instanceof UnauthorizedError) {
+        this.clients.delete(sessionId);
+        return { sessionId, success: true };
+      }
+      this.emitConnectionEvent({
+        type: "error",
+        sessionId,
+        serverId,
+        error: error instanceof Error ? error.message : "Connection failed",
+        errorType: "connection",
+        timestamp: Date.now()
+      });
+      this.clients.delete(sessionId);
+      throw error;
+    }
+  }
   /**
    * Disconnect from an MCP server
    */
@@ -3500,22 +3709,98 @@ var SSEConnectionManager = class {
     this.clients.set(sessionId, client);
     return client;
   }
+  async listPolicyFilteredTools(sessionId) {
+    const session = await sessions.get(this.userId, sessionId);
+    if (!session) {
+      throw new Error("Session not found");
+    }
+    const client = await this.getOrCreateClient(sessionId);
+    const gateway = createToolPolicyGateway(this.userId, sessionId, client);
+    const result = await gateway.listTools();
+    this.emitConnectionEvent({
+      type: "tools_discovered",
+      sessionId,
+      serverId: session.serverId ?? "unknown",
+      toolCount: result.tools.length,
+      tools: result.tools,
+      timestamp: Date.now()
+    });
+    return { session, result };
+  }
   /**
    * List tools from a session
    */
   async listTools(params) {
     const { sessionId } = params;
-    const client = await this.getOrCreateClient(sessionId);
-    const result = await client.listTools();
+    const { result } = await this.listPolicyFilteredTools(sessionId);
     return { tools: result.tools };
   }
+  /**
+   * Get all raw tools with effective access state for management UI.
+   */
+  async getToolPolicy(params) {
+    const { sessionId } = params;
+    const session = await sessions.get(this.userId, sessionId);
+    if (!session) {
+      throw new Error("Session not found");
+    }
+    const client = await this.getOrCreateClient(sessionId);
+    const allTools = await client.fetchTools();
+    const toolPolicy = session.toolPolicy ?? {
+      mode: "all",
+      toolIds: [],
+      updatedAt: session.updatedAt ?? session.createdAt
+    };
+    const serverId = session.serverId ?? "unknown";
+    const tools = allTools.tools.map((tool) => ({
+      ...tool,
+      toolId: createToolId(serverId, tool.name),
+      allowed: isToolAllowed(toolPolicy, tool.name, session.serverId)
+    }));
+    return {
+      toolPolicy,
+      tools,
+      toolCount: tools.length,
+      allowedToolCount: tools.filter((tool) => tool.allowed).length
+    };
+  }
+  /**
+   * Update per-session tool access policy.
+   */
+  async setToolPolicy(params) {
+    const { sessionId } = params;
+    const session = await sessions.get(this.userId, sessionId);
+    if (!session) {
+      throw new Error("Session not found");
+    }
+    const client = await this.getOrCreateClient(sessionId);
+    const allTools = await client.fetchTools();
+    const toolPolicy = normalizeToolPolicyForUpdate(params.toolPolicy);
+    validateToolPolicyAgainstTools(toolPolicy, allTools.tools, session.serverId);
+    await sessions.update(this.userId, sessionId, { toolPolicy });
+    const filteredTools = createToolPolicyGateway(this.userId, sessionId, client).filterTools({ ...session, toolPolicy }, allTools.tools);
+    this.emitConnectionEvent({
+      type: "tools_discovered",
+      sessionId,
+      serverId: session.serverId ?? "unknown",
+      toolCount: filteredTools.length,
+      tools: filteredTools,
+      timestamp: Date.now()
+    });
+    return {
+      success: true,
+      toolPolicy,
+      tools: filteredTools,
+      toolCount: filteredTools.length
+    };
+  }
   /**
    * Call a tool on the MCP server
    */
   async callTool(params) {
     const { sessionId, toolName, toolArgs } = params;
     const client = await this.getOrCreateClient(sessionId);
-    const result = await client.callTool(toolName, toolArgs);
+    const result = await createToolPolicyGateway(this.userId, sessionId, client).callTool(toolName, toolArgs);
     const meta = result._meta || {};
     return {
       ...result,
@@ -3565,7 +3850,7 @@ var SSEConnectionManager = class {
       client.onObservabilityEvent((event) => this.sendEvent(event));
       await client.connect();
       this.clients.set(sessionId, client);
-      const tools = await client.listTools();
+      const { result: tools } = await this.listPolicyFilteredTools(sessionId);
       return { success: true, toolCount: tools.tools.length };
     } catch (error) {
       this.emitConnectionEvent({
@@ -3613,7 +3898,7 @@ var SSEConnectionManager = class {
       client.onConnectionEvent((event) => this.emitConnectionEvent(event));
       await client.finishAuth(code, oauthState);
       this.clients.set(sessionId, client);
-      const tools = await client.listTools();
+      const { result: tools } = await this.listPolicyFilteredTools(sessionId);
       return { success: true, toolCount: tools.tools.length };
     } catch (error) {
       this.emitConnectionEvent({
@@ -3905,6 +4190,15 @@ var SSEClient = class {
   async disconnectFromServer(sessionId) {
     return this.sendRequest("disconnect", { sessionId });
   }
+  async reconnectToServer(params) {
+    return this.sendRequest("reconnect", params);
+  }
+  async setToolPolicy(sessionId, toolPolicy) {
+    return this.sendRequest("setToolPolicy", { sessionId, toolPolicy });
+  }
+  async getToolPolicy(sessionId) {
+    return this.sendRequest("getToolPolicy", { sessionId });
+  }
   async listTools(sessionId) {
     return this.sendRequest("listTools", { sessionId });
   }