@mcp-ts/sdk 2.4.4 → 2.5.0

package/dist/server/index.mjs

@@ -112,13 +112,9 @@ var init_redis = __esm({
   }
 });
 var OAUTH_STATE_SEPARATOR = ".";
-var firstChar = customAlphabet(
-  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
-  1
-);
-var rest = customAlphabet(
-  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
-  11
+var serverIdAlphabet = customAlphabet(
+  "abcdefghijklmnopqrstuvwxyz0123456789",
+  12
 );
 function sanitizeServerLabel(name) {
   let sanitized = name.replace(/[^a-zA-Z0-9-_]/g, "_").replace(/_{2,}/g, "_").toLowerCase();
@@ -128,7 +124,10 @@ function sanitizeServerLabel(name) {
   return sanitized;
 }
 function generateSessionId() {
-  return firstChar() + rest();
+  return "sess_" + nanoid(21);
+}
+function generateServerId() {
+  return serverIdAlphabet();
 }
 function formatOAuthState(nonce, sessionId) {
   return `${nonce}${OAUTH_STATE_SEPARATOR}${sessionId}`;
@@ -159,6 +158,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;
@@ -175,7 +227,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()) {
@@ -189,7 +242,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) {
@@ -202,7 +256,8 @@ function normalizeStoredSession(session) {
     status,
     createdAt,
     updatedAt,
-    expiresAt
+    expiresAt,
+    toolPolicy: normalizeToolPolicy(session.toolPolicy, updatedAt)
   };
 }
 function isSessionExpired(session, now = Date.now()) {
@@ -1060,7 +1115,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) {
@@ -1084,7 +1140,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,
@@ -1098,7 +1154,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`);
@@ -1123,6 +1184,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) {
@@ -1295,7 +1357,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) {
@@ -1318,42 +1381,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") {
@@ -1370,36 +1439,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}`);
@@ -2314,7 +2383,15 @@ var MCPClient = class {
     if (!existingSession && this.serverId && this.serverUrl && this.callbackUrl) {
       this.createdAt = Date.now();
       const updatedAt = this.createdAt;
-      console.log(`[MCPClient] Creating pending session ${this.sessionId} for connection setup`);
+      this._onObservabilityEvent.fire({
+        type: "mcp:client:session_created",
+        level: "info",
+        message: `Creating pending session ${this.sessionId} for connection setup`,
+        sessionId: this.sessionId,
+        serverId: this.serverId,
+        timestamp: Date.now(),
+        id: nanoid()
+      });
       await sessions.create({
         sessionId: this.sessionId,
         userId: this.userId,
@@ -2444,7 +2521,15 @@ var MCPClient = class {
       this.transportType = transportType;
       this.emitStateChange("CONNECTED");
       this.emitProgress("Connected successfully");
-      console.log(`[MCPClient] Saving active session ${this.sessionId} (connect success)`);
+      this._onObservabilityEvent.fire({
+        type: "mcp:client:session_saved",
+        level: "info",
+        message: `Saving active session ${this.sessionId} (connect success)`,
+        sessionId: this.sessionId,
+        serverId: this.serverId,
+        timestamp: Date.now(),
+        id: nanoid()
+      });
       await this.saveSession("active");
     } catch (error) {
       if (error instanceof UnauthorizedError$1 || error instanceof Error && error.message.toLowerCase().includes("unauthorized")) {
@@ -2461,7 +2546,15 @@ var MCPClient = class {
           throw new Error(message);
         }
         this.emitStateChange("AUTHENTICATING");
-        console.log(`[MCPClient] Saving pending OAuth session ${this.sessionId}`);
+        this._onObservabilityEvent.fire({
+          type: "mcp:client:session_saved",
+          level: "info",
+          message: `Saving pending OAuth session ${this.sessionId}`,
+          sessionId: this.sessionId,
+          serverId: this.serverId,
+          timestamp: Date.now(),
+          id: nanoid()
+        });
         await this.saveSession("pending");
         if (this.serverId) {
           this._onConnectionEvent.fire({
@@ -2536,27 +2629,25 @@ var MCPClient = class {
           this.emitStateChange("AUTHENTICATED");
           authenticatedStateEmitted = true;
         }
-        this.emitProgress("Creating authenticated client...");
-        this.client = new Client(
-          {
-            name: MCP_CLIENT_NAME,
-            version: MCP_CLIENT_VERSION
-          },
-          {
-            capabilities: {
-              extensions: {
-                "io.modelcontextprotocol/ui": {
-                  mimeTypes: ["text/html+mcp"]
-                }
-              }
-            }
-          }
-        );
         this.emitStateChange("CONNECTING");
+        if (this.client.transport) {
+          try {
+            await this.client.close();
+          } catch {
+          }
+        }
         await this.client.connect(this.transport);
         this.transportType = currentType;
         this.emitStateChange("CONNECTED");
-        console.log(`[MCPClient] Saving active session ${this.sessionId} (OAuth complete)`);
+        this._onObservabilityEvent.fire({
+          type: "mcp:client:session_saved",
+          level: "info",
+          message: `Saving active session ${this.sessionId} (OAuth complete)`,
+          sessionId: this.sessionId,
+          serverId: this.serverId,
+          timestamp: Date.now(),
+          id: nanoid()
+        });
         await this.saveSession("active");
         return;
       } catch (error) {
@@ -2591,24 +2682,28 @@ 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
    * @throws {Error} When client is not connected
    */
   async listTools() {
-    if (!this.client) {
-      throw new Error("Not connected to server");
-    }
     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",
@@ -2637,9 +2732,6 @@ var MCPClient = class {
    * @throws {Error} When client is not connected
    */
   async callTool(toolName, toolArgs) {
-    if (!this.client) {
-      throw new Error("Not connected to server");
-    }
     const request = {
       method: "tools/call",
       params: {
@@ -2693,9 +2785,6 @@ var MCPClient = class {
    * @throws {Error} When client is not connected
    */
   async listPrompts() {
-    if (!this.client) {
-      throw new Error("Not connected to server");
-    }
     this.emitStateChange("DISCOVERING");
     try {
       const request = {
@@ -2723,9 +2812,6 @@ var MCPClient = class {
    * @throws {Error} When client is not connected
    */
   async getPrompt(name, args) {
-    if (!this.client) {
-      throw new Error("Not connected to server");
-    }
     const request = {
       method: "prompts/get",
       params: {
@@ -2743,9 +2829,6 @@ var MCPClient = class {
    * @throws {Error} When client is not connected
    */
   async listResources() {
-    if (!this.client) {
-      throw new Error("Not connected to server");
-    }
     this.emitStateChange("DISCOVERING");
     try {
       const request = {
@@ -2772,9 +2855,6 @@ var MCPClient = class {
    * @throws {Error} When client is not connected
    */
   async readResource(uri) {
-    if (!this.client) {
-      throw new Error("Not connected to server");
-    }
     const request = {
       method: "resources/read",
       params: {
@@ -2830,7 +2910,16 @@ var MCPClient = class {
     try {
       await this.ensureSession();
     } catch (error) {
-      console.warn("[MCPClient] Initialization failed during clearSession:", error);
+      this._onObservabilityEvent.fire({
+        type: "mcp:client:error",
+        level: "warn",
+        message: "Initialization failed during clearSession",
+        sessionId: this.sessionId,
+        serverId: this.serverId,
+        payload: { error: String(error) },
+        timestamp: Date.now(),
+        id: nanoid()
+      });
     }
     if (this.oauthProvider) {
       await this.oauthProvider.invalidateCredentials("all");
@@ -2941,6 +3030,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;
@@ -3006,7 +3155,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.
@@ -3241,6 +3392,12 @@ var SSEConnectionManager = class {
         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;
@@ -3297,7 +3454,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
       }))
     };
   }
@@ -3307,7 +3465,7 @@ var SSEConnectionManager = class {
   async connect(params) {
     const { serverName, serverUrl, callbackUrl, transportType } = params;
     const headers = normalizeHeaders(params.headers);
-    const serverId = params.serverId && params.serverId.length <= 12 ? params.serverId : await sessions.generateSessionId();
+    const serverId = params.serverId && params.serverId.length <= 12 ? params.serverId : generateServerId();
     const existingSessions = await sessions.list(this.userId);
     const duplicate = existingSessions.find(
       (s) => s.serverId === serverId || s.serverUrl === serverUrl
@@ -3345,7 +3503,7 @@ var SSEConnectionManager = class {
         this.sendEvent(event);
       });
       await client.connect();
-      await client.listTools();
+      await this.listPolicyFilteredTools(sessionId);
       return {
         sessionId,
         success: true
@@ -3416,22 +3574,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,
@@ -3481,7 +3715,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({
@@ -3529,7 +3763,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({