@aws/lsp-codewhisperer 0.0.70 → 0.0.72

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

@@ -8,6 +8,8 @@ exports.McpManager = exports.AGENT_TOOLS_CHANGED = exports.MCP_SERVER_STATUS_CHA
 const types_1 = require("../../../../shared/telemetry/types");
 const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+const sse_js_1 = require("@modelcontextprotocol/sdk/client/sse.js");
 const mcpTypes_1 = require("./mcpTypes");
 const mcpUtils_1 = require("./mcpUtils");
 const errors_1 = require("../../errors");
@@ -15,6 +17,7 @@ const events_1 = require("events");
 const async_mutex_1 = require("async-mutex");
 const path = require("path");
 const vscode_uri_1 = require("vscode-uri");
+const utils_1 = require("../../../../shared/utils");
 exports.MCP_SERVER_STATUS_CHANGED = 'mcpServerStatusChanged';
 exports.AGENT_TOOLS_CHANGED = 'agentToolsChanged';
 /**
@@ -58,7 +61,7 @@ class McpManager {
             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());
+            const activeServers = Array.from(serverConfigs.entries()).filter(([name, _]) => !mgr.isServerDisabled(name));
             // Count global vs project servers
             const globalServers = Array.from(serverConfigs.entries()).filter(([_, config]) => config?.__configPath__ === (0, mcpUtils_1.getGlobalAgentConfigPath)(features.workspace.fs.getUserHomeDir())).length;
             const projectServers = serverConfigs.size - globalServers;
@@ -179,6 +182,12 @@ class McpManager {
         // 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
@@ -205,57 +214,91 @@ class McpManager {
         this.setState(serverName, mcpTypes_1.McpServerStatus.INITIALIZING, 0);
         try {
             this.features.logging.debug(`MCP: initializing server [${serverName}]`);
-            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_1.isEmptyEnv)(cfg.env)
-                    ? Object.fromEntries(Object.entries(cfg.env).filter(([key]) => key && key.trim() !== ''))
-                    : {}),
-            };
-            const transportConfig = {
-                command: cfg.command,
-                args: cfg.args ?? [],
-                env: mergedEnv,
-            };
-            try {
-                const workspaceFolders = this.features.workspace.getAllWorkspaceFolders();
-                if (workspaceFolders.length > 0) {
-                    transportConfig.cwd = vscode_uri_1.URI.parse(workspaceFolders[0].uri).fsPath;
-                }
-            }
-            catch {
-                this.features.logging.debug(`MCP: No workspace folder available for server [${serverName}], continuing without cwd`);
-            }
-            const transport = new stdio_js_1.StdioClientTransport(transportConfig);
             const client = new index_js_1.Client({
                 name: `mcp-client-${serverName}`,
                 version: '1.0.0',
             });
-            const connectPromise = client.connect(transport).catch(err => {
-                let errorMessage = err.message;
-                // Provide specific guidance for common command not found errors
-                if (err.code === 'ENOENT') {
-                    errorMessage = `Command '${cfg.command}' not found. Please ensure it's installed and available in your PATH.`;
-                }
-                else if (err.code === 'EINVAL') {
-                    errorMessage = `Invalid arguments. Please check the command and arguments.`;
+            let transport;
+            const isStdio = !!cfg.command;
+            const doConnect = async () => {
+                if (isStdio) {
+                    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_1.isEmptyEnv)(cfg.env)
+                            ? Object.fromEntries(Object.entries(cfg.env).filter(([k, v]) => k.trim() && v.trim()))
+                            : {}),
+                    };
+                    let cwd;
+                    try {
+                        const folders = this.features.workspace.getAllWorkspaceFolders();
+                        if (folders.length > 0)
+                            cwd = vscode_uri_1.URI.parse(folders[0].uri).fsPath;
+                    }
+                    catch {
+                        this.features.logging.debug(`MCP: no workspace folder for [${serverName}], continuing without cwd`);
+                    }
+                    transport = new stdio_js_1.StdioClientTransport({
+                        command: cfg.command,
+                        args: cfg.args ?? [],
+                        env: mergedEnv,
+                        cwd,
+                    });
+                    this.features.logging.info(`MCP: Connecting MCP server using StdioClientTransport`);
+                    try {
+                        await client.connect(transport);
+                    }
+                    catch (err) {
+                        let errorMessage = err?.message ?? String(err);
+                        if (err?.code === 'ENOENT') {
+                            errorMessage = `Command '${cfg.command}' not found. Please ensure it's installed and on your PATH.`;
+                        }
+                        else if (err?.code === 'EINVAL') {
+                            errorMessage = `Invalid arguments for command '${cfg.command}'.`;
+                        }
+                        else if (err?.code === -32000) {
+                            errorMessage = `MCP protocol error. The server may not be properly configured.`;
+                        }
+                        throw new errors_1.AgenticChatError(`MCP: server '${serverName}' failed to connect: ${errorMessage}`, 'MCPServerConnectionFailed');
+                    }
                 }
-                else if (err.code === -32000) {
-                    errorMessage = `MCP protocol error. The server may not be properly configured.`;
+                else {
+                    const base = new URL(cfg.url);
+                    try {
+                        try {
+                            // try streamable http first
+                            transport = new streamableHttp_js_1.StreamableHTTPClientTransport(base, this.buildHttpOpts(cfg.headers));
+                            this.features.logging.info(`MCP: Connecting MCP server using StreamableHTTPClientTransport`);
+                            await client.connect(transport);
+                        }
+                        catch (err) {
+                            // fallback to SSE
+                            this.features.logging.info(`MCP: streamable http connect failed for [${serverName}], fallback to SSEClientTransport: ${String(err)}`);
+                            transport = new sse_js_1.SSEClientTransport(new URL(cfg.url), this.buildSseOpts(cfg.headers));
+                            await client.connect(transport);
+                        }
+                    }
+                    catch (err) {
+                        let errorMessage = err?.message ?? String(err);
+                        throw new errors_1.AgenticChatError(`MCP: server '${serverName}' failed to connect: ${errorMessage}`, 'MCPServerConnectionFailed');
+                    }
                 }
-                throw new errors_1.AgenticChatError(`MCP: server '${serverName}' failed to connect: ${errorMessage}`, 'MCPServerConnectionFailed');
-            });
-            // 0 or undefined -> no timeout
-            if (cfg.initializationTimeout === 0 || cfg.initializationTimeout === undefined) {
-                await connectPromise;
+            };
+            const connectPromise = doConnect();
+            const timeoutMs = cfg.initializationTimeout === 0 || cfg.initializationTimeout === undefined
+                ? 0
+                : (cfg.initializationTimeout ?? DEFAULT_SERVER_INIT_TIMEOUT_MS);
+            if (timeoutMs > 0) {
+                await Promise.race([
+                    connectPromise,
+                    new Promise((_, reject) => {
+                        const t = setTimeout(() => reject(new errors_1.AgenticChatError(`MCP: server '${serverName}' initialization timed out after ${timeoutMs} ms`, 'MCPServerInitTimeout')), timeoutMs);
+                        t.unref();
+                    }),
+                ]);
             }
             else {
-                const timeoutMs = cfg.initializationTimeout ?? DEFAULT_SERVER_INIT_TIMEOUT_MS;
-                const timeoutPromise = new Promise((_, reject) => {
-                    const timer = setTimeout(() => reject(new errors_1.AgenticChatError(`MCP: server '${serverName}' initialization timed out after ${timeoutMs} ms`, 'MCPServerInitTimeout')), timeoutMs);
-                    timer.unref();
-                });
-                await Promise.race([connectPromise, timeoutPromise]);
+                await connectPromise;
             }
             this.clients.set(serverName, client);
             this.mcpTools = this.mcpTools.filter(t => t.serverName !== serverName);
@@ -269,7 +312,7 @@ class McpManager {
                 this.mcpTools.push({
                     serverName,
                     toolName: t.name,
-                    description: (0, mcpUtils_1.sanitizeContent)(t.description ?? ''),
+                    description: (0, utils_1.sanitizeInput)(t.description ?? ''),
                     inputSchema: t.inputSchema ?? {},
                 });
             }
@@ -287,6 +330,12 @@ class McpManager {
             this.handleError(serverName, e);
         }
     }
+    /**
+     * Update server map
+     */
+    updateServerMap(newMap) {
+        this.mcpServers = new Map(newMap);
+    }
     /**
      * Return a list of all discovered tools.
      */
@@ -310,7 +359,7 @@ class McpManager {
      * Return a list of all enabled tools.
      */
     getEnabledTools() {
-        return this.mcpTools.filter(t => !this.isToolDisabled(t.serverName, t.toolName));
+        return this.mcpTools.filter(t => !this.isServerDisabled(t.serverName) && !this.isToolDisabled(t.serverName, t.toolName));
     }
     /**
      * Returns true if the given tool on the given server is currently disabled.
@@ -320,8 +369,10 @@ class McpManager {
         if (server === 'builtIn') {
             return false;
         }
+        // Get unsanitized server name for prefix
+        const unsanitizedServerName = this.serverNameMapping.get(server) || server;
         // Check if the server is enabled as a whole (@server)
-        const serverPrefix = `@${server}`;
+        const serverPrefix = `@${unsanitizedServerName}`;
         const isWholeServerEnabled = this.agentConfig.tools.includes(serverPrefix);
         // Check if the specific tool is enabled
         const toolId = `${serverPrefix}/${tool}`;
@@ -336,16 +387,10 @@ class McpManager {
     /**
      * Returns true if the given server is currently disabled.
      */
-    // 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
-    //     })
-    // }
+    isServerDisabled(name) {
+        const cfg = this.mcpServers.get(name);
+        return cfg?.disabled ?? false;
+    }
     /**
      * Returns tool permission type for a given tool.
      */
@@ -354,8 +399,10 @@ class McpManager {
         if (server === 'builtIn') {
             return this.agentConfig.allowedTools.includes(tool) ? mcpTypes_1.McpPermissionType.alwaysAllow : mcpTypes_1.McpPermissionType.ask;
         }
+        // Get unsanitized server name for prefix
+        const unsanitizedServerName = this.serverNameMapping.get(server) || server;
         // Check if the server is enabled as a whole (@server)
-        const serverPrefix = `@${server}`;
+        const serverPrefix = `@${unsanitizedServerName}`;
         const isWholeServerEnabled = this.agentConfig.tools.includes(serverPrefix);
         // Check if the specific tool is enabled
         const toolId = `${serverPrefix}/${tool}`;
@@ -404,7 +451,8 @@ 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);
@@ -448,7 +496,9 @@ class McpManager {
             // Add server to agent config
             const serverConfig = {
                 command: cfg.command,
+                url: cfg.url,
                 initializationTimeout: cfg.initializationTimeout,
+                disabled: cfg.disabled ?? false,
             };
             // Only add timeout to agent config if it's not 0
             if (cfg.timeout !== 0) {
@@ -460,6 +510,9 @@ class McpManager {
             if (cfg.env && !(0, mcpUtils_1.isEmptyEnv)(cfg.env)) {
                 serverConfig.env = cfg.env;
             }
+            if (cfg.headers && !(0, mcpUtils_1.isEmptyEnv)(cfg.headers)) {
+                serverConfig.headers = cfg.headers;
+            }
             // Add to agent config
             this.agentConfig.mcpServers[serverName] = serverConfig;
             // We don't need to store configPath anymore as we're using agent config
@@ -475,7 +528,7 @@ class McpManager {
                 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);
+            await (0, mcpUtils_1.saveAgentConfig)(this.features.workspace, this.features.logging, this.agentConfig, agentPath, serverName);
             // Add server tools to tools list after initialization
             await this.initOneServer(sanitizedName, newCfg);
         }
@@ -531,7 +584,7 @@ class McpManager {
                 return true;
             });
             // Save agent config
-            await (0, mcpUtils_1.saveAgentConfig)(this.features.workspace, this.features.logging, this.agentConfig, cfg.__configPath__);
+            await (0, mcpUtils_1.saveAgentConfig)(this.features.workspace, this.features.logging, this.agentConfig, cfg.__configPath__, unsanitizedName);
             // Get all config paths and delete the server from each one
             const wsUris = this.features.workspace.getAllWorkspaceFolders()?.map(f => f.uri) ?? [];
             const wsConfigPaths = (0, mcpUtils_1.getWorkspaceMcpConfigPaths)(wsUris);
@@ -569,6 +622,16 @@ class McpManager {
             // Update agent config
             if (this.agentConfig && unsanitizedServerName) {
                 const updatedConfig = { ...(this.agentConfig.mcpServers[unsanitizedServerName] || {}) };
+                if (configUpdates.url !== undefined)
+                    updatedConfig.url = configUpdates.url;
+                if (configUpdates.headers !== undefined) {
+                    if (configUpdates.headers && Object.keys(configUpdates.headers).length) {
+                        updatedConfig.headers = configUpdates.headers;
+                    }
+                    else {
+                        delete updatedConfig.headers; // allow user to clear headers
+                    }
+                }
                 if (configUpdates.command !== undefined)
                     updatedConfig.command = configUpdates.command;
                 if (configUpdates.initializationTimeout !== undefined)
@@ -591,9 +654,12 @@ class McpManager {
                         delete updatedConfig.env;
                     }
                 }
+                if (configUpdates.disabled !== undefined) {
+                    updatedConfig.disabled = configUpdates.disabled;
+                }
                 this.agentConfig.mcpServers[unsanitizedServerName] = updatedConfig;
                 // Save agent config
-                await (0, mcpUtils_1.saveAgentConfig)(this.features.workspace, this.features.logging, this.agentConfig, agentPath);
+                await (0, mcpUtils_1.saveAgentConfig)(this.features.workspace, this.features.logging, this.agentConfig, agentPath, unsanitizedServerName);
             }
             const newCfg = {
                 ...oldCfg,
@@ -607,13 +673,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, McpServerStatus.DISABLED, 0)
-            //     this.emitToolsChanged(serverName)
-            // } else {
-            //     await this.initOneServer(serverName, newCfg)
-            // }
-            await this.initOneServer(serverName, newCfg);
+            if (this.isServerDisabled(serverName)) {
+                this.setState(serverName, mcpTypes_1.McpServerStatus.DISABLED, 0);
+                this.emitToolsChanged(serverName);
+            }
+            else {
+                await this.initOneServer(serverName, newCfg);
+            }
         }
         catch (err) {
             this.handleError(serverName, err);
@@ -681,10 +747,10 @@ class McpManager {
         try {
             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 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();
@@ -768,16 +834,38 @@ class McpManager {
                     this.agentConfig.allowedTools.push(toolId);
                 }
             }
+            // Update server enabled/disabled state in agent config
+            if (this.agentConfig.mcpServers[unsanitizedServerName]) {
+                this.agentConfig.mcpServers[unsanitizedServerName].disabled = !perm.enabled;
+            }
+            // Also update the mcpServers map
+            if (serverConfig) {
+                serverConfig.disabled = !perm.enabled;
+            }
             // Save agent config
             const agentPath = perm.__configPath__;
             if (agentPath) {
-                await (0, mcpUtils_1.saveAgentConfig)(this.features.workspace, this.features.logging, this.agentConfig, agentPath);
+                await (0, mcpUtils_1.saveAgentConfig)(this.features.workspace, this.features.logging, this.agentConfig, agentPath, unsanitizedServerName);
             }
             // Update mcpServerPermissions map
             this.mcpServerPermissions.set(serverName, {
                 enabled: perm.enabled,
                 toolPerms: perm.toolPerms || {},
             });
+            // enable/disable server
+            if (this.isServerDisabled(serverName)) {
+                const client = this.clients.get(serverName);
+                if (client) {
+                    await client.close();
+                    this.clients.delete(serverName);
+                }
+                this.setState(serverName, mcpTypes_1.McpServerStatus.DISABLED, 0);
+            }
+            else {
+                if (!this.clients.has(serverName)) {
+                    await this.initOneServer(serverName, this.mcpServers.get(serverName));
+                }
+            }
             this.features.logging.info(`Permissions updated for '${serverName}' in agent config`);
             this.emitToolsChanged(serverName);
         }
@@ -791,42 +879,13 @@ class McpManager {
      */
     requiresApproval(server, tool) {
         // For built-in tools, check directly without prefix
-        const toolId = server === 'builtIn' ? 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.
-     * This is used by the UI to reflect real-time server status.
-     * @private
-     */
-    setState(server, status, toolsCount, lastError) {
-        const st = { status, toolsCount, lastError };
-        this.mcpServerStates.set(server, st);
-        this.events.emit(exports.MCP_SERVER_STATUS_CHANGED, server, { ...st });
-    }
-    /**
-     * Emits an event when the tools associated with a server change.
-     * Used to refresh the Agent's tool list.
-     * @private
-     */
-    emitToolsChanged(server) {
-        const enabled = this.getEnabledTools()
-            .filter(t => t.serverName === server)
-            .map(t => ({ ...t }));
-        this.features.logging.debug(`ToolsChanged | server=${server} | toolCount=${enabled.length}`);
-        this.events.emit(exports.AGENT_TOOLS_CHANGED, server, enabled);
-    }
-    /**
-     * Centralized error handling: logs the error, updates the status, and emits an event.
-     * Exceptions are no longer thrown to ensure the remaining workflow continues uninterrupted.
-     */
-    handleError(server, err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        this.features.logging.error(`MCP ERROR${server ? ` [${server}]` : ''}: ${msg}`);
-        if (server) {
-            this.setState(server, mcpTypes_1.McpServerStatus.FAILED, 0, msg);
-            this.emitToolsChanged(server);
+        if (server === 'builtIn') {
+            return !this.agentConfig.allowedTools.includes(tool);
         }
+        // Get unsanitized server name for prefix
+        const unsanitizedServerName = this.serverNameMapping.get(server) || server;
+        const toolId = `@${unsanitizedServerName}/${tool}`;
+        return !this.agentConfig.allowedTools.includes(toolId);
     }
     /**
      * Returns any errors that occurred during loading of MCP configuration files
@@ -880,7 +939,7 @@ class McpManager {
                     return true;
                 });
                 // Save agent config
-                await (0, mcpUtils_1.saveAgentConfig)(this.features.workspace, this.features.logging, this.agentConfig, cfg.__configPath__);
+                await (0, mcpUtils_1.saveAgentConfig)(this.features.workspace, this.features.logging, this.agentConfig, cfg.__configPath__, unsanitizedName);
             }
         }
         catch (err) {
@@ -950,6 +1009,100 @@ class McpManager {
     setToolNameMapping(mapping) {
         this.toolNameMapping = new Map(mapping);
     }
+    /**
+     * Updates the runtime state for a given server, including status, tool count, and optional error message.
+     * This is used by the UI to reflect real-time server status.
+     * @private
+     */
+    setState(server, status, toolsCount, lastError) {
+        const st = { status, toolsCount, lastError };
+        this.mcpServerStates.set(server, st);
+        this.events.emit(exports.MCP_SERVER_STATUS_CHANGED, server, { ...st });
+    }
+    /**
+     * Emits an event when the tools associated with a server change.
+     * Used to refresh the Agent's tool list.
+     * @private
+     */
+    emitToolsChanged(server) {
+        const enabled = this.getEnabledTools()
+            .filter(t => t.serverName === server)
+            .map(t => ({ ...t }));
+        this.features.logging.debug(`ToolsChanged | server=${server} | toolCount=${enabled.length}`);
+        this.events.emit(exports.AGENT_TOOLS_CHANGED, server, enabled);
+    }
+    /**
+     * Centralized error handling: logs the error, updates the status, and emits an event.
+     * Exceptions are no longer thrown to ensure the remaining workflow continues uninterrupted.
+     */
+    handleError(server, err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        this.features.logging.error(`MCP ERROR${server ? ` [${server}]` : ''}: ${msg}`);
+        if (server) {
+            this.setState(server, mcpTypes_1.McpServerStatus.FAILED, 0, msg);
+            this.emitToolsChanged(server);
+        }
+    }
+    /**
+     * Ensure the server-specific config is internally consistent.
+     * Mutates `cfg` in-place, trimming fields that don't belong to the selected transport.
+     * @private
+     */
+    validateServerCfg(cfg) {
+        const hasCmd = !!cfg.command?.trim();
+        const hasUrl = !!cfg.url?.trim();
+        if (hasCmd && hasUrl)
+            throw new Error('Specify either command or url, not both');
+        if (!hasCmd && !hasUrl)
+            throw new Error('Either command or url is required');
+        if (hasCmd) {
+            if (!cfg.command.trim())
+                throw new Error('Stdio transport requires "command"');
+            delete cfg.url;
+            delete cfg.headers;
+        }
+        else {
+            if (!cfg.url.trim())
+                throw new Error('HTTP transport requires "url"');
+            delete cfg.command;
+            delete cfg.args;
+            delete cfg.env;
+        }
+    }
+    /**
+     * Creates the option bag for SSEClientTransport
+     * @private
+     */
+    buildSseOpts(headers) {
+        if (!headers || Object.keys(headers).length === 0) {
+            return;
+        }
+        const requestInit = { headers };
+        // override only the SSE‐GET:
+        const eventSourceInit = {
+            fetch: (input, init = {}) => {
+                const merged = new Headers(init.headers || {});
+                for (const [k, v] of Object.entries(headers)) {
+                    merged.set(k, v);
+                }
+                return fetch(input, {
+                    ...init,
+                    headers: merged,
+                });
+            },
+        };
+        return { requestInit, eventSourceInit };
+    }
+    /**
+     * Creates the option bag for StreamableHTTPClientTransport
+     * @private
+     */
+    buildHttpOpts(headers) {
+        if (!headers || Object.keys(headers).length === 0) {
+            return;
+        }
+        return { requestInit: { headers } };
+    }
 }
 exports.McpManager = McpManager;
 //# sourceMappingURL=mcpManager.js.map