@aws/lsp-codewhisperer 0.0.65 → 0.0.67

package/out/language-server/agenticChat/tools/mcp/mcpManager.js

@@ -6,15 +6,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.McpManager = exports.AGENT_TOOLS_CHANGED = exports.MCP_SERVER_STATUS_CHANGED = void 0;
 const types_1 = require("../../../../shared/telemetry/types");
-const mcpUtils_1 = require("./mcpUtils");
 const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
 const mcpTypes_1 = require("./mcpTypes");
-const mcpUtils_2 = require("./mcpUtils");
+const mcpUtils_1 = require("./mcpUtils");
 const errors_1 = require("../../errors");
 const events_1 = require("events");
 const async_mutex_1 = require("async-mutex");
-const path = require("path");
 const vscode_uri_1 = require("vscode-uri");
 exports.MCP_SERVER_STATUS_CHANGED = 'mcpServerStatusChanged';
 exports.AGENT_TOOLS_CHANGED = 'agentToolsChanged';
@@ -22,8 +20,7 @@ exports.AGENT_TOOLS_CHANGED = 'agentToolsChanged';
  * Manages MCP servers and their tools
  */
 class McpManager {
-    configPaths;
-    personaPaths;
+    agentPaths;
     features;
     static #instance;
     clients;
@@ -37,9 +34,9 @@ class McpManager {
     static personaMutex = new async_mutex_1.Mutex();
     toolNameMapping;
     serverNameMapping;
-    constructor(configPaths, personaPaths, features) {
-        this.configPaths = configPaths;
-        this.personaPaths = personaPaths;
+    agentConfig;
+    constructor(agentPaths, features) {
+        this.agentPaths = agentPaths;
         this.features = features;
         this.mcpTools = [];
         this.clients = new Map();
@@ -48,21 +45,21 @@ class McpManager {
         this.configLoadErrors = new Map();
         this.mcpServerPermissions = new Map();
         this.events = new events_1.EventEmitter({ captureRejections: true }).on('error', console.error);
-        this.features.logging.info(`MCP manager: initialized with ${configPaths.length} configs`);
+        this.features.logging.info(`MCP manager: initialized with ${agentPaths.length} configs`);
         this.toolNameMapping = new Map();
         this.serverNameMapping = new Map();
     }
-    static async init(configPaths, personaPaths, features) {
+    static async init(agentPaths, features) {
         if (!McpManager.#instance) {
-            const mgr = new McpManager(configPaths, personaPaths, features);
+            const mgr = new McpManager(agentPaths, features);
             McpManager.#instance = mgr;
             await mgr.discoverAllServers();
             features.logging.info(`MCP: discovered ${mgr.mcpTools.length} tools across all servers`);
             // Emit MCP configuration metrics
             const serverConfigs = mgr.getAllServerConfigs();
-            const activeServers = Array.from(serverConfigs.entries()).filter(([name, _]) => !mgr.isServerDisabled(name));
+            const activeServers = Array.from(serverConfigs.entries());
             // Count global vs project servers
-            const globalServers = Array.from(serverConfigs.entries()).filter(([_, config]) => config?.__configPath__ === (0, mcpUtils_1.getGlobalMcpConfigPath)(features.workspace.fs.getUserHomeDir())).length;
+            const globalServers = Array.from(serverConfigs.entries()).filter(([_, config]) => config?.__configPath__ === (0, mcpUtils_1.getGlobalAgentConfigPath)(features.workspace.fs.getUserHomeDir())).length;
             const projectServers = serverConfigs.size - globalServers;
             // Count tools by permission
             let toolsAlwaysAllowed = 0;
@@ -118,30 +115,69 @@ class McpManager {
      * Load configurations and initialize each enabled server.
      */
     async discoverAllServers() {
-        const permissionMap = await (0, mcpUtils_2.loadPersonaPermissions)(this.features.workspace, this.features.logging, this.personaPaths);
-        this.mcpServerPermissions = permissionMap;
-        const { servers, serverNameMapping, errors } = await (0, mcpUtils_2.loadMcpServerConfigs)(this.features.workspace, this.features.logging, this.configPaths);
-        this.mcpServers = servers;
-        this.serverNameMapping = serverNameMapping;
+        // Load agent config
+        const result = await (0, mcpUtils_1.loadAgentConfig)(this.features.workspace, this.features.logging, this.agentPaths);
+        // Extract agent config and other data
+        this.agentConfig = result.agentConfig;
+        this.mcpServers = result.servers;
+        this.serverNameMapping = result.serverNameMapping;
         // Reset the configuration errors after every refresh.
         this.configLoadErrors.clear();
         // Store any config load errors
-        errors.forEach((errorMsg, key) => {
+        result.errors.forEach((errorMsg, key) => {
             this.configLoadErrors.set(key, errorMsg);
         });
-        // Set all servers to UNINITIALIZED state initially
-        for (const name of this.mcpServers.keys()) {
-            this.setState(name, mcpTypes_1.McpServerStatus.UNINITIALIZED, 0);
+        this.features.logging.info('Using agent configuration');
+        // Reset permissions map
+        this.mcpServerPermissions.clear();
+        // Initialize permissions for servers from agent config
+        for (const [sanitizedName, _] of this.mcpServers.entries()) {
+            const name = this.serverNameMapping.get(sanitizedName) || sanitizedName;
+            // Set server status to UNINITIALIZED initially
+            this.setState(sanitizedName, mcpTypes_1.McpServerStatus.UNINITIALIZED, 0);
+            // Initialize permissions for this server
+            const serverPrefix = `@${name}`;
+            // Extract tool permissions from agent config
+            const toolPerms = {};
+            // Check if the server is enabled as a whole (@server) or just specific tools (@server/tool)
+            const isWholeServerEnabled = this.agentConfig.tools.includes(serverPrefix);
+            if (isWholeServerEnabled) {
+                // Check for specific tools in allowedTools
+                this.agentConfig.allowedTools.forEach(allowedTool => {
+                    if (allowedTool.startsWith(serverPrefix + '/')) {
+                        const toolName = allowedTool.substring(serverPrefix.length + 1);
+                        if (toolName) {
+                            // This specific tool is in allowedTools
+                            toolPerms[toolName] = mcpTypes_1.McpPermissionType.alwaysAllow;
+                        }
+                    }
+                });
+            }
+            else {
+                // Only specific tools are enabled
+                this.agentConfig.tools.forEach(tool => {
+                    if (tool.startsWith(serverPrefix + '/')) {
+                        const toolName = tool.substring(serverPrefix.length + 1);
+                        if (toolName) {
+                            // Check if tool is in allowedTools
+                            if (this.agentConfig.allowedTools.includes(tool)) {
+                                toolPerms[toolName] = mcpTypes_1.McpPermissionType.alwaysAllow;
+                            }
+                            else {
+                                toolPerms[toolName] = mcpTypes_1.McpPermissionType.ask;
+                            }
+                        }
+                    }
+                });
+            }
+            this.mcpServerPermissions.set(sanitizedName, {
+                enabled: true,
+                toolPerms,
+            });
         }
         // Get all servers that need to be initialized
         const serversToInit = [];
         for (const [name, cfg] of this.mcpServers.entries()) {
-            if (this.isServerDisabled(name)) {
-                this.features.logging.info(`MCP: server '${name}' is disabled by persona settings, skipping`);
-                this.setState(name, mcpTypes_1.McpServerStatus.DISABLED, 0);
-                this.emitToolsChanged(name);
-                continue;
-            }
             serversToInit.push([name, cfg]);
         }
         // Process servers in batches of 5 at a time
@@ -171,7 +207,7 @@ class McpManager {
             const mergedEnv = {
                 ...process.env,
                 // Make sure we do not have empty key and value in mergedEnv, or adding server through UI will fail on Windows
-                ...(cfg.env && !(0, mcpUtils_2.isEmptyEnv)(cfg.env)
+                ...(cfg.env && !(0, mcpUtils_1.isEmptyEnv)(cfg.env)
                     ? Object.fromEntries(Object.entries(cfg.env).filter(([key]) => key && key.trim() !== ''))
                     : {}),
             };
@@ -208,8 +244,8 @@ class McpManager {
                 }
                 throw new errors_1.AgenticChatError(`MCP: server '${serverName}' failed to connect: ${errorMessage}`, 'MCPServerConnectionFailed');
             });
-            // 0 -> no timeout
-            if (cfg.initializationTimeout === 0) {
+            // 0 or undefined -> no timeout
+            if (cfg.initializationTimeout === 0 || cfg.initializationTimeout === undefined) {
                 await connectPromise;
             }
             else {
@@ -273,34 +309,73 @@ class McpManager {
      * Return a list of all enabled tools.
      */
     getEnabledTools() {
-        return this.mcpTools.filter(t => !this.isServerDisabled(t.serverName) && !this.isToolDisabled(t.serverName, t.toolName));
+        return this.mcpTools.filter(t => !this.isToolDisabled(t.serverName, t.toolName));
     }
     /**
      * Returns true if the given tool on the given server is currently disabled.
      */
     isToolDisabled(server, tool) {
-        return this.getToolPerm(server, tool) === mcpTypes_1.McpPermissionType.deny;
+        // built-in tools cannot be disabled
+        if (server === 'builtIn') {
+            return false;
+        }
+        // Check if the server is enabled as a whole (@server)
+        const serverPrefix = `@${server}`;
+        const isWholeServerEnabled = this.agentConfig.tools.includes(serverPrefix);
+        // Check if the specific tool is enabled
+        const toolId = `${serverPrefix}/${tool}`;
+        const isSpecificToolEnabled = this.agentConfig.tools.includes(toolId);
+        // If server is enabled as a whole, all tools are enabled
+        if (isWholeServerEnabled) {
+            return false;
+        }
+        // Otherwise, check if this specific tool is enabled
+        return !isSpecificToolEnabled;
     }
     /**
      * Returns true if the given server is currently disabled.
      */
-    isServerDisabled(name) {
-        const explicit = this.mcpServerPermissions.get(name)?.enabled;
-        const star = this.mcpServerPermissions.get('*')?.enabled;
-        return !(explicit ?? star ?? false);
-    }
+    // public isServerDisabled(name: string): boolean {
+    //     // Check if any tool from this server is enabled
+    //     return !this.agentConfig.tools.some(tool => {
+    //         if (tool.startsWith('@')) {
+    //             // Check if it's the server itself or a tool from the server
+    //             return tool === `@${name}` || tool.startsWith(`@${name}/`)
+    //         }
+    //         return false
+    //     })
+    // }
     /**
      * Returns tool permission type for a given tool.
      */
     getToolPerm(server, tool) {
-        const srv = this.mcpServerPermissions.get(server);
-        const star = this.mcpServerPermissions.get('*');
-        const result = srv?.toolPerms[tool] ??
-            srv?.toolPerms['*'] ??
-            star?.toolPerms[tool] ??
-            star?.toolPerms['*'] ??
-            mcpTypes_1.McpPermissionType.ask;
-        return result;
+        // For built-in tools, check directly without prefix
+        if (server === 'Built-in') {
+            return this.agentConfig.allowedTools.includes(tool) ? mcpTypes_1.McpPermissionType.alwaysAllow : mcpTypes_1.McpPermissionType.ask;
+        }
+        // Check if the server is enabled as a whole (@server)
+        const serverPrefix = `@${server}`;
+        const isWholeServerEnabled = this.agentConfig.tools.includes(serverPrefix);
+        // Check if the specific tool is enabled
+        const toolId = `${serverPrefix}/${tool}`;
+        const isSpecificToolEnabled = this.agentConfig.tools.includes(toolId);
+        // If the tool is not enabled, return deny
+        if (!isWholeServerEnabled && !isSpecificToolEnabled) {
+            return mcpTypes_1.McpPermissionType.deny;
+        }
+        // If server is enabled as a whole, check if the server itself is in allowedTools
+        if (isWholeServerEnabled) {
+            // If server is in allowedTools, all tools are alwaysAllow
+            if (this.agentConfig.allowedTools.includes(serverPrefix)) {
+                return mcpTypes_1.McpPermissionType.alwaysAllow;
+            }
+            // Otherwise, check if specific tool is in allowedTools
+            return this.agentConfig.allowedTools.includes(toolId)
+                ? mcpTypes_1.McpPermissionType.alwaysAllow
+                : mcpTypes_1.McpPermissionType.ask;
+        }
+        // For specific tools, check if it's in allowedTools
+        return this.agentConfig.allowedTools.includes(toolId) ? mcpTypes_1.McpPermissionType.alwaysAllow : mcpTypes_1.McpPermissionType.ask;
     }
     /**
      * Return a list of all server configurations.
@@ -308,9 +383,6 @@ class McpManager {
     getAllServerConfigs() {
         return new Map(this.mcpServers);
     }
-    getAllPermissions() {
-        return new Map(this.mcpServerPermissions);
-    }
     /**
      * Map server names to their available tool names.
      */
@@ -331,8 +403,7 @@ class McpManager {
         const cfg = this.mcpServers.get(server);
         if (!cfg)
             throw new Error(`MCP: server '${server}' is not configured`);
-        if (this.isServerDisabled(server))
-            throw new Error(`MCP: server '${server}' is disabled`);
+        // if (this.isServerDisabled(server)) throw new Error(`MCP: server '${server}' is disabled`)
         const available = this.getEnabledTools()
             .filter(t => t.serverName === server)
             .map(t => t.toolName);
@@ -366,43 +437,46 @@ class McpManager {
     /**
      * Add a new server: persist config, register in memory, and initialize.
      */
-    async addServer(serverName, cfg, configPath, personaPath) {
+    async addServer(serverName, cfg, agentPath) {
         try {
-            const sanitizedName = (0, mcpUtils_2.sanitizeName)(serverName);
-            if (this.mcpServers.has(sanitizedName)) {
+            const sanitizedName = (0, mcpUtils_1.sanitizeName)(serverName);
+            if (this.mcpServers.has(sanitizedName) &&
+                this.getServerState(sanitizedName)?.status == mcpTypes_1.McpServerStatus.ENABLED) {
                 throw new Error(`MCP: server '${sanitizedName}' already exists`);
             }
-            if (!configPath || !personaPath) {
-                throw new Error(`Both MCP config file path and Persona config file path are required`);
+            // Add server to agent config
+            const serverConfig = {
+                command: cfg.command,
+                initializationTimeout: cfg.initializationTimeout,
+            };
+            // Only add timeout to agent config if it's not 0
+            if (cfg.timeout !== 0) {
+                serverConfig.timeout = cfg.timeout;
+            }
+            if (cfg.args && cfg.args.length > 0) {
+                serverConfig.args = cfg.args;
             }
-            await this.mutateConfigFile(configPath, json => {
-                const serverConfig = {
-                    command: cfg.command,
-                    initializationTimeout: cfg.initializationTimeout,
-                    timeout: cfg.timeout,
-                };
-                if (cfg.args && cfg.args.length > 0) {
-                    serverConfig.args = cfg.args;
-                }
-                if (cfg.env && !(0, mcpUtils_2.isEmptyEnv)(cfg.env)) {
-                    serverConfig.env = cfg.env;
-                }
-                json.mcpServers[serverName] = serverConfig;
-            });
-            const newCfg = { ...cfg, __configPath__: configPath };
+            if (cfg.env && !(0, mcpUtils_1.isEmptyEnv)(cfg.env)) {
+                serverConfig.env = cfg.env;
+            }
+            // Add to agent config
+            this.agentConfig.mcpServers[serverName] = serverConfig;
+            // We don't need to store configPath anymore as we're using agent config
+            const newCfg = { ...cfg, __configPath__: agentPath };
             this.mcpServers.set(sanitizedName, newCfg);
             this.serverNameMapping.set(sanitizedName, serverName);
-            await this.mutatePersonaFile(personaPath, p => p.addServer(serverName));
-            this.personaPaths = [...new Set([...this.personaPaths, personaPath])];
-            const permissionMap = await (0, mcpUtils_2.loadPersonaPermissions)(this.features.workspace, this.features.logging, this.personaPaths);
-            this.mcpServerPermissions = permissionMap;
-            if (this.isServerDisabled(sanitizedName)) {
-                this.setState(sanitizedName, mcpTypes_1.McpServerStatus.DISABLED, 0);
-                this.emitToolsChanged(serverName);
-            }
-            else {
-                await this.initOneServer(sanitizedName, newCfg);
+            // Check if the server already has permissions in the agent config
+            const serverPrefix = `@${serverName}`;
+            const hasServerInTools = this.agentConfig.tools.some(tool => tool === serverPrefix || tool.startsWith(`${serverPrefix}/`));
+            // Only set permissions if the server doesn't already have them
+            if (!hasServerInTools) {
+                // Enable the server as a whole rather than individual tools
+                this.agentConfig.tools.push(serverPrefix);
             }
+            // Save agent config once with all changes
+            await (0, mcpUtils_1.saveAgentConfig)(this.features.workspace, this.features.logging, this.agentConfig, agentPath);
+            // Add server tools to tools list after initialization
+            await this.initOneServer(sanitizedName, newCfg);
         }
         catch (err) {
             this.features.logging.error(`Failed to add MCP server '${serverName}': ${err instanceof Error ? err.message : String(err)}`);
@@ -420,8 +494,6 @@ class McpManager {
         if (!cfg || !cfg.__configPath__) {
             throw new Error(`MCP: server '${serverName}' not found`);
         }
-        // Capture the remaining server keys before deletion for persona file update
-        const remainingServer = Array.from(this.mcpServers.keys()).filter(key => key !== serverName);
         const client = this.clients.get(serverName);
         if (client) {
             await client.close();
@@ -429,38 +501,54 @@ class McpManager {
         }
         this.mcpTools = this.mcpTools.filter(t => t.serverName !== serverName);
         this.mcpServerStates.delete(serverName);
-        // Remove from config file first
-        if (unsanitizedName) {
-            await this.mutateConfigFile(cfg.__configPath__, json => {
-                delete json.mcpServers[unsanitizedName];
+        // Remove from agent config
+        if (unsanitizedName && this.agentConfig) {
+            // Remove server from mcpServers
+            delete this.agentConfig.mcpServers[unsanitizedName];
+            // Remove server tools from tools list
+            this.agentConfig.tools = this.agentConfig.tools.filter(tool => {
+                if (tool.startsWith('@')) {
+                    if (tool === `@${unsanitizedName}`) {
+                        return false;
+                    }
+                    if (tool.startsWith(`@${unsanitizedName}/`)) {
+                        return false;
+                    }
+                }
+                return true;
             });
-        }
-        // Remove from persona file with the correct remaining server list
-        if (permission && permission.__configPath__ && unsanitizedName) {
-            await this.mutatePersonaFile(permission.__configPath__, p => p.removeServer(unsanitizedName, remainingServer));
+            // Remove server tools from allowedTools
+            this.agentConfig.allowedTools = this.agentConfig.allowedTools.filter(tool => {
+                if (tool.startsWith('@')) {
+                    if (tool === `@${unsanitizedName}`) {
+                        return false;
+                    }
+                    if (tool.startsWith(`@${unsanitizedName}/`)) {
+                        return false;
+                    }
+                }
+                return true;
+            });
+            // Save agent config
+            await (0, mcpUtils_1.saveAgentConfig)(this.features.workspace, this.features.logging, this.agentConfig, cfg.__configPath__);
         }
         this.mcpServers.delete(serverName);
         this.serverNameMapping.delete(serverName);
-        this.mcpServerPermissions.delete(serverName);
-        this.mcpServerPermissions = await (0, mcpUtils_2.loadPersonaPermissions)(this.features.workspace, this.features.logging, this.personaPaths);
         this.emitToolsChanged(serverName);
     }
     /**
      * Update a server: persist changes, teardown old client/tools, and re-init if enabled.
      */
-    async updateServer(serverName, configUpdates, configPath) {
+    async updateServer(serverName, configUpdates, agentPath) {
         try {
-            if (!configPath) {
-                throw new Error(`Missing configPath for '${serverName}'`);
-            }
             const oldCfg = this.mcpServers.get(serverName);
-            if (!oldCfg || !oldCfg.__configPath__) {
+            if (!oldCfg) {
                 throw new Error(`MCP: server '${serverName}' not found`);
             }
             const unsanitizedServerName = this.serverNameMapping.get(serverName);
-            await this.mutateConfigFile(configPath, json => {
-                json.mcpServers ||= {};
-                const updatedConfig = { ...(json.mcpServers[unsanitizedServerName] || {}) };
+            // Update agent config
+            if (this.agentConfig && unsanitizedServerName) {
+                const updatedConfig = { ...(this.agentConfig.mcpServers[unsanitizedServerName] || {}) };
                 if (configUpdates.command !== undefined)
                     updatedConfig.command = configUpdates.command;
                 if (configUpdates.initializationTimeout !== undefined)
@@ -476,19 +564,20 @@ class McpManager {
                     }
                 }
                 if (configUpdates.env !== undefined) {
-                    if (!(0, mcpUtils_2.isEmptyEnv)(configUpdates.env)) {
+                    if (!(0, mcpUtils_1.isEmptyEnv)(configUpdates.env)) {
                         updatedConfig.env = configUpdates.env;
                     }
                     else {
                         delete updatedConfig.env;
                     }
                 }
-                json.mcpServers[unsanitizedServerName] = updatedConfig;
-            });
+                this.agentConfig.mcpServers[unsanitizedServerName] = updatedConfig;
+                // Save agent config
+                await (0, mcpUtils_1.saveAgentConfig)(this.features.workspace, this.features.logging, this.agentConfig, agentPath);
+            }
             const newCfg = {
                 ...oldCfg,
                 ...configUpdates,
-                __configPath__: configPath,
             };
             const oldClient = this.clients.get(serverName);
             if (oldClient) {
@@ -498,13 +587,13 @@ class McpManager {
             this.mcpTools = this.mcpTools.filter(t => t.serverName !== serverName);
             this.mcpServers.set(serverName, newCfg);
             this.serverNameMapping.set(serverName, unsanitizedServerName);
-            if (this.isServerDisabled(serverName)) {
-                this.setState(serverName, mcpTypes_1.McpServerStatus.DISABLED, 0);
-                this.emitToolsChanged(serverName);
-            }
-            else {
-                await this.initOneServer(serverName, newCfg);
-            }
+            // if (this.isServerDisabled(serverName)) {
+            //     this.setState(serverName, McpServerStatus.DISABLED, 0)
+            //     this.emitToolsChanged(serverName)
+            // } else {
+            //     await this.initOneServer(serverName, newCfg)
+            // }
+            await this.initOneServer(serverName, newCfg);
         }
         catch (err) {
             this.handleError(serverName, err);
@@ -529,6 +618,17 @@ class McpManager {
         this.mcpTools = [];
         this.mcpServers.clear();
         this.mcpServerStates.clear();
+        this.agentConfig = {
+            name: 'default-agent',
+            version: '1.0.0',
+            description: 'Agent configuration',
+            mcpServers: {},
+            tools: [],
+            allowedTools: [],
+            toolsSettings: {},
+            includedFiles: [],
+            resources: [],
+        };
         if (!keepInstance) {
             McpManager.#instance = undefined;
         }
@@ -559,49 +659,106 @@ class McpManager {
      */
     async updateServerPermission(serverName, perm) {
         try {
-            const personaPath = perm.__configPath__;
-            if (!personaPath) {
-                throw new Error(`Missing personaPath for '${serverName}'`);
-            }
-            await this.mutatePersonaFile(personaPath, p => {
-                if (perm.enabled === undefined) {
-                    throw new Error('Server disabled state must be explicitly set');
-                }
-                const unsanitizedServerName = this.serverNameMapping.get(serverName);
-                // disable whole server
-                if (!perm.enabled) {
-                    p.removeServer(unsanitizedServerName, Array.from(this.mcpServers.keys())); // removes from list clears tool perms
-                    return;
-                }
-                // server must be enabled from here on
-                p.addServer(unsanitizedServerName);
-                // handle permission updates
-                if (perm.toolPerms) {
-                    const existing = p.toJson().toolPerms?.[unsanitizedServerName] ?? {};
-                    const merged = { ...existing, ...perm.toolPerms };
-                    p.replaceToolPerms(unsanitizedServerName, merged);
+            const unsanitizedServerName = this.serverNameMapping.get(serverName) || serverName;
+            // Get server config
+            // const serverConfig = this.mcpServers.get(serverName)
+            // if (!serverConfig) {
+            //     throw new Error(`Server '${serverName}' not found`)
+            // }
+            const serverPrefix = `@${unsanitizedServerName}`;
+            // Track tools that should be enabled
+            const toolsToEnable = new Set();
+            const toolsToAlwaysAllow = new Set();
+            // Check if server is enabled as a whole
+            const isWholeServerEnabled = this.agentConfig.tools.includes(serverPrefix);
+            // Process each tool permission
+            for (const [toolName, permission] of Object.entries(perm.toolPerms || {})) {
+                const toolId = (unsanitizedServerName !== 'Built-in' ? `${serverPrefix}/` : '') + `${toolName}`;
+                if (permission === mcpTypes_1.McpPermissionType.deny) {
+                    // For deny: if server is enabled as a whole, we need to switch to individual tools
+                    if (isWholeServerEnabled) {
+                        // Get all tools for this server
+                        const serverTools = this.mcpTools.filter(t => t.serverName === serverName);
+                        // Remove server prefix from tools
+                        this.agentConfig.tools = this.agentConfig.tools.filter(t => t !== serverPrefix);
+                        // Add all tools except the denied one
+                        for (const t of serverTools) {
+                            if (t.toolName !== toolName) {
+                                const tid = `${serverPrefix}/${t.toolName}`;
+                                if (!this.agentConfig.tools.includes(tid)) {
+                                    this.agentConfig.tools.push(tid);
+                                }
+                                toolsToEnable.add(tid);
+                            }
+                        }
+                    }
+                    else {
+                        // Just remove the specific tool
+                        this.agentConfig.tools = this.agentConfig.tools.filter(t => t !== toolId);
+                    }
+                    // Always remove from allowedTools
+                    this.agentConfig.allowedTools = this.agentConfig.allowedTools.filter(t => t !== toolId);
                 }
                 else {
-                    p.ensureWildcardAsk(unsanitizedServerName);
+                    // For ask or alwaysAllow: add to tools
+                    toolsToEnable.add(toolId);
+                    // For alwaysAllow: also add to allowedTools
+                    if (permission === mcpTypes_1.McpPermissionType.alwaysAllow) {
+                        toolsToAlwaysAllow.add(toolId);
+                    }
+                    else {
+                        // For ask: remove from allowedTools if present
+                        this.agentConfig.allowedTools = this.agentConfig.allowedTools.filter(t => t !== toolId);
+                    }
                 }
-            });
-            const permissionMap = await (0, mcpUtils_2.loadPersonaPermissions)(this.features.workspace, this.features.logging, this.personaPaths);
-            this.mcpServerPermissions = permissionMap;
-            // enable/disable server
-            if (this.isServerDisabled(serverName)) {
-                const client = this.clients.get(serverName);
-                if (client) {
-                    await client.close();
-                    this.clients.delete(serverName);
+            }
+            // If all tools are enabled, use @serverName instead of individual tools
+            const allTools = this.mcpTools.filter(t => t.serverName === serverName).map(t => t.toolName);
+            // Check if all tools are enabled, considering both:
+            // 1. The server might already be enabled as a whole (isWholeServerEnabled)
+            // 2. All tools might be individually enabled in toolsToEnable
+            const allToolsEnabled = allTools.length > 0 &&
+                // If server is already enabled as a whole and no tools are being denied
+                ((isWholeServerEnabled && !Object.values(perm.toolPerms || {}).includes(mcpTypes_1.McpPermissionType.deny)) ||
+                    // Or if all tools are individually enabled
+                    allTools.every(toolName => toolsToEnable.has(`${serverPrefix}/${toolName}`) ||
+                        !Object.keys(perm.toolPerms || {}).includes(toolName)));
+            // Update tools list
+            if (allToolsEnabled) {
+                // Remove individual tool entries
+                this.agentConfig.tools = this.agentConfig.tools.filter(t => !t.startsWith(`${serverPrefix}/`));
+                // Add server prefix if not already there
+                if (!this.agentConfig.tools.includes(serverPrefix)) {
+                    this.agentConfig.tools.push(serverPrefix);
                 }
-                this.setState(serverName, mcpTypes_1.McpServerStatus.DISABLED, 0);
             }
             else {
-                if (!this.clients.has(serverName)) {
-                    await this.initOneServer(serverName, this.mcpServers.get(serverName));
+                // Remove server prefix if present
+                this.agentConfig.tools = this.agentConfig.tools.filter(t => t !== serverPrefix);
+                // Add individual tools
+                for (const toolId of toolsToEnable) {
+                    if (!this.agentConfig.tools.includes(toolId)) {
+                        this.agentConfig.tools.push(toolId);
+                    }
                 }
             }
-            this.features.logging.info(`Permissions updated for '${serverName}' in ${personaPath}`);
+            // Update allowedTools list
+            for (const toolId of toolsToAlwaysAllow) {
+                if (!this.agentConfig.allowedTools.includes(toolId)) {
+                    this.agentConfig.allowedTools.push(toolId);
+                }
+            }
+            // Save agent config
+            const agentPath = perm.__configPath__;
+            if (agentPath) {
+                await (0, mcpUtils_1.saveAgentConfig)(this.features.workspace, this.features.logging, this.agentConfig, agentPath);
+            }
+            // Update mcpServerPermissions map
+            this.mcpServerPermissions.set(serverName, {
+                enabled: perm.enabled,
+                toolPerms: perm.toolPerms || {},
+            });
+            this.features.logging.info(`Permissions updated for '${serverName}' in agent config`);
             this.emitToolsChanged(serverName);
         }
         catch (err) {
@@ -609,73 +766,13 @@ class McpManager {
             return;
         }
     }
-    /**
-     * Read, mutate, and write the MCP JSON config at the given path.
-     * @private
-     */
-    async mutateConfigFile(configPath, mutator) {
-        return McpManager.configMutex
-            .runExclusive(async () => {
-            let json = { mcpServers: {} };
-            try {
-                const raw = await this.features.workspace.fs.readFile(configPath);
-                this.features.logging.info(`Updating MCP config file: ${configPath}`);
-                const existing = JSON.parse(raw.toString());
-                json = { mcpServers: {}, ...existing };
-            }
-            catch (err) {
-                // ignore fire not exist error
-                if (err?.code !== 'ENOENT')
-                    throw err;
-            }
-            mutator(json);
-            let fsPath;
-            try {
-                const uri = vscode_uri_1.URI.parse(configPath);
-                fsPath = uri.scheme === 'file' ? uri.fsPath : configPath;
-            }
-            catch {
-                fsPath = configPath;
-            }
-            fsPath = path.normalize(fsPath);
-            const dir = path.dirname(fsPath);
-            await this.features.workspace.fs.mkdir(dir, { recursive: true });
-            await this.features.workspace.fs.writeFile(fsPath, JSON.stringify(json, null, 2));
-            this.features.logging.debug(`MCP config file write complete: ${configPath}`);
-        })
-            .catch((e) => {
-            this.features.logging.error(`MCP: failed to update config at ${configPath}: ${e.message}`);
-            throw e;
-        });
-    }
-    /**
-     * Read, mutate, and write the Persona YAML config at the given path.
-     * @private
-     */
-    async mutatePersonaFile(personaPath, mutator) {
-        await McpManager.personaMutex
-            .runExclusive(async () => {
-            this.features.logging.info(`Updating persona file: ${personaPath}`);
-            let raw = '';
-            try {
-                raw = (await this.features.workspace.fs.readFile(personaPath)).toString();
-            }
-            catch { }
-            const model = mcpTypes_1.PersonaModel.fromJson(raw ? JSON.parse(raw) : {});
-            mutator(model);
-            await this.features.workspace.fs.writeFile(personaPath, JSON.stringify(model.toJson(), null, 2));
-            this.features.logging.debug(`Persona file write complete: ${personaPath}`);
-        })
-            .catch((e) => {
-            this.features.logging.error(`MCP: failed to update persona file at ${personaPath}: ${e.message}`);
-            throw e;
-        });
-    }
     /**
      * Check if a tool requires approval.
      */
     requiresApproval(server, tool) {
-        return this.getToolPerm(server, tool) === mcpTypes_1.McpPermissionType.ask;
+        // For built-in tools, check directly without prefix
+        const toolId = server === 'Built-in' ? tool : `@${server}/${tool}`;
+        return !this.agentConfig.allowedTools.includes(toolId);
     }
     /**
      * Updates the runtime state for a given server, including status, tool count, and optional error message.
@@ -723,7 +820,7 @@ class McpManager {
             .join('\n\n');
     }
     /**
-     * Remove a server from the config file but keep it in memory.
+     * Remove a server from the agent config file but keep it in memory.
      * This is used when there's a server status error during initialization.
      */
     async removeServerFromConfigFile(serverName) {
@@ -733,13 +830,41 @@ class McpManager {
                 this.features.logging.warn(`Cannot remove config for server '${serverName}': Config not found or missing path`);
                 return;
             }
-            await this.mutateConfigFile(cfg.__configPath__, json => {
-                delete json.mcpServers[this.serverNameMapping.get(serverName)];
-            });
-            this.features.logging.info(`Removed server '${serverName}' from config file but kept in memory`);
+            const unsanitizedName = this.serverNameMapping.get(serverName) || serverName;
+            // Remove from agent config
+            if (unsanitizedName && this.agentConfig) {
+                // Remove server from mcpServers
+                delete this.agentConfig.mcpServers[unsanitizedName];
+                // Remove server tools from tools list
+                this.agentConfig.tools = this.agentConfig.tools.filter(tool => {
+                    if (tool.startsWith('@')) {
+                        if (tool === `@${unsanitizedName}`) {
+                            return false;
+                        }
+                        if (tool.startsWith(`@${unsanitizedName}/`)) {
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+                // Remove server tools from allowedTools
+                this.agentConfig.allowedTools = this.agentConfig.allowedTools.filter(tool => {
+                    if (tool.startsWith('@')) {
+                        if (tool === `@${unsanitizedName}`) {
+                            return false;
+                        }
+                        if (tool.startsWith(`@${unsanitizedName}/`)) {
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+                // Save agent config
+                await (0, mcpUtils_1.saveAgentConfig)(this.features.workspace, this.features.logging, this.agentConfig, cfg.__configPath__);
+            }
         }
         catch (err) {
-            this.features.logging.error(`Error removing server '${serverName}' from config file: ${err}`);
+            this.features.logging.error(`Error removing server '${serverName}' from agent config file: ${err}`);
         }
     }
     getOriginalToolNames(namespacedName) {
@@ -751,6 +876,18 @@ class McpManager {
     getToolNameMapping() {
         return new Map(this.toolNameMapping);
     }
+    /**
+     * Determines if a server is global or workspace-specific
+     * @param serverName The name of the server to check
+     * @returns true if the server is global, false if workspace-specific
+     */
+    isServerGlobal(serverName) {
+        const config = this.mcpServers.get(serverName);
+        if (!config)
+            return false;
+        const globalAgentPath = (0, mcpUtils_1.getGlobalAgentConfigPath)(this.features.workspace.fs.getUserHomeDir());
+        return config.__configPath__ === globalAgentPath;
+    }
     setToolNameMapping(mapping) {
         this.toolNameMapping = new Map(mapping);
     }