@mcp-ts/sdk 2.4.5 → 2.5.1

package/src/server/handlers/sse-handler.ts

@@ -18,6 +18,7 @@ import type {
   McpRpcResponse,
   ConnectParams,
   DisconnectParams,
+  ReconnectParams,
   SessionParams,
   CallToolParams,
   GetPromptParams,
@@ -32,13 +33,19 @@ import type {
   ListPromptsResult,
   ListResourcesResult,
   CallToolResult,
+  SetToolPolicyParams,
+  SetToolPolicyResult,
+  GetToolPolicyParams,
+  GetToolPolicyResult,
 } from '../../shared/types.js';
 import { RpcErrorCodes } from '../../shared/errors.js';
 import { UnauthorizedError } from '../../shared/errors.js';
 import { isConnectionEvent, isRpcResponseEvent } from '../../shared/event-routing.js';
 import { parseOAuthState } from '../../shared/utils.js';
 import { MCPClient } from '../mcp/oauth-client.js';
-import { sessions, generateServerId } from '../storage/index.js';
+import { sessions, generateServerId, type Session } from '../storage/index.js';
+import { createToolId, isToolAllowed, normalizeToolPolicyForUpdate, validateToolPolicyAgainstTools } from '../storage/tool-policy.js';
+import { createToolPolicyGateway } from '../mcp/tool-policy-gateway.js';
 
 // ============================================
 // Types & Interfaces
@@ -149,7 +156,7 @@ export class SSEConnectionManager {
    */
   async handleRequest(request: McpRpcRequest): Promise<McpRpcResponse> {
     try {
-      let result: SessionListResult | ConnectResult | DisconnectResult | GetSessionResult | FinishAuthResult | ListToolsRpcResult | ListPromptsResult | ListResourcesResult | unknown;
+      let result: SessionListResult | ConnectResult | DisconnectResult | GetSessionResult | FinishAuthResult | ListToolsRpcResult | SetToolPolicyResult | GetToolPolicyResult | ListPromptsResult | ListResourcesResult | unknown;
 
       switch (request.method) {
         case 'listSessions':
@@ -160,6 +167,10 @@ export class SSEConnectionManager {
           result = await this.connect(request.params as ConnectParams);
           break;
 
+        case 'reconnect':
+          result = await this.reconnect(request.params as ReconnectParams);
+          break;
+
         case 'disconnect':
           result = await this.disconnect(request.params as DisconnectParams);
           break;
@@ -168,6 +179,14 @@ export class SSEConnectionManager {
           result = await this.listTools(request.params as SessionParams);
           break;
 
+        case 'setToolPolicy':
+          result = await this.setToolPolicy(request.params as SetToolPolicyParams);
+          break;
+
+        case 'getToolPolicy':
+          result = await this.getToolPolicy(request.params as GetToolPolicyParams);
+          break;
+
         case 'callTool':
           result = await this.callTool(request.params as CallToolParams);
           break;
@@ -241,6 +260,7 @@ export class SSEConnectionManager {
         createdAt: s.createdAt,
         updatedAt: s.updatedAt ?? s.createdAt,
         status: s.status ?? 'pending',
+        toolPolicy: s.toolPolicy,
       })),
     };
   }
@@ -315,8 +335,8 @@ export class SSEConnectionManager {
       // Attempt connection
       await client.connect();
 
-      // Fetch tools
-      await client.listTools();
+      // Fetch policy-filtered tools for agent-facing discovery
+      await this.listPolicyFilteredTools(sessionId);
 
       return {
         sessionId,
@@ -348,6 +368,87 @@ export class SSEConnectionManager {
     }
   }
 
+  /**
+   * 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.
+   */
+  private async reconnect(params: ReconnectParams): Promise<ConnectResult> {
+    const { serverId: rawServerId, serverName, serverUrl, callbackUrl, transportType } = params;
+    const headers = normalizeHeaders(params.headers);
+
+    // Normalize serverId the same way connect() does
+    const serverId = rawServerId && rawServerId.length <= 12
+      ? rawServerId
+      : generateServerId();
+
+    // Find existing session for the same server to reuse its session ID
+    const existingSessions = await sessions.list(this.userId);
+    const duplicate = existingSessions.find(s =>
+      s.serverId === serverId || s.serverUrl === serverUrl
+    );
+
+    // Reuse the duplicate sessionId if present, otherwise generate a new one
+    const sessionId = duplicate ? duplicate.sessionId : await sessions.generateSessionId();
+
+    if (duplicate) {
+      // Disconnect any active in-memory client transport without deleting the database session
+      const existingClient = this.clients.get(duplicate.sessionId);
+      if (existingClient) {
+        await existingClient.disconnect();
+        this.clients.delete(duplicate.sessionId);
+      }
+    }
+
+    try {
+      const clientMetadata = await this.getResolvedClientMetadata();
+
+      // Create a new client instantiating the reused session ID (which preserves DCR credentials and tokens)
+      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
    */
@@ -407,23 +508,109 @@ export class SSEConnectionManager {
     return client;
   }
 
+  private async listPolicyFilteredTools(sessionId: string): Promise<{ session: Session; result: ListToolsRpcResult }> {
+    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
    */
   private async listTools(params: SessionParams): Promise<ListToolsRpcResult> {
     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.
+   */
+  private async getToolPolicy(params: GetToolPolicyParams): Promise<GetToolPolicyResult> {
+    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' as const,
+      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.
+   */
+  private async setToolPolicy(params: SetToolPolicyParams): Promise<SetToolPolicyResult> {
+    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
    */
   private async callTool(params: CallToolParams): Promise<CallToolResult> {
     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);
 
     // Inject sessionId into meta so client knows who handled it
     // This allows AppHost to auto-launch without scanning all sessions
@@ -485,7 +672,7 @@ export class SSEConnectionManager {
       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) {
@@ -541,7 +728,7 @@ export class SSEConnectionManager {
       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) {
@@ -687,3 +874,9 @@ function writeSSEEvent(res: { write: Function }, event: string, data: unknown):
   res.write(`event: ${event}\n`);
   res.write(`data: ${JSON.stringify(data)}\n\n`);
 }
+
+
+
+
+
+

package/src/server/mcp/multi-session-client.ts

@@ -1,6 +1,7 @@
 import { MCPClient } from './oauth-client.js';
 import { sessions, type Session } from '../storage/index.js';
-import type { ToolClientProvider } from '../../shared/types.js';
+import type { ToolClient, ToolClientProvider } from '../../shared/types.js';
+import { createToolPolicyGateway } from './tool-policy-gateway.js';
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -148,8 +149,10 @@ export class MultiSessionClient implements ToolClientProvider {
      * Use this to enumerate available tools across all connected servers,
      * or to route a tool call to the right client by `serverId`.
      */
-    getClients(): MCPClient[] {
-        return this.clients;
+    getClients(): ToolClient[] {
+        return this.clients.map((client) =>
+            createToolPolicyGateway(this.userId, client.getSessionId(), client)
+        );
     }
 
     /**
@@ -321,3 +324,4 @@ export class MultiSessionClient implements ToolClientProvider {
         );
     }
 }
+

package/src/server/mcp/oauth-client.ts

@@ -781,6 +781,21 @@ export class MCPClient {
     }
   }
 
+  /**
+   * 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(): Promise<ListToolsResult> {
+    const request: ListToolsRequest = {
+      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
@@ -790,14 +805,7 @@ export class MCPClient {
     this.emitStateChange('DISCOVERING');
 
     try {
-      const request: ListToolsRequest = {
-        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({
@@ -821,7 +829,6 @@ export class MCPClient {
       throw error;
     }
   }
-
   /**
    * Executes a tool on the connected MCP server
    * @param toolName - Name of the tool to execute
@@ -830,7 +837,6 @@ export class MCPClient {
    * @throws {Error} When client is not connected
    */
   async callTool(toolName: string, toolArgs: Record<string, unknown>): Promise<CallToolResult> {
-
     const request: CallToolRequest = {
       method: 'tools/call',
       params: {
@@ -1173,3 +1179,12 @@ export class MCPClient {
   }
 
 }
+
+
+
+
+
+
+
+
+

package/src/server/mcp/tool-policy-gateway.ts

@@ -0,0 +1,90 @@
+import type { Tool, ListToolsResult, CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { ToolClient } from '../../shared/types.js';
+import { sessions } from '../storage/index.js';
+import type { Session } from '../storage/types.js';
+import { assertToolAllowed, filterToolsByPolicy } from '../storage/tool-policy.js';
+
+type RawToolClient = ToolClient & {
+    fetchTools(): Promise<{ tools: Tool[] }>;
+    listTools(): Promise<{ tools: Tool[] }>;
+    callTool(name: string, args: Record<string, unknown>): Promise<CallToolResult>;
+};
+
+export class ToolPolicyGateway implements ToolClient {
+    constructor(
+        private readonly userId: string,
+        private readonly sessionId: string,
+        private readonly client: RawToolClient
+    ) {}
+
+    isConnected(): boolean {
+        return this.client.isConnected();
+    }
+
+    getServerId(): string | undefined {
+        return this.client.getServerId?.();
+    }
+
+    getServerName(): string | undefined {
+        return this.client.getServerName?.();
+    }
+
+    getServerUrl(): string | undefined {
+        return this.client.getServerUrl?.();
+    }
+
+    getSessionId(): string {
+        return this.client.getSessionId?.() ?? this.sessionId;
+    }
+
+    async listTools(): Promise<ListToolsResult> {
+        const session = await this.getSession();
+        const result = await this.client.fetchTools();
+        const tools = this.filterTools(session, result.tools);
+
+        return {
+            ...result,
+            tools,
+        } as ListToolsResult;
+    }
+
+    async listAllTools(): Promise<ListToolsResult> {
+        return await this.client.fetchTools() as ListToolsResult;
+    }
+
+    async callTool(name: string, args: Record<string, unknown>): Promise<CallToolResult> {
+        const session = await this.getSession();
+        this.assertAllowed(session, name);
+        return await this.client.callTool(name, args);
+    }
+
+    filterTools(session: Session, tools: Tool[]): Tool[] {
+        return filterToolsByPolicy(tools, session.toolPolicy, this.getPolicyServerId(session));
+    }
+
+    assertAllowed(session: Session, toolName: string): void {
+        assertToolAllowed(session.toolPolicy, toolName, this.getPolicyServerId(session));
+    }
+
+    private async getSession(): Promise<Session> {
+        const session = await sessions.get(this.userId, this.sessionId);
+        if (!session) {
+            throw new Error('Session not found');
+        }
+        return session;
+    }
+
+    private getPolicyServerId(session: Session): string | undefined {
+        return this.client.getServerId?.() ?? session.serverId;
+    }
+}
+
+export function createToolPolicyGateway(
+    userId: string,
+    sessionId: string,
+    client: RawToolClient
+): ToolPolicyGateway {
+    return new ToolPolicyGateway(userId, sessionId, client);
+}
+
+

package/src/server/storage/neon-backend.ts

@@ -4,6 +4,7 @@ import { DORMANT_SESSION_EXPIRATION_MS } from '../../shared/constants.js';
 import { generateSessionId } from '../../shared/utils.js';
 import { encryptObject, decryptObject } from './crypto.js';
 import { resolveSessionExpiresAt } from './session-lifecycle.js';
+import { normalizeToolPolicy } from './tool-policy.js';
 
 export interface NeonStorageOptions {
     schema?: string;
@@ -30,6 +31,7 @@ type NeonSessionRow = {
     headers?: unknown;
     auth_url?: string | null;
     status?: SessionStatus | null;
+    tool_policy?: unknown;
 };
 
 type NeonCredentialsRow = {
@@ -103,6 +105,7 @@ export class NeonStorageBackend implements SessionStore {
             headers: decryptObject(row.headers),
             authUrl: row.auth_url ?? undefined,
             status: row.status ?? 'pending',
+            toolPolicy: normalizeToolPolicy(row.tool_policy as Parameters<typeof normalizeToolPolicy>[0]),
         };
     }
 
@@ -135,43 +138,35 @@ export class NeonStorageBackend implements SessionStore {
         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: string[] = [
+            '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: unknown[] = [
+            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: any) {
             if (error.code === '23505') {
@@ -200,38 +195,44 @@ export class NeonStorageBackend implements SessionStore {
             'callbackUrl' in data ||
             'status' in data ||
             'headers' in data ||
-            'authUrl' in data
+            'authUrl' in data ||
+            'toolPolicy' in data
         );
 
         if (shouldUpdateSession) {
+            const setClauses: string[] = [];
+            const values: unknown[] = [];
+            let paramIndex = 1;
+
+            const addSet = (column: string, value: unknown) => {
+                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' as const, 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]
             ) as Array<{ id: string }>;
 
             if (updatedRows.length === 0) {
@@ -412,3 +413,7 @@ export class NeonStorageBackend implements SessionStore {
         // Neon HTTP queries do not hold a persistent connection.
     }
 }
+
+
+
+

package/src/server/storage/session-lifecycle.ts

@@ -4,6 +4,7 @@ import {
     STATE_EXPIRATION_MS,
 } from '../../shared/constants.js';
 import type { Session, SessionStatus } from './types.js';
+import { normalizeToolPolicy } from './tool-policy.js';
 
 export function resolveSessionExpiresAt(status: SessionStatus = 'pending', referenceTime = Date.now()): number | null {
     return status === 'active' ? null : referenceTime + STATE_EXPIRATION_MS;
@@ -26,6 +27,7 @@ export function normalizeNewSession(session: Session, now = Date.now()): Session
         createdAt,
         updatedAt,
         expiresAt: resolveSessionExpiresAt(status, status === 'active' ? updatedAt : createdAt),
+        toolPolicy: normalizeToolPolicy(session.toolPolicy, updatedAt),
     };
 }
 
@@ -46,6 +48,7 @@ export function mergeSessionUpdate(
         ...updated,
         status,
         expiresAt: resolveSessionExpiresAt(status, updatedAt),
+        toolPolicy: normalizeToolPolicy(updated.toolPolicy, updatedAt),
     };
 }
 
@@ -63,6 +66,7 @@ export function normalizeStoredSession(session: Session): Session {
         createdAt,
         updatedAt,
         expiresAt,
+        toolPolicy: normalizeToolPolicy(session.toolPolicy, updatedAt),
     };
 }
 
@@ -76,3 +80,4 @@ export function isSessionExpired(session: Session, now = Date.now()): boolean {
 
     return typeof hydrated.expiresAt === 'number' && hydrated.expiresAt < now;
 }
+