@mcp-ts/sdk 2.4.4 → 2.5.0

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

@@ -32,13 +32,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 } 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 +155,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':
@@ -168,6 +174,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 +255,7 @@ export class SSEConnectionManager {
         createdAt: s.createdAt,
         updatedAt: s.updatedAt ?? s.createdAt,
         status: s.status ?? 'pending',
+        toolPolicy: s.toolPolicy,
       })),
     };
   }
@@ -256,7 +271,7 @@ export class SSEConnectionManager {
     // Tool name format: tool_<serverId>_<toolName> - with 12 char serverId leaves 46 chars for tool name
     const serverId = params.serverId && params.serverId.length <= 12
       ? params.serverId
-      : await sessions.generateSessionId();
+      : generateServerId();
 
     // Check for existing connections
     const existingSessions = await sessions.list(this.userId);
@@ -315,8 +330,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,
@@ -407,23 +422,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 +586,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 +642,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 +788,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

@@ -360,7 +360,15 @@ export class MCPClient {
     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,
@@ -542,7 +550,15 @@ export class MCPClient {
 
       // Refresh session metadata on every successful connect so active sessions
       // record ongoing usage and don't look dormant to session cleanup jobs.
-      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) {
       /** Handle Authentication Errors */
@@ -580,7 +596,15 @@ export class MCPClient {
         }
 
         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) {
@@ -686,34 +710,30 @@ export class MCPClient {
           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'],
-                },
-              },
-            } as McpAppClientCapabilities
-          }
-        );
-
         this.emitStateChange('CONNECTING');
 
-        /** We explicitly try to connect with the transport we just auth'd with first */
+        // The SDK Client may still have a transport attached from a prior
+        // connect() that failed with UnauthorizedError; close it first so
+        // we can negotiate a fresh session with the newly-exchanged tokens.
+        if (this.client.transport) {
+          try { await this.client.close(); } catch {}
+        }
+
         await this.client.connect(this.transport);
 
         /** Connection succeeded — lock in the transport type */
         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; // Success, exit function
@@ -761,27 +781,31 @@ 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
    * @throws {Error} When client is not connected
    */
   async listTools(): Promise<ListToolsResult> {
-    if (!this.client) {
-      throw new Error('Not connected to server');
-    }
-
     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({
@@ -805,7 +829,6 @@ export class MCPClient {
       throw error;
     }
   }
-
   /**
    * Executes a tool on the connected MCP server
    * @param toolName - Name of the tool to execute
@@ -814,10 +837,6 @@ export class MCPClient {
    * @throws {Error} When client is not connected
    */
   async callTool(toolName: string, toolArgs: Record<string, unknown>): Promise<CallToolResult> {
-    if (!this.client) {
-      throw new Error('Not connected to server');
-    }
-
     const request: CallToolRequest = {
       method: 'tools/call',
       params: {
@@ -877,10 +896,6 @@ export class MCPClient {
    * @throws {Error} When client is not connected
    */
   async listPrompts(): Promise<ListPromptsResult> {
-    if (!this.client) {
-      throw new Error('Not connected to server');
-    }
-
     this.emitStateChange('DISCOVERING');
 
     try {
@@ -913,9 +928,6 @@ export class MCPClient {
    * @throws {Error} When client is not connected
    */
   async getPrompt(name: string, args?: Record<string, string>): Promise<GetPromptResult> {
-    if (!this.client) {
-      throw new Error('Not connected to server');
-    }
 
     const request: GetPromptRequest = {
       method: 'prompts/get',
@@ -936,10 +948,6 @@ export class MCPClient {
    * @throws {Error} When client is not connected
    */
   async listResources(): Promise<ListResourcesResult> {
-    if (!this.client) {
-      throw new Error('Not connected to server');
-    }
-
     this.emitStateChange('DISCOVERING');
 
     try {
@@ -971,9 +979,6 @@ export class MCPClient {
    * @throws {Error} When client is not connected
    */
   async readResource(uri: string): Promise<ReadResourceResult> {
-    if (!this.client) {
-      throw new Error('Not connected to server');
-    }
 
     const request: ReadResourceRequest = {
       method: 'resources/read',
@@ -1031,7 +1036,16 @@ export class MCPClient {
     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) {
@@ -1165,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/index.ts

@@ -9,7 +9,7 @@ import type { SessionStore, Session, SessionMutationEvent, SessionMutationListen
 
 // Re-export types
 export * from './types.js';
-export { generateSessionId } from '../../shared/utils.js';
+export { generateSessionId, generateServerId } from '../../shared/utils.js';
 export { RedisStorageBackend, MemoryStorageBackend, FileStorageBackend, SqliteStorage, SupabaseStorageBackend, NeonStorageBackend };
 
 export function createSupabaseStorageBackend(client: any): SupabaseStorageBackend {