@iaforged/context-code 1.0.62 → 1.0.65

package/dist/src/services/mcp/client.js

@@ -1,2480 +0,0 @@
-import { MACRO, feature } from '../../recovery/bunBundleShim.js';
-import { createRequire } from 'module';
-const require = createRequire(import.meta.url);
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { SSEClientTransport, } from '@modelcontextprotocol/sdk/client/sse.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-import { StreamableHTTPClientTransport, } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
-import { createFetchWithInit, } from '@modelcontextprotocol/sdk/shared/transport.js';
-import { CallToolResultSchema, ElicitRequestSchema, ErrorCode, ListPromptsResultSchema, ListResourcesResultSchema, ListRootsRequestSchema, ListToolsResultSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
-import mapValues from 'lodash-es/mapValues.js';
-import memoize from 'lodash-es/memoize.js';
-import zipObject from 'lodash-es/zipObject.js';
-import pMap from 'p-map';
-import { getOriginalCwd, getSessionId } from '../../bootstrap/state.js';
-import { getOauthConfig } from '../../constants/oauth.js';
-import { PRODUCT_URL } from '../../constants/product.js';
-import { toolMatchesName, } from '../../Tool.js';
-import { ListMcpResourcesTool } from '../../tools/ListMcpResourcesTool/ListMcpResourcesTool.js';
-import { MCPTool } from '../../tools/MCPTool/MCPTool.js';
-import { createMcpAuthTool } from '../../tools/McpAuthTool/McpAuthTool.js';
-import { ReadMcpResourceTool } from '../../tools/ReadMcpResourceTool/ReadMcpResourceTool.js';
-import { createAbortController } from '../../utils/abortController.js';
-import { count } from '../../utils/array.js';
-import { checkAndRefreshOAuthTokenIfNeeded, getClaudeAIOAuthTokens, handleOAuth401Error, } from '../../utils/auth.js';
-import { registerCleanup } from '../../utils/cleanupRegistry.js';
-import { detectCodeIndexingFromMcpServerName } from '../../utils/codeIndexing.js';
-import { logForDebugging } from '../../utils/debug.js';
-import { isEnvDefinedFalsy, isEnvTruthy } from '../../utils/envUtils.js';
-import { errorMessage, TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, } from '../../utils/errors.js';
-import { getMCPUserAgent } from '../../utils/http.js';
-import { maybeNotifyIDEConnected } from '../../utils/ide.js';
-import { maybeResizeAndDownsampleImageBuffer } from '../../utils/imageResizer.js';
-import { logMCPDebug, logMCPError } from '../../utils/log.js';
-import { getBinaryBlobSavedMessage, getFormatDescription, getLargeOutputInstructions, persistBinaryContent, } from '../../utils/mcpOutputStorage.js';
-import { getContentSizeEstimate, mcpContentNeedsTruncation, truncateMcpContentIfNeeded, } from '../../utils/mcpValidation.js';
-import { WebSocketTransport } from '../../utils/mcpWebSocketTransport.js';
-import { memoizeWithLRU } from '../../utils/memoize.js';
-import { getWebSocketTLSOptions } from '../../utils/mtls.js';
-import { getProxyFetchOptions, getWebSocketProxyAgent, getWebSocketProxyUrl, } from '../../utils/proxy.js';
-import { recursivelySanitizeUnicode } from '../../utils/sanitization.js';
-import { getSessionIngressAuthToken } from '../../utils/sessionIngressAuth.js';
-import { subprocessEnv } from '../../utils/subprocessEnv.js';
-import { isPersistError, persistToolResult, } from '../../utils/toolResultStorage.js';
-import { logEvent, } from '../analytics/index.js';
-import { runElicitationHooks, runElicitationResultHooks, } from './elicitationHandler.js';
-import { buildMcpToolName } from './mcpStringUtils.js';
-import { normalizeNameForMCP } from './normalization.js';
-import { getLoggingSafeMcpBaseUrl } from './utils.js';
-/* eslint-disable @typescript-eslint/no-require-imports */
-const fetchMcpSkillsForClient = feature('MCP_SKILLS')
-    ? require('../../skills/mcpSkills.js').fetchMcpSkillsForClient
-    : null;
-import { UnauthorizedError } from '@modelcontextprotocol/sdk/client/auth.js';
-/* eslint-enable @typescript-eslint/no-require-imports */
-import { classifyMcpToolForCollapse } from '../../tools/MCPTool/classifyForCollapse.js';
-import { clearKeychainCache } from '../../utils/secureStorage/macOsKeychainHelpers.js';
-import { sleep } from '../../utils/sleep.js';
-import { ClaudeAuthProvider, hasMcpDiscoveryButNoToken, wrapFetchWithStepUpDetection, } from './auth.js';
-import { markClaudeAiMcpConnected } from './claudeai.js';
-import { getAllMcpConfigs, isMcpServerDisabled } from './config.js';
-import { getMcpServerHeaders } from './headersHelper.js';
-import { SdkControlClientTransport } from './SdkControlTransport.js';
-/**
- * Custom error class to indicate that an MCP tool call failed due to
- * authentication issues (e.g., expired OAuth token returning 401).
- * This error should be caught at the tool execution layer to update
- * the client's status to 'needs-auth'.
- */
-export class McpAuthError extends Error {
-    serverName;
-    constructor(serverName, message) {
-        super(message);
-        this.name = 'McpAuthError';
-        this.serverName = serverName;
-    }
-}
-/**
- * Thrown when an MCP session has expired and the connection cache has been cleared.
- * The caller should get a fresh client via ensureConnectedClient and retry.
- */
-class McpSessionExpiredError extends Error {
-    constructor(serverName) {
-        super(`MCP server "${serverName}" session expired`);
-        this.name = 'McpSessionExpiredError';
-    }
-}
-/**
- * Thrown when an MCP tool returns `isError: true`. Carries the result's `_meta`
- * so SDK consumers can still receive it — per the MCP spec, `_meta` is on the
- * base Result type and is valid on error results.
- */
-export class McpToolCallError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS extends TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS {
-    mcpMeta;
-    constructor(message, telemetryMessage, mcpMeta) {
-        super(message, telemetryMessage);
-        this.mcpMeta = mcpMeta;
-        this.name = 'McpToolCallError';
-    }
-}
-/**
- * Detects whether an error is an MCP "Session not found" error (HTTP 404 + JSON-RPC code -32001).
- * Per the MCP spec, servers return 404 when a session ID is no longer valid.
- * We check both signals to avoid false positives from generic 404s (wrong URL, server gone, etc.).
- */
-export function isMcpSessionExpiredError(error) {
-    const httpStatus = 'code' in error ? error.code : undefined;
-    if (httpStatus !== 404) {
-        return false;
-    }
-    // The SDK embeds the response body text in the error message.
-    // MCP servers return: {"error":{"code":-32001,"message":"Session not found"},...}
-    // Check for the JSON-RPC error code to distinguish from generic web server 404s.
-    return (error.message.includes('"code":-32001') ||
-        error.message.includes('"code": -32001'));
-}
-/**
- * Default timeout for MCP tool calls (effectively infinite - ~27.8 hours).
- */
-const DEFAULT_MCP_TOOL_TIMEOUT_MS = 100_000_000;
-/**
- * Cap on MCP tool descriptions and server instructions sent to the model.
- * OpenAPI-generated MCP servers have been observed dumping 15-60KB of endpoint
- * docs into tool.description; this caps the p95 tail without losing the intent.
- */
-const MAX_MCP_DESCRIPTION_LENGTH = 2048;
-/**
- * Gets the timeout for MCP tool calls in milliseconds.
- * Uses MCP_TOOL_TIMEOUT environment variable if set, otherwise defaults to ~27.8 hours.
- */
-function getMcpToolTimeoutMs() {
-    return (parseInt(process.env.MCP_TOOL_TIMEOUT || '', 10) ||
-        DEFAULT_MCP_TOOL_TIMEOUT_MS);
-}
-import { isClaudeInChromeMCPServer } from '../../utils/claudeInChrome/common.js';
-// Lazy: toolRendering.tsx pulls React/ink; only needed when Claude-in-Chrome MCP server is connected
-/* eslint-disable @typescript-eslint/no-require-imports */
-const claudeInChromeToolRendering = () => require('../../utils/claudeInChrome/toolRendering.js');
-// Lazy: wrapper.tsx → hostAdapter.ts → executor.ts pulls both native modules
-// (@ant/computer-use-input + @ant/computer-use-swift). Runtime-gated by
-// GrowthBook tengu_malort_pedway (see gates.ts).
-const computerUseWrapper = feature('CHICAGO_MCP')
-    ? () => require('../../utils/computerUse/wrapper.js')
-    : undefined;
-const isComputerUseMCPServer = feature('CHICAGO_MCP')
-    ? require('../../utils/computerUse/common.js').isComputerUseMCPServer
-    : undefined;
-import { mkdir, readFile, unlink, writeFile } from 'fs/promises';
-import { dirname, join } from 'path';
-import { getClaudeConfigHomeDir } from '../../utils/envUtils.js';
-/* eslint-enable @typescript-eslint/no-require-imports */
-import { jsonParse, jsonStringify } from '../../utils/slowOperations.js';
-const MCP_AUTH_CACHE_TTL_MS = 15 * 60 * 1000; // 15 min
-function getMcpAuthCachePath() {
-    return join(getClaudeConfigHomeDir(), 'mcp-needs-auth-cache.json');
-}
-// Memoized so N concurrent isMcpAuthCached() calls during batched connection
-// share a single file read instead of N reads of the same file. Invalidated
-// on write (setMcpAuthCacheEntry) and clear (clearMcpAuthCache). Not using
-// lodash memoize because we need to null out the cache, not delete by key.
-let authCachePromise = null;
-function getMcpAuthCache() {
-    if (!authCachePromise) {
-        authCachePromise = readFile(getMcpAuthCachePath(), 'utf-8')
-            .then(data => jsonParse(data))
-            .catch(() => ({}));
-    }
-    return authCachePromise;
-}
-async function isMcpAuthCached(serverId) {
-    const cache = await getMcpAuthCache();
-    const entry = cache[serverId];
-    if (!entry) {
-        return false;
-    }
-    return Date.now() - entry.timestamp < MCP_AUTH_CACHE_TTL_MS;
-}
-// Serialize cache writes through a promise chain to prevent concurrent
-// read-modify-write races when multiple servers return 401 in the same batch
-let writeChain = Promise.resolve();
-function setMcpAuthCacheEntry(serverId) {
-    writeChain = writeChain
-        .then(async () => {
-        const cache = await getMcpAuthCache();
-        cache[serverId] = { timestamp: Date.now() };
-        const cachePath = getMcpAuthCachePath();
-        await mkdir(dirname(cachePath), { recursive: true });
-        await writeFile(cachePath, jsonStringify(cache));
-        // Invalidate the read cache so subsequent reads see the new entry.
-        // Safe because writeChain serializes writes: the next write's
-        // getMcpAuthCache() call will re-read the file with this entry present.
-        authCachePromise = null;
-    })
-        .catch(() => {
-        // Best-effort cache write
-    });
-}
-export function clearMcpAuthCache() {
-    authCachePromise = null;
-    void unlink(getMcpAuthCachePath()).catch(() => {
-        // Cache file may not exist
-    });
-}
-/**
- * Spread-ready analytics field for the server's base URL. Calls
- * getLoggingSafeMcpBaseUrl once (not twice like the inline ternary it replaces).
- * Typed as AnalyticsMetadata since the URL is query-stripped and safe to log.
- */
-function mcpBaseUrlAnalytics(serverRef) {
-    const url = getLoggingSafeMcpBaseUrl(serverRef);
-    return url
-        ? {
-            mcpServerBaseUrl: url,
-        }
-        : {};
-}
-/**
- * Shared handler for sse/http/claudeai-proxy auth failures during connect:
- * emits tengu_mcp_server_needs_auth, caches the needs-auth entry, and returns
- * the needs-auth connection result.
- */
-function handleRemoteAuthFailure(name, serverRef, transportType) {
-    logEvent('tengu_mcp_server_needs_auth', {
-        transportType: transportType,
-        ...mcpBaseUrlAnalytics(serverRef),
-    });
-    const label = {
-        sse: 'SSE',
-        http: 'HTTP',
-        'claudeai-proxy': 'claude.ai proxy',
-    };
-    logMCPDebug(name, `Authentication required for ${label[transportType]} server`);
-    setMcpAuthCacheEntry(name);
-    return { name, type: 'needs-auth', config: serverRef };
-}
-/**
- * Fetch wrapper for claude.ai proxy connections. Attaches the OAuth bearer
- * token and retries once on 401 via handleOAuth401Error (force-refresh).
- *
- * The Anthropic API path has this retry (withRetry.ts, grove.ts) to handle
- * memoize-cache staleness and clock drift. Without the same here, a single
- * stale token mass-401s every claude.ai connector and sticks them all in the
- * 15-min needs-auth cache.
- */
-export function createClaudeAiProxyFetch(innerFetch) {
-    return async (url, init) => {
-        const doRequest = async () => {
-            await checkAndRefreshOAuthTokenIfNeeded();
-            const currentTokens = getClaudeAIOAuthTokens();
-            if (!currentTokens) {
-                throw new Error('No claude.ai OAuth token available');
-            }
-            // eslint-disable-next-line eslint-plugin-n/no-unsupported-features/node-builtins
-            const headers = new Headers(init?.headers);
-            headers.set('Authorization', `Bearer ${currentTokens.accessToken}`);
-            const response = await innerFetch(url, { ...init, headers });
-            // Return the exact token that was sent. Reading getClaudeAIOAuthTokens()
-            // again after the request is wrong under concurrent 401s: another
-            // connector's handleOAuth401Error clears the memoize cache, so we'd read
-            // the NEW token from keychain, pass it to handleOAuth401Error, which
-            // finds same-as-keychain → returns false → skips retry. Same pattern as
-            // bridgeApi.ts withOAuthRetry (token passed as fn param).
-            return { response, sentToken: currentTokens.accessToken };
-        };
-        const { response, sentToken } = await doRequest();
-        if (response.status !== 401) {
-            return response;
-        }
-        // handleOAuth401Error returns true only if the token actually changed
-        // (keychain had a newer one, or force-refresh succeeded). Gate retry on
-        // that — otherwise we double round-trip time for every connector whose
-        // downstream service genuinely needs auth (the common case: 30+ servers
-        // with "MCP server requires authentication but no OAuth token configured").
-        const tokenChanged = await handleOAuth401Error(sentToken).catch(() => false);
-        logEvent('tengu_mcp_claudeai_proxy_401', {
-            tokenChanged: tokenChanged,
-        });
-        if (!tokenChanged) {
-            // ELOCKED contention: another connector may have won the lockfile and refreshed — check if token changed underneath us
-            const now = getClaudeAIOAuthTokens()?.accessToken;
-            if (!now || now === sentToken) {
-                return response;
-            }
-        }
-        try {
-            return (await doRequest()).response;
-        }
-        catch {
-            // Retry itself failed (network error). Return the original 401 so the
-            // outer handler can classify it.
-            return response;
-        }
-    };
-}
-/**
- * Create a ws.WebSocket client with the MCP protocol.
- * Bun's ws shim types lack the 3-arg constructor (url, protocols, options)
- * that the real ws package supports, so we cast the constructor here.
- */
-async function createNodeWsClient(url, options) {
-    const wsModule = await import('ws');
-    const WS = wsModule.default;
-    return new WS(url, ['mcp'], options);
-}
-const IMAGE_MIME_TYPES = new Set([
-    'image/jpeg',
-    'image/png',
-    'image/gif',
-    'image/webp',
-]);
-function getConnectionTimeoutMs() {
-    return parseInt(process.env.MCP_TIMEOUT || '', 10) || 30000;
-}
-/**
- * Default timeout for individual MCP requests (auth, tool calls, etc.)
- */
-const MCP_REQUEST_TIMEOUT_MS = 60000;
-/**
- * MCP Streamable HTTP spec requires clients to advertise acceptance of both
- * JSON and SSE on every POST. Servers that enforce this strictly reject
- * requests without it (HTTP 406).
- * https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#sending-messages-to-the-server
- */
-const MCP_STREAMABLE_HTTP_ACCEPT = 'application/json, text/event-stream';
-/**
- * Wraps a fetch function to apply a fresh timeout signal to each request.
- * This avoids the bug where a single AbortSignal.timeout() created at connection
- * time becomes stale after 60 seconds, causing all subsequent requests to fail
- * immediately with "The operation timed out." Uses a 60-second timeout.
- *
- * Also ensures the Accept header required by the MCP Streamable HTTP spec is
- * present on POSTs. The MCP SDK sets this inside StreamableHTTPClientTransport.send(),
- * but it is attached to a Headers instance that passes through an object spread here,
- * and some runtimes/agents have been observed dropping it before it reaches the wire.
- * See https://github.com/anthropics/claude-agent-sdk-typescript/issues/202.
- * Normalizing here (the last wrapper before fetch()) guarantees it is sent.
- *
- * GET requests are excluded from the timeout since, for MCP transports, they are
- * long-lived SSE streams meant to stay open indefinitely. (Auth-related GETs use
- * a separate fetch wrapper with its own timeout in auth.ts.)
- *
- * @param baseFetch - The fetch function to wrap
- */
-export function wrapFetchWithTimeout(baseFetch) {
-    return async (url, init) => {
-        const method = (init?.method ?? 'GET').toUpperCase();
-        // Skip timeout for GET requests - in MCP transports, these are long-lived SSE streams.
-        // (OAuth discovery GETs in auth.ts use a separate createAuthFetch() with its own timeout.)
-        if (method === 'GET') {
-            return baseFetch(url, init);
-        }
-        // Normalize headers and guarantee the Streamable-HTTP Accept value. new Headers()
-        // accepts HeadersInit | undefined and copies from plain objects, tuple arrays,
-        // and existing Headers instances — so whatever shape the SDK handed us, the
-        // Accept value survives the spread below as an own property of a concrete object.
-        // eslint-disable-next-line eslint-plugin-n/no-unsupported-features/node-builtins
-        const headers = new Headers(init?.headers);
-        if (!headers.has('accept')) {
-            headers.set('accept', MCP_STREAMABLE_HTTP_ACCEPT);
-        }
-        // Use setTimeout instead of AbortSignal.timeout() so we can clearTimeout on
-        // completion. AbortSignal.timeout's internal timer is only released when the
-        // signal is GC'd, which in Bun is lazy — ~2.4KB of native memory per request
-        // lingers for the full 60s even when the request completes in milliseconds.
-        const controller = new AbortController();
-        const timer = setTimeout(c => c.abort(new DOMException('The operation timed out.', 'TimeoutError')), MCP_REQUEST_TIMEOUT_MS, controller);
-        timer.unref?.();
-        const parentSignal = init?.signal;
-        const abort = () => controller.abort(parentSignal?.reason);
-        parentSignal?.addEventListener('abort', abort);
-        if (parentSignal?.aborted) {
-            controller.abort(parentSignal.reason);
-        }
-        const cleanup = () => {
-            clearTimeout(timer);
-            parentSignal?.removeEventListener('abort', abort);
-        };
-        try {
-            const response = await baseFetch(url, {
-                ...init,
-                headers,
-                signal: controller.signal,
-            });
-            cleanup();
-            return response;
-        }
-        catch (error) {
-            cleanup();
-            throw error;
-        }
-    };
-}
-export function getMcpServerConnectionBatchSize() {
-    return parseInt(process.env.MCP_SERVER_CONNECTION_BATCH_SIZE || '', 10) || 3;
-}
-function getRemoteMcpServerConnectionBatchSize() {
-    return (parseInt(process.env.MCP_REMOTE_SERVER_CONNECTION_BATCH_SIZE || '', 10) ||
-        20);
-}
-function isLocalMcpServer(config) {
-    return !config.type || config.type === 'stdio' || config.type === 'sdk';
-}
-// For the IDE MCP servers, we only include specific tools
-const ALLOWED_IDE_TOOLS = ['mcp__ide__executeCode', 'mcp__ide__getDiagnostics'];
-function isIncludedMcpTool(tool) {
-    return (!tool.name.startsWith('mcp__ide__') || ALLOWED_IDE_TOOLS.includes(tool.name));
-}
-/**
- * Generates the cache key for a server connection
- * @param name Server name
- * @param serverRef Server configuration
- * @returns Cache key string
- */
-export function getServerCacheKey(name, serverRef) {
-    return `${name}-${jsonStringify(serverRef)}`;
-}
-/**
- * TODO (ollie): The memoization here increases complexity by a lot, and im not sure it really improves performance
- * Attempts to connect to a single MCP server
- * @param name Server name
- * @param serverRef Scoped server configuration
- * @returns A wrapped client (either connected or failed)
- */
-export const connectToServer = memoize(async (name, serverRef, serverStats) => {
-    const connectStartTime = Date.now();
-    let inProcessServer;
-    try {
-        let transport;
-        // If we have the session ingress JWT, we will connect via the session ingress rather than
-        // to remote MCP's directly.
-        const sessionIngressToken = getSessionIngressAuthToken();
-        if (serverRef.type === 'sse') {
-            // Create an auth provider for this server
-            const authProvider = new ClaudeAuthProvider(name, serverRef);
-            // Get combined headers (static + dynamic)
-            const combinedHeaders = await getMcpServerHeaders(name, serverRef);
-            // Use the auth provider with SSEClientTransport
-            const transportOptions = {
-                authProvider,
-                // Use fresh timeout per request to avoid stale AbortSignal bug.
-                // Step-up detection wraps innermost so the 403 is seen before the
-                // SDK's handler calls auth() → tokens().
-                fetch: wrapFetchWithTimeout(wrapFetchWithStepUpDetection(createFetchWithInit(), authProvider)),
-                requestInit: {
-                    headers: {
-                        'User-Agent': getMCPUserAgent(),
-                        ...combinedHeaders,
-                    },
-                },
-            };
-            // IMPORTANT: Always set eventSourceInit with a fetch that does NOT use the
-            // timeout wrapper. The EventSource connection is long-lived (stays open indefinitely
-            // to receive server-sent events), so applying a 60-second timeout would kill it.
-            // The timeout is only meant for individual API requests (POST, auth refresh), not
-            // the persistent SSE stream.
-            transportOptions.eventSourceInit = {
-                fetch: async (url, init) => {
-                    // Get auth headers from the auth provider
-                    const authHeaders = {};
-                    const tokens = await authProvider.tokens();
-                    if (tokens) {
-                        authHeaders.Authorization = `Bearer ${tokens.access_token}`;
-                    }
-                    const proxyOptions = getProxyFetchOptions();
-                    // eslint-disable-next-line eslint-plugin-n/no-unsupported-features/node-builtins
-                    return fetch(url, {
-                        ...init,
-                        ...proxyOptions,
-                        headers: {
-                            'User-Agent': getMCPUserAgent(),
-                            ...authHeaders,
-                            ...init?.headers,
-                            ...combinedHeaders,
-                            Accept: 'text/event-stream',
-                        },
-                    });
-                },
-            };
-            transport = new SSEClientTransport(new URL(serverRef.url), transportOptions);
-            logMCPDebug(name, `SSE transport initialized, awaiting connection`);
-        }
-        else if (serverRef.type === 'sse-ide') {
-            logMCPDebug(name, `Setting up SSE-IDE transport to ${serverRef.url}`);
-            // IDE servers don't need authentication
-            // TODO: Use the auth token provided in the lockfile
-            const proxyOptions = getProxyFetchOptions();
-            const transportOptions = proxyOptions.dispatcher
-                ? {
-                    eventSourceInit: {
-                        fetch: async (url, init) => {
-                            // eslint-disable-next-line eslint-plugin-n/no-unsupported-features/node-builtins
-                            return fetch(url, {
-                                ...init,
-                                ...proxyOptions,
-                                headers: {
-                                    'User-Agent': getMCPUserAgent(),
-                                    ...init?.headers,
-                                },
-                            });
-                        },
-                    },
-                }
-                : {};
-            transport = new SSEClientTransport(new URL(serverRef.url), Object.keys(transportOptions).length > 0
-                ? transportOptions
-                : undefined);
-        }
-        else if (serverRef.type === 'ws-ide') {
-            const tlsOptions = getWebSocketTLSOptions();
-            const wsHeaders = {
-                'User-Agent': getMCPUserAgent(),
-                ...(serverRef.authToken && {
-                    'X-Claude-Code-Ide-Authorization': serverRef.authToken,
-                }),
-            };
-            let wsClient;
-            if (typeof Bun !== 'undefined') {
-                // Bun's WebSocket supports headers/proxy/tls options but the DOM typings don't
-                // eslint-disable-next-line eslint-plugin-n/no-unsupported-features/node-builtins
-                wsClient = new globalThis.WebSocket(serverRef.url, {
-                    protocols: ['mcp'],
-                    headers: wsHeaders,
-                    proxy: getWebSocketProxyUrl(serverRef.url),
-                    tls: tlsOptions || undefined,
-                });
-            }
-            else {
-                wsClient = await createNodeWsClient(serverRef.url, {
-                    headers: wsHeaders,
-                    agent: getWebSocketProxyAgent(serverRef.url),
-                    ...(tlsOptions || {}),
-                });
-            }
-            transport = new WebSocketTransport(wsClient);
-        }
-        else if (serverRef.type === 'ws') {
-            logMCPDebug(name, `Initializing WebSocket transport to ${serverRef.url}`);
-            const combinedHeaders = await getMcpServerHeaders(name, serverRef);
-            const tlsOptions = getWebSocketTLSOptions();
-            const wsHeaders = {
-                'User-Agent': getMCPUserAgent(),
-                ...(sessionIngressToken && {
-                    Authorization: `Bearer ${sessionIngressToken}`,
-                }),
-                ...combinedHeaders,
-            };
-            // Redact sensitive headers before logging
-            const wsHeadersForLogging = mapValues(wsHeaders, (value, key) => key.toLowerCase() === 'authorization' ? '[REDACTED]' : value);
-            logMCPDebug(name, `WebSocket transport options: ${jsonStringify({
-                url: serverRef.url,
-                headers: wsHeadersForLogging,
-                hasSessionAuth: !!sessionIngressToken,
-            })}`);
-            let wsClient;
-            if (typeof Bun !== 'undefined') {
-                // Bun's WebSocket supports headers/proxy/tls options but the DOM typings don't
-                // eslint-disable-next-line eslint-plugin-n/no-unsupported-features/node-builtins
-                wsClient = new globalThis.WebSocket(serverRef.url, {
-                    protocols: ['mcp'],
-                    headers: wsHeaders,
-                    proxy: getWebSocketProxyUrl(serverRef.url),
-                    tls: tlsOptions || undefined,
-                });
-            }
-            else {
-                wsClient = await createNodeWsClient(serverRef.url, {
-                    headers: wsHeaders,
-                    agent: getWebSocketProxyAgent(serverRef.url),
-                    ...(tlsOptions || {}),
-                });
-            }
-            transport = new WebSocketTransport(wsClient);
-        }
-        else if (serverRef.type === 'http') {
-            logMCPDebug(name, `Initializing HTTP transport to ${serverRef.url}`);
-            logMCPDebug(name, `Node version: ${process.version}, Platform: ${process.platform}`);
-            logMCPDebug(name, `Environment: ${jsonStringify({
-                NODE_OPTIONS: process.env.NODE_OPTIONS || 'not set',
-                UV_THREADPOOL_SIZE: process.env.UV_THREADPOOL_SIZE || 'default',
-                HTTP_PROXY: process.env.HTTP_PROXY || 'not set',
-                HTTPS_PROXY: process.env.HTTPS_PROXY || 'not set',
-                NO_PROXY: process.env.NO_PROXY || 'not set',
-            })}`);
-            // Create an auth provider for this server
-            const authProvider = new ClaudeAuthProvider(name, serverRef);
-            // Get combined headers (static + dynamic)
-            const combinedHeaders = await getMcpServerHeaders(name, serverRef);
-            // Check if this server has stored OAuth tokens. If so, the SDK's
-            // authProvider will set Authorization — don't override with the
-            // session ingress token (SDK merges requestInit AFTER authProvider).
-            // CCR proxy URLs (ccr_shttp_mcp) have no stored OAuth, so they still
-            // get the ingress token. See PR #24454 discussion.
-            const hasOAuthTokens = !!(await authProvider.tokens());
-            // Use the auth provider with StreamableHTTPClientTransport
-            const proxyOptions = getProxyFetchOptions();
-            logMCPDebug(name, `Proxy options: ${proxyOptions.dispatcher ? 'custom dispatcher' : 'default'}`);
-            const transportOptions = {
-                authProvider,
-                // Use fresh timeout per request to avoid stale AbortSignal bug.
-                // Step-up detection wraps innermost so the 403 is seen before the
-                // SDK's handler calls auth() → tokens().
-                fetch: wrapFetchWithTimeout(wrapFetchWithStepUpDetection(createFetchWithInit(), authProvider)),
-                requestInit: {
-                    ...proxyOptions,
-                    headers: {
-                        'User-Agent': getMCPUserAgent(),
-                        ...(sessionIngressToken &&
-                            !hasOAuthTokens && {
-                            Authorization: `Bearer ${sessionIngressToken}`,
-                        }),
-                        ...combinedHeaders,
-                    },
-                },
-            };
-            // Redact sensitive headers before logging
-            const headersForLogging = transportOptions.requestInit?.headers
-                ? mapValues(transportOptions.requestInit.headers, (value, key) => key.toLowerCase() === 'authorization' ? '[REDACTED]' : value)
-                : undefined;
-            logMCPDebug(name, `HTTP transport options: ${jsonStringify({
-                url: serverRef.url,
-                headers: headersForLogging,
-                hasAuthProvider: !!authProvider,
-                timeoutMs: MCP_REQUEST_TIMEOUT_MS,
-            })}`);
-            transport = new StreamableHTTPClientTransport(new URL(serverRef.url), transportOptions);
-            logMCPDebug(name, `HTTP transport created successfully`);
-        }
-        else if (serverRef.type === 'sdk') {
-            throw new Error('SDK servers should be handled in print.ts');
-        }
-        else if (serverRef.type === 'claudeai-proxy') {
-            logMCPDebug(name, `Initializing claude.ai proxy transport for server ${serverRef.id}`);
-            const tokens = getClaudeAIOAuthTokens();
-            if (!tokens) {
-                throw new Error('No claude.ai OAuth token found');
-            }
-            const oauthConfig = getOauthConfig();
-            const proxyUrl = `${oauthConfig.MCP_PROXY_URL}${oauthConfig.MCP_PROXY_PATH.replace('{server_id}', serverRef.id)}`;
-            logMCPDebug(name, `Using claude.ai proxy at ${proxyUrl}`);
-            // eslint-disable-next-line eslint-plugin-n/no-unsupported-features/node-builtins
-            const fetchWithAuth = createClaudeAiProxyFetch(globalThis.fetch);
-            const proxyOptions = getProxyFetchOptions();
-            const transportOptions = {
-                // Wrap fetchWithAuth with fresh timeout per request
-                fetch: wrapFetchWithTimeout(fetchWithAuth),
-                requestInit: {
-                    ...proxyOptions,
-                    headers: {
-                        'User-Agent': getMCPUserAgent(),
-                        'X-Mcp-Client-Session-Id': getSessionId(),
-                    },
-                },
-            };
-            transport = new StreamableHTTPClientTransport(new URL(proxyUrl), transportOptions);
-            logMCPDebug(name, `claude.ai proxy transport created successfully`);
-        }
-        else if ((serverRef.type === 'stdio' || !serverRef.type) &&
-            isClaudeInChromeMCPServer(name)) {
-            // Run the Chrome MCP server in-process to avoid spawning a ~325 MB subprocess
-            const { createChromeContext } = await import('../../utils/claudeInChrome/mcpServer.js');
-            const { createClaudeForChromeMcpServer } = await import('@ant/claude-for-chrome-mcp');
-            const { createLinkedTransportPair } = await import('./InProcessTransport.js');
-            const context = createChromeContext(serverRef.env);
-            inProcessServer = createClaudeForChromeMcpServer(context);
-            const [clientTransport, serverTransport] = createLinkedTransportPair();
-            await inProcessServer.connect(serverTransport);
-            transport = clientTransport;
-            logMCPDebug(name, `In-process Chrome MCP server started`);
-        }
-        else if (feature('CHICAGO_MCP') &&
-            (serverRef.type === 'stdio' || !serverRef.type) &&
-            isComputerUseMCPServer(name)) {
-            // Run the Computer Use MCP server in-process — same rationale as
-            // Chrome above. The package's CallTool handler is a stub; real
-            // dispatch goes through wrapper.tsx's .call() override.
-            const { createComputerUseMcpServerForCli } = await import('../../utils/computerUse/mcpServer.js');
-            const { createLinkedTransportPair } = await import('./InProcessTransport.js');
-            inProcessServer = await createComputerUseMcpServerForCli();
-            const [clientTransport, serverTransport] = createLinkedTransportPair();
-            await inProcessServer.connect(serverTransport);
-            transport = clientTransport;
-            logMCPDebug(name, `In-process Computer Use MCP server started`);
-        }
-        else if (serverRef.type === 'stdio' || !serverRef.type) {
-            const finalCommand = process.env.CLAUDE_CODE_SHELL_PREFIX || serverRef.command;
-            const finalArgs = process.env.CLAUDE_CODE_SHELL_PREFIX
-                ? [[serverRef.command, ...serverRef.args].join(' ')]
-                : serverRef.args;
-            transport = new StdioClientTransport({
-                command: finalCommand,
-                args: finalArgs,
-                env: {
-                    ...subprocessEnv(),
-                    ...serverRef.env,
-                },
-                stderr: 'pipe', // prevents error output from the MCP server from printing to the UI
-            });
-        }
-        else {
-            throw new Error(`Unsupported server type: ${serverRef.type}`);
-        }
-        // Set up stderr logging for stdio transport before connecting in case there are any stderr
-        // outputs emitted during the connection start (this can be useful for debugging failed connections).
-        // Store handler reference for cleanup to prevent memory leaks
-        let stderrHandler;
-        let stderrOutput = '';
-        if (serverRef.type === 'stdio' || !serverRef.type) {
-            const stdioTransport = transport;
-            if (stdioTransport.stderr) {
-                stderrHandler = (data) => {
-                    // Cap stderr accumulation to prevent unbounded memory growth
-                    if (stderrOutput.length < 64 * 1024 * 1024) {
-                        try {
-                            stderrOutput += data.toString();
-                        }
-                        catch {
-                            // Ignore errors from exceeding max string length
-                        }
-                    }
-                };
-                stdioTransport.stderr.on('data', stderrHandler);
-            }
-        }
-        const client = new Client({
-            name: 'claude-code',
-            title: 'Context Code',
-            version: MACRO.VERSION ?? 'unknown',
-            description: "Anthropic's agentic coding tool",
-            websiteUrl: PRODUCT_URL,
-        }, {
-            capabilities: {
-                roots: {},
-                // Empty object declares the capability. Sending {form:{},url:{}}
-                // breaks Java MCP SDK servers (Spring AI) whose Elicitation class
-                // has zero fields and fails on unknown properties.
-                elicitation: {},
-            },
-        });
-        // Add debug logging for client events if available
-        if (serverRef.type === 'http') {
-            logMCPDebug(name, `Client created, setting up request handler`);
-        }
-        client.setRequestHandler(ListRootsRequestSchema, async () => {
-            logMCPDebug(name, `Received ListRoots request from server`);
-            return {
-                roots: [
-                    {
-                        uri: `file://${getOriginalCwd()}`,
-                    },
-                ],
-            };
-        });
-        // Add a timeout to connection attempts to prevent tests from hanging indefinitely
-        logMCPDebug(name, `Starting connection with timeout of ${getConnectionTimeoutMs()}ms`);
-        // For HTTP transport, try a basic connectivity test first
-        if (serverRef.type === 'http') {
-            logMCPDebug(name, `Testing basic HTTP connectivity to ${serverRef.url}`);
-            try {
-                const testUrl = new URL(serverRef.url);
-                logMCPDebug(name, `Parsed URL: host=${testUrl.hostname}, port=${testUrl.port || 'default'}, protocol=${testUrl.protocol}`);
-                // Log DNS resolution attempt
-                if (testUrl.hostname === '127.0.0.1' ||
-                    testUrl.hostname === 'localhost') {
-                    logMCPDebug(name, `Using loopback address: ${testUrl.hostname}`);
-                }
-            }
-            catch (urlError) {
-                logMCPDebug(name, `Failed to parse URL: ${urlError}`);
-            }
-        }
-        const connectPromise = client.connect(transport);
-        const timeoutPromise = new Promise((_, reject) => {
-            const timeoutId = setTimeout(() => {
-                const elapsed = Date.now() - connectStartTime;
-                logMCPDebug(name, `Connection timeout triggered after ${elapsed}ms (limit: ${getConnectionTimeoutMs()}ms)`);
-                if (inProcessServer) {
-                    inProcessServer.close().catch(() => { });
-                }
-                transport.close().catch(() => { });
-                reject(new TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS(`MCP server "${name}" connection timed out after ${getConnectionTimeoutMs()}ms`, 'MCP connection timeout'));
-            }, getConnectionTimeoutMs());
-            // Clean up timeout if connect resolves or rejects
-            connectPromise.then(() => {
-                clearTimeout(timeoutId);
-            }, _error => {
-                clearTimeout(timeoutId);
-            });
-        });
-        try {
-            await Promise.race([connectPromise, timeoutPromise]);
-            if (stderrOutput) {
-                logMCPError(name, `Server stderr: ${stderrOutput}`);
-                stderrOutput = ''; // Release accumulated string to prevent memory growth
-            }
-            const elapsed = Date.now() - connectStartTime;
-            logMCPDebug(name, `Successfully connected (transport: ${serverRef.type || 'stdio'}) in ${elapsed}ms`);
-        }
-        catch (error) {
-            const elapsed = Date.now() - connectStartTime;
-            // SSE-specific error logging
-            if (serverRef.type === 'sse' && error instanceof Error) {
-                logMCPDebug(name, `SSE Connection failed after ${elapsed}ms: ${jsonStringify({
-                    url: serverRef.url,
-                    error: error.message,
-                    errorType: error.constructor.name,
-                    stack: error.stack,
-                })}`);
-                logMCPError(name, error);
-                if (error instanceof UnauthorizedError) {
-                    return handleRemoteAuthFailure(name, serverRef, 'sse');
-                }
-            }
-            else if (serverRef.type === 'http' && error instanceof Error) {
-                const errorObj = error;
-                logMCPDebug(name, `HTTP Connection failed after ${elapsed}ms: ${error.message} (code: ${errorObj.code || 'none'}, errno: ${errorObj.errno || 'none'})`);
-                logMCPError(name, error);
-                if (error instanceof UnauthorizedError) {
-                    return handleRemoteAuthFailure(name, serverRef, 'http');
-                }
-            }
-            else if (serverRef.type === 'claudeai-proxy' &&
-                error instanceof Error) {
-                logMCPDebug(name, `claude.ai proxy connection failed after ${elapsed}ms: ${error.message}`);
-                logMCPError(name, error);
-                // StreamableHTTPError has a `code` property with the HTTP status
-                const errorCode = error.code;
-                if (errorCode === 401) {
-                    return handleRemoteAuthFailure(name, serverRef, 'claudeai-proxy');
-                }
-            }
-            else if (serverRef.type === 'sse-ide' ||
-                serverRef.type === 'ws-ide') {
-                logEvent('tengu_mcp_ide_server_connection_failed', {
-                    connectionDurationMs: elapsed,
-                });
-            }
-            if (inProcessServer) {
-                inProcessServer.close().catch(() => { });
-            }
-            transport.close().catch(() => { });
-            if (stderrOutput) {
-                logMCPError(name, `Server stderr: ${stderrOutput}`);
-            }
-            throw error;
-        }
-        const capabilities = client.getServerCapabilities();
-        const serverVersion = client.getServerVersion();
-        const rawInstructions = client.getInstructions();
-        let instructions = rawInstructions;
-        if (rawInstructions &&
-            rawInstructions.length > MAX_MCP_DESCRIPTION_LENGTH) {
-            instructions =
-                rawInstructions.slice(0, MAX_MCP_DESCRIPTION_LENGTH) + '… [truncated]';
-            logMCPDebug(name, `Server instructions truncated from ${rawInstructions.length} to ${MAX_MCP_DESCRIPTION_LENGTH} chars`);
-        }
-        // Log successful connection details
-        logMCPDebug(name, `Connection established with capabilities: ${jsonStringify({
-            hasTools: !!capabilities?.tools,
-            hasPrompts: !!capabilities?.prompts,
-            hasResources: !!capabilities?.resources,
-            hasResourceSubscribe: !!capabilities?.resources?.subscribe,
-            serverVersion: serverVersion || 'unknown',
-        })}`);
-        logForDebugging(`[MCP] Server "${name}" connected with subscribe=${!!capabilities?.resources?.subscribe}`);
-        // Register default elicitation handler that returns cancel during the
-        // window before registerElicitationHandler overwrites it in
-        // onConnectionAttempt (useManageMCPConnections).
-        client.setRequestHandler(ElicitRequestSchema, async (request) => {
-            logMCPDebug(name, `Elicitation request received during initialization: ${jsonStringify(request)}`);
-            return { action: 'cancel' };
-        });
-        if (serverRef.type === 'sse-ide' || serverRef.type === 'ws-ide') {
-            const ideConnectionDurationMs = Date.now() - connectStartTime;
-            logEvent('tengu_mcp_ide_server_connection_succeeded', {
-                connectionDurationMs: ideConnectionDurationMs,
-                serverVersion: serverVersion,
-            });
-            try {
-                void maybeNotifyIDEConnected(client);
-            }
-            catch (error) {
-                logMCPError(name, `Failed to send ide_connected notification: ${error}`);
-            }
-        }
-        // Enhanced connection drop detection and logging for all transport types
-        const connectionStartTime = Date.now();
-        let hasErrorOccurred = false;
-        // Store original handlers
-        const originalOnerror = client.onerror;
-        const originalOnclose = client.onclose;
-        // The SDK's transport calls onerror on connection failures but doesn't call onclose,
-        // which CC uses to trigger reconnection. We bridge this gap by tracking consecutive
-        // terminal errors and manually closing after MAX_ERRORS_BEFORE_RECONNECT failures.
-        let consecutiveConnectionErrors = 0;
-        const MAX_ERRORS_BEFORE_RECONNECT = 3;
-        // Guard against re-entry: close() aborts in-flight streams which may fire
-        // onerror again before the close chain completes.
-        let hasTriggeredClose = false;
-        // client.close() → transport.close() → transport.onclose → SDK's _onclose():
-        // rejects all pending request handlers (so hung callTool() promises fail with
-        // McpError -32000 "Connection closed") and then invokes our client.onclose
-        // handler below (which clears the memo cache so the next call reconnects).
-        // Calling client.onclose?.() directly would only clear the cache — pending
-        // tool calls would stay hung.
-        const closeTransportAndRejectPending = (reason) => {
-            if (hasTriggeredClose)
-                return;
-            hasTriggeredClose = true;
-            logMCPDebug(name, `Closing transport (${reason})`);
-            void client.close().catch(e => {
-                logMCPDebug(name, `Error during close: ${errorMessage(e)}`);
-            });
-        };
-        const isTerminalConnectionError = (msg) => {
-            return (msg.includes('ECONNRESET') ||
-                msg.includes('ETIMEDOUT') ||
-                msg.includes('EPIPE') ||
-                msg.includes('EHOSTUNREACH') ||
-                msg.includes('ECONNREFUSED') ||
-                msg.includes('Body Timeout Error') ||
-                msg.includes('terminated') ||
-                // SDK SSE reconnection intermediate errors — may be wrapped around the
-                // actual network error, so the substrings above won't match
-                msg.includes('SSE stream disconnected') ||
-                msg.includes('Failed to reconnect SSE stream'));
-        };
-        // Enhanced error handler with detailed logging
-        client.onerror = (error) => {
-            const uptime = Date.now() - connectionStartTime;
-            hasErrorOccurred = true;
-            const transportType = serverRef.type || 'stdio';
-            // Log the connection drop with context
-            logMCPDebug(name, `${transportType.toUpperCase()} connection dropped after ${Math.floor(uptime / 1000)}s uptime`);
-            // Log specific error details for debugging
-            if (error.message) {
-                if (error.message.includes('ECONNRESET')) {
-                    logMCPDebug(name, `Connection reset - server may have crashed or restarted`);
-                }
-                else if (error.message.includes('ETIMEDOUT')) {
-                    logMCPDebug(name, `Connection timeout - network issue or server unresponsive`);
-                }
-                else if (error.message.includes('ECONNREFUSED')) {
-                    logMCPDebug(name, `Connection refused - server may be down`);
-                }
-                else if (error.message.includes('EPIPE')) {
-                    logMCPDebug(name, `Broken pipe - server closed connection unexpectedly`);
-                }
-                else if (error.message.includes('EHOSTUNREACH')) {
-                    logMCPDebug(name, `Host unreachable - network connectivity issue`);
-                }
-                else if (error.message.includes('ESRCH')) {
-                    logMCPDebug(name, `Process not found - stdio server process terminated`);
-                }
-                else if (error.message.includes('spawn')) {
-                    logMCPDebug(name, `Failed to spawn process - check command and permissions`);
-                }
-                else {
-                    logMCPDebug(name, `Connection error: ${error.message}`);
-                }
-            }
-            // For HTTP transports, detect session expiry (404 + JSON-RPC -32001)
-            // and close the transport so pending tool calls reject and the next
-            // call reconnects with a fresh session ID.
-            if ((transportType === 'http' || transportType === 'claudeai-proxy') &&
-                isMcpSessionExpiredError(error)) {
-                logMCPDebug(name, `MCP session expired (server returned 404 with session-not-found), triggering reconnection`);
-                closeTransportAndRejectPending('session expired');
-                if (originalOnerror) {
-                    originalOnerror(error);
-                }
-                return;
-            }
-            // For remote transports (SSE/HTTP), track terminal connection errors
-            // and trigger reconnection via close if we see repeated failures.
-            if (transportType === 'sse' ||
-                transportType === 'http' ||
-                transportType === 'claudeai-proxy') {
-                // The SDK's StreamableHTTP transport fires this after exhausting its
-                // own SSE reconnect attempts (default maxRetries: 2) — but it never
-                // calls onclose, so pending callTool() promises hang indefinitely.
-                // This is the definitive "transport gave up" signal.
-                if (error.message.includes('Maximum reconnection attempts')) {
-                    closeTransportAndRejectPending('SSE reconnection exhausted');
-                    if (originalOnerror) {
-                        originalOnerror(error);
-                    }
-                    return;
-                }
-                if (isTerminalConnectionError(error.message)) {
-                    consecutiveConnectionErrors++;
-                    logMCPDebug(name, `Terminal connection error ${consecutiveConnectionErrors}/${MAX_ERRORS_BEFORE_RECONNECT}`);
-                    if (consecutiveConnectionErrors >= MAX_ERRORS_BEFORE_RECONNECT) {
-                        consecutiveConnectionErrors = 0;
-                        closeTransportAndRejectPending('max consecutive terminal errors');
-                    }
-                }
-                else {
-                    // Non-terminal error (e.g., transient issue), reset counter
-                    consecutiveConnectionErrors = 0;
-                }
-            }
-            // Call original handler
-            if (originalOnerror) {
-                originalOnerror(error);
-            }
-        };
-        // Enhanced close handler with connection drop context
-        client.onclose = () => {
-            const uptime = Date.now() - connectionStartTime;
-            const transportType = serverRef.type ?? 'unknown';
-            logMCPDebug(name, `${transportType.toUpperCase()} connection closed after ${Math.floor(uptime / 1000)}s (${hasErrorOccurred ? 'with errors' : 'cleanly'})`);
-            // Clear the memoization cache so next operation reconnects
-            const key = getServerCacheKey(name, serverRef);
-            // Also clear fetch caches (keyed by server name). Reconnection
-            // creates a new connection object; without clearing, the next
-            // fetch would return stale tools/resources from the old connection.
-            fetchToolsForClient.cache.delete(name);
-            fetchResourcesForClient.cache.delete(name);
-            fetchCommandsForClient.cache.delete(name);
-            if (feature('MCP_SKILLS')) {
-                fetchMcpSkillsForClient.cache.delete(name);
-            }
-            connectToServer.cache.delete(key);
-            logMCPDebug(name, `Cleared connection cache for reconnection`);
-            if (originalOnclose) {
-                originalOnclose();
-            }
-        };
-        const cleanup = async () => {
-            // In-process servers (e.g. Chrome MCP) don't have child processes or stderr
-            if (inProcessServer) {
-                try {
-                    await inProcessServer.close();
-                }
-                catch (error) {
-                    logMCPDebug(name, `Error closing in-process server: ${error}`);
-                }
-                try {
-                    await client.close();
-                }
-                catch (error) {
-                    logMCPDebug(name, `Error closing client: ${error}`);
-                }
-                return;
-            }
-            // Remove stderr event listener to prevent memory leaks
-            if (stderrHandler && (serverRef.type === 'stdio' || !serverRef.type)) {
-                const stdioTransport = transport;
-                stdioTransport.stderr?.off('data', stderrHandler);
-            }
-            // For stdio transports, explicitly terminate the child process with proper signals
-            // NOTE: StdioClientTransport.close() only sends an abort signal, but many MCP servers
-            // (especially Docker containers) need explicit SIGINT/SIGTERM signals to trigger graceful shutdown
-            if (serverRef.type === 'stdio') {
-                try {
-                    const stdioTransport = transport;
-                    const childPid = stdioTransport.pid;
-                    if (childPid) {
-                        logMCPDebug(name, 'Sending SIGINT to MCP server process');
-                        // First try SIGINT (like Ctrl+C)
-                        try {
-                            process.kill(childPid, 'SIGINT');
-                        }
-                        catch (error) {
-                            logMCPDebug(name, `Error sending SIGINT: ${error}`);
-                            return;
-                        }
-                        // Wait for graceful shutdown with rapid escalation (total 500ms to keep CLI responsive)
-                        await new Promise(async (resolve) => {
-                            let resolved = false;
-                            // Set up a timer to check if process still exists
-                            const checkInterval = setInterval(() => {
-                                try {
-                                    // process.kill(pid, 0) checks if process exists without killing it
-                                    process.kill(childPid, 0);
-                                }
-                                catch {
-                                    // Process no longer exists
-                                    if (!resolved) {
-                                        resolved = true;
-                                        clearInterval(checkInterval);
-                                        clearTimeout(failsafeTimeout);
-                                        logMCPDebug(name, 'MCP server process exited cleanly');
-                                        resolve();
-                                    }
-                                }
-                            }, 50);
-                            // Absolute failsafe: clear interval after 600ms no matter what
-                            const failsafeTimeout = setTimeout(() => {
-                                if (!resolved) {
-                                    resolved = true;
-                                    clearInterval(checkInterval);
-                                    logMCPDebug(name, 'Cleanup timeout reached, stopping process monitoring');
-                                    resolve();
-                                }
-                            }, 600);
-                            try {
-                                // Wait 100ms for SIGINT to work (usually much faster)
-                                await sleep(100);
-                                if (!resolved) {
-                                    // Check if process still exists
-                                    try {
-                                        process.kill(childPid, 0);
-                                        // Process still exists, SIGINT failed, try SIGTERM
-                                        logMCPDebug(name, 'SIGINT failed, sending SIGTERM to MCP server process');
-                                        try {
-                                            process.kill(childPid, 'SIGTERM');
-                                        }
-                                        catch (termError) {
-                                            logMCPDebug(name, `Error sending SIGTERM: ${termError}`);
-                                            resolved = true;
-                                            clearInterval(checkInterval);
-                                            clearTimeout(failsafeTimeout);
-                                            resolve();
-                                            return;
-                                        }
-                                    }
-                                    catch {
-                                        // Process already exited
-                                        resolved = true;
-                                        clearInterval(checkInterval);
-                                        clearTimeout(failsafeTimeout);
-                                        resolve();
-                                        return;
-                                    }
-                                    // Wait 400ms for SIGTERM to work (slower than SIGINT, often used for cleanup)
-                                    await sleep(400);
-                                    if (!resolved) {
-                                        // Check if process still exists
-                                        try {
-                                            process.kill(childPid, 0);
-                                            // Process still exists, SIGTERM failed, force kill with SIGKILL
-                                            logMCPDebug(name, 'SIGTERM failed, sending SIGKILL to MCP server process');
-                                            try {
-                                                process.kill(childPid, 'SIGKILL');
-                                            }
-                                            catch (killError) {
-                                                logMCPDebug(name, `Error sending SIGKILL: ${killError}`);
-                                            }
-                                        }
-                                        catch {
-                                            // Process already exited
-                                            resolved = true;
-                                            clearInterval(checkInterval);
-                                            clearTimeout(failsafeTimeout);
-                                            resolve();
-                                        }
-                                    }
-                                }
-                                // Final timeout - always resolve after 500ms max (total cleanup time)
-                                if (!resolved) {
-                                    resolved = true;
-                                    clearInterval(checkInterval);
-                                    clearTimeout(failsafeTimeout);
-                                    resolve();
-                                }
-                            }
-                            catch {
-                                // Handle any errors in the escalation sequence
-                                if (!resolved) {
-                                    resolved = true;
-                                    clearInterval(checkInterval);
-                                    clearTimeout(failsafeTimeout);
-                                    resolve();
-                                }
-                            }
-                        });
-                    }
-                }
-                catch (processError) {
-                    logMCPDebug(name, `Error terminating process: ${processError}`);
-                }
-            }
-            // Close the client connection (which also closes the transport)
-            try {
-                await client.close();
-            }
-            catch (error) {
-                logMCPDebug(name, `Error closing client: ${error}`);
-            }
-        };
-        // Register cleanup for all transport types - even network transports might need cleanup
-        // This ensures all MCP servers get properly terminated, not just stdio ones
-        const cleanupUnregister = registerCleanup(cleanup);
-        // Create the wrapped cleanup that includes unregistering
-        const wrappedCleanup = async () => {
-            cleanupUnregister?.();
-            await cleanup();
-        };
-        const connectionDurationMs = Date.now() - connectStartTime;
-        logEvent('tengu_mcp_server_connection_succeeded', {
-            connectionDurationMs,
-            transportType: (serverRef.type ??
-                'stdio'),
-            totalServers: serverStats?.totalServers,
-            stdioCount: serverStats?.stdioCount,
-            sseCount: serverStats?.sseCount,
-            httpCount: serverStats?.httpCount,
-            sseIdeCount: serverStats?.sseIdeCount,
-            wsIdeCount: serverStats?.wsIdeCount,
-            ...mcpBaseUrlAnalytics(serverRef),
-        });
-        return {
-            name,
-            client,
-            type: 'connected',
-            capabilities: capabilities ?? {},
-            serverInfo: serverVersion,
-            instructions,
-            config: serverRef,
-            cleanup: wrappedCleanup,
-        };
-    }
-    catch (error) {
-        const connectionDurationMs = Date.now() - connectStartTime;
-        logEvent('tengu_mcp_server_connection_failed', {
-            connectionDurationMs,
-            totalServers: serverStats?.totalServers || 1,
-            stdioCount: serverStats?.stdioCount || (serverRef.type === 'stdio' ? 1 : 0),
-            sseCount: serverStats?.sseCount || (serverRef.type === 'sse' ? 1 : 0),
-            httpCount: serverStats?.httpCount || (serverRef.type === 'http' ? 1 : 0),
-            sseIdeCount: serverStats?.sseIdeCount || (serverRef.type === 'sse-ide' ? 1 : 0),
-            wsIdeCount: serverStats?.wsIdeCount || (serverRef.type === 'ws-ide' ? 1 : 0),
-            transportType: (serverRef.type ??
-                'stdio'),
-            ...mcpBaseUrlAnalytics(serverRef),
-        });
-        logMCPDebug(name, `Connection failed after ${connectionDurationMs}ms: ${errorMessage(error)}`);
-        logMCPError(name, `Connection failed: ${errorMessage(error)}`);
-        if (inProcessServer) {
-            inProcessServer.close().catch(() => { });
-        }
-        return {
-            name,
-            type: 'failed',
-            config: serverRef,
-            error: errorMessage(error),
-        };
-    }
-}, getServerCacheKey);
-/**
- * Clears the memoize cache for a specific server
- * @param name Server name
- * @param serverRef Server configuration
- */
-export async function clearServerCache(name, serverRef) {
-    const key = getServerCacheKey(name, serverRef);
-    try {
-        const wrappedClient = await connectToServer(name, serverRef);
-        if (wrappedClient.type === 'connected') {
-            await wrappedClient.cleanup();
-        }
-    }
-    catch {
-        // Ignore errors - server might have failed to connect
-    }
-    // Clear from cache (both connection and fetch caches so reconnect
-    // fetches fresh tools/resources/commands instead of stale ones)
-    connectToServer.cache.delete(key);
-    fetchToolsForClient.cache.delete(name);
-    fetchResourcesForClient.cache.delete(name);
-    fetchCommandsForClient.cache.delete(name);
-    if (feature('MCP_SKILLS')) {
-        fetchMcpSkillsForClient.cache.delete(name);
-    }
-}
-/**
- * Ensures a valid connected client for an MCP server.
- * For most server types, uses the memoization cache if available, or reconnects
- * if the cache was cleared (e.g., after onclose). This ensures tool/resource
- * calls always use a valid connection.
- *
- * SDK MCP servers run in-process and are handled separately via setupSdkMcpClients,
- * so they are returned as-is without going through connectToServer.
- *
- * @param client The connected MCP server client
- * @returns Connected MCP server client (same or reconnected)
- * @throws Error if server cannot be connected
- */
-export async function ensureConnectedClient(client) {
-    // SDK MCP servers run in-process and are handled separately via setupSdkMcpClients
-    if (client.config.type === 'sdk') {
-        return client;
-    }
-    const connectedClient = await connectToServer(client.name, client.config);
-    if (connectedClient.type !== 'connected') {
-        throw new TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS(`MCP server "${client.name}" is not connected`, 'MCP server not connected');
-    }
-    return connectedClient;
-}
-/**
- * Compares two MCP server configurations to determine if they are equivalent.
- * Used to detect when a server needs to be reconnected due to config changes.
- */
-export function areMcpConfigsEqual(a, b) {
-    // Quick type check first
-    if (a.type !== b.type)
-        return false;
-    // Compare by serializing - this handles all config variations
-    // We exclude 'scope' from comparison since it's metadata, not connection config
-    const { scope: _scopeA, ...configA } = a;
-    const { scope: _scopeB, ...configB } = b;
-    return jsonStringify(configA) === jsonStringify(configB);
-}
-// Max cache size for fetch* caches. Keyed by server name (stable across
-// reconnects), bounded to prevent unbounded growth with many MCP servers.
-const MCP_FETCH_CACHE_SIZE = 20;
-/**
- * Encode MCP tool input for the auto-mode security classifier.
- * Exported so the auto-mode eval scripts can mirror production encoding
- * for `mcp__*` tool stubs without duplicating this logic.
- */
-export function mcpToolInputToAutoClassifierInput(input, toolName) {
-    const keys = Object.keys(input);
-    return keys.length > 0
-        ? keys.map(k => `${k}=${String(input[k])}`).join(' ')
-        : toolName;
-}
-export const fetchToolsForClient = memoizeWithLRU(async (client) => {
-    if (client.type !== 'connected')
-        return [];
-    try {
-        if (!client.capabilities?.tools) {
-            return [];
-        }
-        const result = (await client.client.request({ method: 'tools/list' }, ListToolsResultSchema));
-        // Sanitize tool data from MCP server
-        const toolsToProcess = recursivelySanitizeUnicode(result.tools);
-        // Check if we should skip the mcp__ prefix for SDK MCP servers
-        const skipPrefix = client.config.type === 'sdk' &&
-            isEnvTruthy(process.env.CLAUDE_AGENT_SDK_MCP_NO_PREFIX);
-        // Convert MCP tools to our Tool format
-        return toolsToProcess
-            .map((tool) => {
-            const fullyQualifiedName = buildMcpToolName(client.name, tool.name);
-            return {
-                ...MCPTool,
-                // In skip-prefix mode, use the original name for model invocation so MCP tools
-                // can override builtins by name. mcpInfo is used for permission checking.
-                name: skipPrefix ? tool.name : fullyQualifiedName,
-                mcpInfo: { serverName: client.name, toolName: tool.name },
-                isMcp: true,
-                // Collapse whitespace: _meta is open to external MCP servers, and
-                // a newline here would inject orphan lines into the deferred-tool
-                // list (formatDeferredToolLine joins on '\n').
-                searchHint: typeof tool._meta?.['anthropic/searchHint'] === 'string'
-                    ? tool._meta['anthropic/searchHint']
-                        .replace(/\s+/g, ' ')
-                        .trim() || undefined
-                    : undefined,
-                alwaysLoad: tool._meta?.['anthropic/alwaysLoad'] === true,
-                async description() {
-                    return tool.description ?? '';
-                },
-                async prompt() {
-                    const desc = tool.description ?? '';
-                    return desc.length > MAX_MCP_DESCRIPTION_LENGTH
-                        ? desc.slice(0, MAX_MCP_DESCRIPTION_LENGTH) + '… [truncated]'
-                        : desc;
-                },
-                isConcurrencySafe() {
-                    return tool.annotations?.readOnlyHint ?? false;
-                },
-                isReadOnly() {
-                    return tool.annotations?.readOnlyHint ?? false;
-                },
-                toAutoClassifierInput(input) {
-                    return mcpToolInputToAutoClassifierInput(input, tool.name);
-                },
-                isDestructive() {
-                    return tool.annotations?.destructiveHint ?? false;
-                },
-                isOpenWorld() {
-                    return tool.annotations?.openWorldHint ?? false;
-                },
-                isSearchOrReadCommand() {
-                    return classifyMcpToolForCollapse(client.name, tool.name);
-                },
-                inputJSONSchema: tool.inputSchema,
-                async checkPermissions() {
-                    return {
-                        behavior: 'passthrough',
-                        message: 'MCPTool requires permission.',
-                        suggestions: [
-                            {
-                                type: 'addRules',
-                                rules: [
-                                    {
-                                        toolName: fullyQualifiedName,
-                                        ruleContent: undefined,
-                                    },
-                                ],
-                                behavior: 'allow',
-                                destination: 'localSettings',
-                            },
-                        ],
-                    };
-                },
-                async call(args, context, _canUseTool, parentMessage, onProgress) {
-                    const toolUseId = extractToolUseId(parentMessage);
-                    const meta = toolUseId
-                        ? { 'claudecode/toolUseId': toolUseId }
-                        : {};
-                    // Emit progress when tool starts
-                    if (onProgress && toolUseId) {
-                        onProgress({
-                            toolUseID: toolUseId,
-                            data: {
-                                type: 'mcp_progress',
-                                status: 'started',
-                                serverName: client.name,
-                                toolName: tool.name,
-                            },
-                        });
-                    }
-                    const startTime = Date.now();
-                    const MAX_SESSION_RETRIES = 1;
-                    for (let attempt = 0;; attempt++) {
-                        try {
-                            const connectedClient = await ensureConnectedClient(client);
-                            const mcpResult = await callMCPToolWithUrlElicitationRetry({
-                                client: connectedClient,
-                                clientConnection: client,
-                                tool: tool.name,
-                                args,
-                                meta,
-                                signal: context.abortController.signal,
-                                setAppState: context.setAppState,
-                                onProgress: onProgress && toolUseId
-                                    ? progressData => {
-                                        onProgress({
-                                            toolUseID: toolUseId,
-                                            data: progressData,
-                                        });
-                                    }
-                                    : undefined,
-                                handleElicitation: context.handleElicitation,
-                            });
-                            // Emit progress when tool completes successfully
-                            if (onProgress && toolUseId) {
-                                onProgress({
-                                    toolUseID: toolUseId,
-                                    data: {
-                                        type: 'mcp_progress',
-                                        status: 'completed',
-                                        serverName: client.name,
-                                        toolName: tool.name,
-                                        elapsedTimeMs: Date.now() - startTime,
-                                    },
-                                });
-                            }
-                            return {
-                                data: mcpResult.content,
-                                ...((mcpResult._meta || mcpResult.structuredContent) && {
-                                    mcpMeta: {
-                                        ...(mcpResult._meta && {
-                                            _meta: mcpResult._meta,
-                                        }),
-                                        ...(mcpResult.structuredContent && {
-                                            structuredContent: mcpResult.structuredContent,
-                                        }),
-                                    },
-                                }),
-                            };
-                        }
-                        catch (error) {
-                            // Session expired — the connection cache has been
-                            // cleared, so retry with a fresh client.
-                            if (error instanceof McpSessionExpiredError &&
-                                attempt < MAX_SESSION_RETRIES) {
-                                logMCPDebug(client.name, `Retrying tool '${tool.name}' after session recovery`);
-                                continue;
-                            }
-                            // Emit progress when tool fails
-                            if (onProgress && toolUseId) {
-                                onProgress({
-                                    toolUseID: toolUseId,
-                                    data: {
-                                        type: 'mcp_progress',
-                                        status: 'failed',
-                                        serverName: client.name,
-                                        toolName: tool.name,
-                                        elapsedTimeMs: Date.now() - startTime,
-                                    },
-                                });
-                            }
-                            // Wrap MCP SDK errors so telemetry gets useful context
-                            // instead of just "Error" or "McpError" (the constructor
-                            // name). MCP SDK errors are protocol-level messages and
-                            // don't contain user file paths or code.
-                            if (error instanceof Error &&
-                                !(error instanceof
-                                    TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS)) {
-                                const name = error.constructor.name;
-                                if (name === 'Error') {
-                                    throw new TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS(error.message, error.message.slice(0, 200));
-                                }
-                                // McpError has a numeric `code` with the JSON-RPC error
-                                // code (e.g. -32000 ConnectionClosed, -32001 RequestTimeout)
-                                if (name === 'McpError' &&
-                                    'code' in error &&
-                                    typeof error.code === 'number') {
-                                    throw new TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS(error.message, `McpError ${error.code}`);
-                                }
-                            }
-                            throw error;
-                        }
-                    }
-                },
-                userFacingName() {
-                    // Prefer title annotation if available, otherwise use tool name
-                    const displayName = tool.annotations?.title || tool.name;
-                    return `${client.name} - ${displayName} (MCP)`;
-                },
-                ...(isClaudeInChromeMCPServer(client.name) &&
-                    (client.config.type === 'stdio' || !client.config.type)
-                    ? claudeInChromeToolRendering().getClaudeInChromeMCPToolOverrides(tool.name)
-                    : {}),
-                ...(feature('CHICAGO_MCP') &&
-                    (client.config.type === 'stdio' || !client.config.type) &&
-                    isComputerUseMCPServer(client.name)
-                    ? computerUseWrapper().getComputerUseMCPToolOverrides(tool.name)
-                    : {}),
-            };
-        })
-            .filter(isIncludedMcpTool);
-    }
-    catch (error) {
-        logMCPError(client.name, `Failed to fetch tools: ${errorMessage(error)}`);
-        return [];
-    }
-}, (client) => client.name, MCP_FETCH_CACHE_SIZE);
-export const fetchResourcesForClient = memoizeWithLRU(async (client) => {
-    if (client.type !== 'connected')
-        return [];
-    try {
-        if (!client.capabilities?.resources) {
-            return [];
-        }
-        const result = await client.client.request({ method: 'resources/list' }, ListResourcesResultSchema);
-        if (!result.resources)
-            return [];
-        // Add server name to each resource
-        return result.resources.map(resource => ({
-            ...resource,
-            server: client.name,
-        }));
-    }
-    catch (error) {
-        logMCPError(client.name, `Failed to fetch resources: ${errorMessage(error)}`);
-        return [];
-    }
-}, (client) => client.name, MCP_FETCH_CACHE_SIZE);
-export const fetchCommandsForClient = memoizeWithLRU(async (client) => {
-    if (client.type !== 'connected')
-        return [];
-    try {
-        if (!client.capabilities?.prompts) {
-            return [];
-        }
-        // Request prompts list from client
-        const result = (await client.client.request({ method: 'prompts/list' }, ListPromptsResultSchema));
-        if (!result.prompts)
-            return [];
-        // Sanitize prompt data from MCP server
-        const promptsToProcess = recursivelySanitizeUnicode(result.prompts);
-        // Convert MCP prompts to our Command format
-        return promptsToProcess.map(prompt => {
-            const argNames = Object.values(prompt.arguments ?? {}).map(k => k.name);
-            return {
-                type: 'prompt',
-                name: 'mcp__' + normalizeNameForMCP(client.name) + '__' + prompt.name,
-                description: prompt.description ?? '',
-                hasUserSpecifiedDescription: !!prompt.description,
-                contentLength: 0, // Dynamic MCP content
-                isEnabled: () => true,
-                isHidden: false,
-                isMcp: true,
-                progressMessage: 'running',
-                userFacingName() {
-                    // Use prompt.name (programmatic identifier) not prompt.title (display name)
-                    // to avoid spaces breaking slash command parsing
-                    return `${client.name}:${prompt.name} (MCP)`;
-                },
-                argNames,
-                source: 'mcp',
-                async getPromptForCommand(args) {
-                    const argsArray = args.split(' ');
-                    try {
-                        const connectedClient = await ensureConnectedClient(client);
-                        const result = await connectedClient.client.getPrompt({
-                            name: prompt.name,
-                            arguments: zipObject(argNames, argsArray),
-                        });
-                        const transformed = await Promise.all(result.messages.map(message => transformResultContent(message.content, connectedClient.name)));
-                        return transformed.flat();
-                    }
-                    catch (error) {
-                        logMCPError(client.name, `Error running command '${prompt.name}': ${errorMessage(error)}`);
-                        throw error;
-                    }
-                },
-            };
-        });
-    }
-    catch (error) {
-        logMCPError(client.name, `Failed to fetch commands: ${errorMessage(error)}`);
-        return [];
-    }
-}, (client) => client.name, MCP_FETCH_CACHE_SIZE);
-/**
- * Call an IDE tool directly as an RPC
- * @param toolName The name of the tool to call
- * @param args The arguments to pass to the tool
- * @param client The IDE client to use for the RPC call
- * @returns The result of the tool call
- */
-export async function callIdeRpc(toolName, args, client) {
-    const result = await callMCPTool({
-        client,
-        tool: toolName,
-        args,
-        signal: createAbortController().signal,
-    });
-    return result.content;
-}
-/**
- * Note: This should not be called by UI components directly, they should use the reconnectMcpServer
- * function from useManageMcpConnections.
- * @param name Server name
- * @param config Server configuration
- * @returns Object containing the client connection and its resources
- */
-export async function reconnectMcpServerImpl(name, config) {
-    try {
-        // Invalidate the keychain cache so we read fresh credentials from disk.
-        // This is necessary when another process (e.g. the VS Code extension host)
-        // has modified stored tokens (cleared auth, saved new OAuth tokens) and then
-        // asks the CLI subprocess to reconnect.  Without this, the subprocess would
-        // use stale cached data and never notice the tokens were removed.
-        clearKeychainCache();
-        await clearServerCache(name, config);
-        const client = await connectToServer(name, config);
-        if (client.type !== 'connected') {
-            return {
-                client,
-                tools: [],
-                commands: [],
-            };
-        }
-        if (config.type === 'claudeai-proxy') {
-            markClaudeAiMcpConnected(name);
-        }
-        const supportsResources = !!client.capabilities?.resources;
-        const [tools, mcpCommands, mcpSkills, resources] = await Promise.all([
-            fetchToolsForClient(client),
-            fetchCommandsForClient(client),
-            feature('MCP_SKILLS') && supportsResources
-                ? fetchMcpSkillsForClient(client)
-                : Promise.resolve([]),
-            supportsResources ? fetchResourcesForClient(client) : Promise.resolve([]),
-        ]);
-        const commands = [...mcpCommands, ...mcpSkills];
-        // Check if we need to add resource tools
-        const resourceTools = [];
-        if (supportsResources) {
-            // Only add resource tools if no other server has them
-            const hasResourceTools = [ListMcpResourcesTool, ReadMcpResourceTool].some(tool => tools.some(t => toolMatchesName(t, tool.name)));
-            if (!hasResourceTools) {
-                resourceTools.push(ListMcpResourcesTool, ReadMcpResourceTool);
-            }
-        }
-        return {
-            client,
-            tools: [...tools, ...resourceTools],
-            commands,
-            resources: resources.length > 0 ? resources : undefined,
-        };
-    }
-    catch (error) {
-        // Handle errors gracefully - connection might have closed during fetch
-        logMCPError(name, `Error during reconnection: ${errorMessage(error)}`);
-        // Return with failed status
-        return {
-            client: { name, type: 'failed', config },
-            tools: [],
-            commands: [],
-        };
-    }
-}
-// Replaced 2026-03: previous implementation ran fixed-size sequential batches
-// (await batch 1 fully, then start batch 2). That meant one slow server in
-// batch N held up ALL servers in batch N+1, even if the other 19 slots were
-// idle. pMap frees each slot as soon as its server completes, so a single
-// slow server only occupies one slot instead of blocking an entire batch
-// boundary. Same concurrency ceiling, same results, better scheduling.
-async function processBatched(items, concurrency, processor) {
-    await pMap(items, processor, { concurrency });
-}
-export async function getMcpToolsCommandsAndResources(onConnectionAttempt, mcpConfigs) {
-    let resourceToolsAdded = false;
-    const allConfigEntries = Object.entries(mcpConfigs ?? (await getAllMcpConfigs()).servers);
-    // Partition into disabled and active entries — disabled servers should
-    // never generate HTTP connections or flow through batch processing
-    const configEntries = [];
-    for (const entry of allConfigEntries) {
-        if (isMcpServerDisabled(entry[0])) {
-            onConnectionAttempt({
-                client: { name: entry[0], type: 'disabled', config: entry[1] },
-                tools: [],
-                commands: [],
-            });
-        }
-        else {
-            configEntries.push(entry);
-        }
-    }
-    // Calculate transport counts for logging
-    const totalServers = configEntries.length;
-    const stdioCount = count(configEntries, ([_, c]) => c.type === 'stdio');
-    const sseCount = count(configEntries, ([_, c]) => c.type === 'sse');
-    const httpCount = count(configEntries, ([_, c]) => c.type === 'http');
-    const sseIdeCount = count(configEntries, ([_, c]) => c.type === 'sse-ide');
-    const wsIdeCount = count(configEntries, ([_, c]) => c.type === 'ws-ide');
-    // Split servers by type: local (stdio/sdk) need lower concurrency due to
-    // process spawning, remote servers can connect with higher concurrency
-    const localServers = configEntries.filter(([_, config]) => isLocalMcpServer(config));
-    const remoteServers = configEntries.filter(([_, config]) => !isLocalMcpServer(config));
-    const serverStats = {
-        totalServers,
-        stdioCount,
-        sseCount,
-        httpCount,
-        sseIdeCount,
-        wsIdeCount,
-    };
-    const processServer = async ([name, config]) => {
-        try {
-            // Check if server is disabled - if so, just add it to state without connecting
-            if (isMcpServerDisabled(name)) {
-                onConnectionAttempt({
-                    client: {
-                        name,
-                        type: 'disabled',
-                        config,
-                    },
-                    tools: [],
-                    commands: [],
-                });
-                return;
-            }
-            // Skip connection for servers that recently returned 401 (15min TTL),
-            // or that we have probed before but hold no token for. The second
-            // check closes the gap the TTL leaves open: without it, every 15min
-            // we re-probe servers that cannot succeed until the user runs /mcp.
-            // Each probe is a network round-trip for connect-401 plus OAuth
-            // discovery, and print mode awaits the whole batch (main.tsx:3503).
-            if ((config.type === 'claudeai-proxy' ||
-                config.type === 'http' ||
-                config.type === 'sse') &&
-                ((await isMcpAuthCached(name)) ||
-                    ((config.type === 'http' || config.type === 'sse') &&
-                        hasMcpDiscoveryButNoToken(name, config)))) {
-                logMCPDebug(name, `Skipping connection (cached needs-auth)`);
-                onConnectionAttempt({
-                    client: { name, type: 'needs-auth', config },
-                    tools: [createMcpAuthTool(name, config)],
-                    commands: [],
-                });
-                return;
-            }
-            const client = await connectToServer(name, config, serverStats);
-            if (client.type !== 'connected') {
-                onConnectionAttempt({
-                    client,
-                    tools: client.type === 'needs-auth'
-                        ? [createMcpAuthTool(name, config)]
-                        : [],
-                    commands: [],
-                });
-                return;
-            }
-            if (config.type === 'claudeai-proxy') {
-                markClaudeAiMcpConnected(name);
-            }
-            const supportsResources = !!client.capabilities?.resources;
-            const [tools, mcpCommands, mcpSkills, resources] = await Promise.all([
-                fetchToolsForClient(client),
-                fetchCommandsForClient(client),
-                // Discover skills from skill:// resources
-                feature('MCP_SKILLS') && supportsResources
-                    ? fetchMcpSkillsForClient(client)
-                    : Promise.resolve([]),
-                // Fetch resources if supported
-                supportsResources
-                    ? fetchResourcesForClient(client)
-                    : Promise.resolve([]),
-            ]);
-            const commands = [...mcpCommands, ...mcpSkills];
-            // If this server resources and we haven't added resource tools yet,
-            // include our resource tools with this client's tools
-            const resourceTools = [];
-            if (supportsResources && !resourceToolsAdded) {
-                resourceToolsAdded = true;
-                resourceTools.push(ListMcpResourcesTool, ReadMcpResourceTool);
-            }
-            onConnectionAttempt({
-                client,
-                tools: [...tools, ...resourceTools],
-                commands,
-                resources: resources.length > 0 ? resources : undefined,
-            });
-        }
-        catch (error) {
-            // Handle errors gracefully - connection might have closed during fetch
-            logMCPError(name, `Error fetching tools/commands/resources: ${errorMessage(error)}`);
-            // Still update with the client but no tools/commands
-            onConnectionAttempt({
-                client: { name, type: 'failed', config },
-                tools: [],
-                commands: [],
-            });
-        }
-    };
-    // Process both groups concurrently, each with their own concurrency limits:
-    // - Local servers (stdio/sdk): lower concurrency to avoid process spawning resource contention
-    // - Remote servers: higher concurrency since they're just network connections
-    await Promise.all([
-        processBatched(localServers, getMcpServerConnectionBatchSize(), processServer),
-        processBatched(remoteServers, getRemoteMcpServerConnectionBatchSize(), processServer),
-    ]);
-}
-// Not memoized: called only 2-3 times at startup/reconfig. The inner work
-// (connectToServer, fetch*ForClient) is already cached. Memoizing here by
-// mcpConfigs object ref leaked — main.tsx creates fresh config objects each call.
-export function prefetchAllMcpResources(mcpConfigs) {
-    return new Promise(resolve => {
-        let pendingCount = 0;
-        let completedCount = 0;
-        pendingCount = Object.keys(mcpConfigs).length;
-        if (pendingCount === 0) {
-            void resolve({
-                clients: [],
-                tools: [],
-                commands: [],
-            });
-            return;
-        }
-        const clients = [];
-        const tools = [];
-        const commands = [];
-        getMcpToolsCommandsAndResources(result => {
-            clients.push(result.client);
-            tools.push(...result.tools);
-            commands.push(...result.commands);
-            completedCount++;
-            if (completedCount >= pendingCount) {
-                const commandsMetadataLength = commands.reduce((sum, command) => {
-                    const commandMetadataLength = command.name.length +
-                        (command.description ?? '').length +
-                        (command.argumentHint ?? '').length;
-                    return sum + commandMetadataLength;
-                }, 0);
-                logEvent('tengu_mcp_tools_commands_loaded', {
-                    tools_count: tools.length,
-                    commands_count: commands.length,
-                    commands_metadata_length: commandsMetadataLength,
-                });
-                void resolve({
-                    clients,
-                    tools,
-                    commands,
-                });
-            }
-        }, mcpConfigs).catch(error => {
-            logMCPError('prefetchAllMcpResources', `Failed to get MCP resources: ${errorMessage(error)}`);
-            // Still resolve with empty results
-            void resolve({
-                clients: [],
-                tools: [],
-                commands: [],
-            });
-        });
-    });
-}
-/**
- * Transform result content from an MCP tool or MCP prompt into message blocks
- */
-export async function transformResultContent(resultContent, serverName) {
-    switch (resultContent.type) {
-        case 'text':
-            return [
-                {
-                    type: 'text',
-                    text: resultContent.text,
-                },
-            ];
-        case 'audio': {
-            const audioData = resultContent;
-            return await persistBlobToTextBlock(Buffer.from(audioData.data, 'base64'), audioData.mimeType, serverName, `[Audio from ${serverName}] `);
-        }
-        case 'image': {
-            // Resize and compress image data, enforcing API dimension limits
-            const imageBuffer = Buffer.from(String(resultContent.data), 'base64');
-            const ext = resultContent.mimeType?.split('/')[1] || 'png';
-            const resized = await maybeResizeAndDownsampleImageBuffer(imageBuffer, imageBuffer.length, ext);
-            return [
-                {
-                    type: 'image',
-                    source: {
-                        data: resized.buffer.toString('base64'),
-                        media_type: `image/${resized.mediaType}`,
-                        type: 'base64',
-                    },
-                },
-            ];
-        }
-        case 'resource': {
-            const resource = resultContent.resource;
-            const prefix = `[Resource from ${serverName} at ${resource.uri}] `;
-            if ('text' in resource) {
-                return [
-                    {
-                        type: 'text',
-                        text: `${prefix}${resource.text}`,
-                    },
-                ];
-            }
-            else if ('blob' in resource) {
-                const isImage = IMAGE_MIME_TYPES.has(resource.mimeType ?? '');
-                if (isImage) {
-                    // Resize and compress image blob, enforcing API dimension limits
-                    const imageBuffer = Buffer.from(resource.blob, 'base64');
-                    const ext = resource.mimeType?.split('/')[1] || 'png';
-                    const resized = await maybeResizeAndDownsampleImageBuffer(imageBuffer, imageBuffer.length, ext);
-                    const content = [];
-                    if (prefix) {
-                        content.push({
-                            type: 'text',
-                            text: prefix,
-                        });
-                    }
-                    content.push({
-                        type: 'image',
-                        source: {
-                            data: resized.buffer.toString('base64'),
-                            media_type: `image/${resized.mediaType}`,
-                            type: 'base64',
-                        },
-                    });
-                    return content;
-                }
-                else {
-                    return await persistBlobToTextBlock(Buffer.from(resource.blob, 'base64'), resource.mimeType, serverName, prefix);
-                }
-            }
-            return [];
-        }
-        case 'resource_link': {
-            const resourceLink = resultContent;
-            let text = `[Resource link: ${resourceLink.name}] ${resourceLink.uri}`;
-            if (resourceLink.description) {
-                text += ` (${resourceLink.description})`;
-            }
-            return [
-                {
-                    type: 'text',
-                    text,
-                },
-            ];
-        }
-        default:
-            return [];
-    }
-}
-/**
- * Decode base64 binary content, write it to disk with the proper extension,
- * and return a small text block with the file path. Replaces the old behavior
- * of dumping raw base64 into the context.
- */
-async function persistBlobToTextBlock(bytes, mimeType, serverName, sourceDescription) {
-    const persistId = `mcp-${normalizeNameForMCP(serverName)}-blob-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    const result = await persistBinaryContent(bytes, mimeType, persistId);
-    if ('error' in result) {
-        return [
-            {
-                type: 'text',
-                text: `${sourceDescription}Binary content (${mimeType || 'unknown type'}, ${bytes.length} bytes) could not be saved to disk: ${result.error}`,
-            },
-        ];
-    }
-    return [
-        {
-            type: 'text',
-            text: getBinaryBlobSavedMessage(result.filepath, mimeType, result.size, sourceDescription),
-        },
-    ];
-}
-/**
- * Generates a compact, jq-friendly type signature for a value.
- * e.g. "{title: string, items: [{id: number, name: string}]}"
- */
-export function inferCompactSchema(value, depth = 2) {
-    if (value === null)
-        return 'null';
-    if (Array.isArray(value)) {
-        if (value.length === 0)
-            return '[]';
-        return `[${inferCompactSchema(value[0], depth - 1)}]`;
-    }
-    if (typeof value === 'object') {
-        if (depth <= 0)
-            return '{...}';
-        const entries = Object.entries(value).slice(0, 10);
-        const props = entries.map(([k, v]) => `${k}: ${inferCompactSchema(v, depth - 1)}`);
-        const suffix = Object.keys(value).length > 10 ? ', ...' : '';
-        return `{${props.join(', ')}${suffix}}`;
-    }
-    return typeof value;
-}
-export async function transformMCPResult(result, tool, // Tool name for validation (e.g., "search")
-name) {
-    if (result && typeof result === 'object') {
-        if ('toolResult' in result) {
-            return {
-                content: String(result.toolResult),
-                type: 'toolResult',
-            };
-        }
-        if ('structuredContent' in result &&
-            result.structuredContent !== undefined) {
-            return {
-                content: jsonStringify(result.structuredContent),
-                type: 'structuredContent',
-                schema: inferCompactSchema(result.structuredContent),
-            };
-        }
-        if ('content' in result && Array.isArray(result.content)) {
-            const transformedContent = (await Promise.all(result.content.map(item => transformResultContent(item, name)))).flat();
-            return {
-                content: transformedContent,
-                type: 'contentArray',
-                schema: inferCompactSchema(transformedContent),
-            };
-        }
-    }
-    const errorMessage = `MCP server "${name}" tool "${tool}": unexpected response format`;
-    logMCPError(name, errorMessage);
-    throw new TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS(errorMessage, 'MCP tool unexpected response format');
-}
-/**
- * Check if MCP content contains any image blocks.
- * Used to decide whether to persist to file (images should use truncation instead
- * to preserve image compression and viewability).
- */
-function contentContainsImages(content) {
-    if (!content || typeof content === 'string') {
-        return false;
-    }
-    return content.some(block => block.type === 'image');
-}
-export async function processMCPResult(result, tool, // Tool name for validation (e.g., "search")
-name) {
-    const { content, type, schema } = await transformMCPResult(result, tool, name);
-    // IDE tools are not going to the model directly, so we don't need to
-    // handle large output.
-    if (name === 'ide') {
-        return content;
-    }
-    // Check if content needs truncation (i.e., is too large)
-    if (!(await mcpContentNeedsTruncation(content))) {
-        return content;
-    }
-    const sizeEstimateTokens = getContentSizeEstimate(content);
-    // If large output files feature is disabled, fall back to old truncation behavior
-    if (isEnvDefinedFalsy(process.env.ENABLE_MCP_LARGE_OUTPUT_FILES)) {
-        logEvent('tengu_mcp_large_result_handled', {
-            outcome: 'truncated',
-            reason: 'env_disabled',
-            sizeEstimateTokens,
-        });
-        return await truncateMcpContentIfNeeded(content);
-    }
-    // Save large output to file and return instructions for reading it
-    // Content is guaranteed to exist at this point (we checked mcpContentNeedsTruncation)
-    if (!content) {
-        return content;
-    }
-    // If content contains images, fall back to truncation - persisting images as JSON
-    // defeats the image compression logic and makes them non-viewable
-    if (contentContainsImages(content)) {
-        logEvent('tengu_mcp_large_result_handled', {
-            outcome: 'truncated',
-            reason: 'contains_images',
-            sizeEstimateTokens,
-        });
-        return await truncateMcpContentIfNeeded(content);
-    }
-    // Generate a unique ID for the persisted file (server__tool-timestamp)
-    const timestamp = Date.now();
-    const persistId = `mcp-${normalizeNameForMCP(name)}-${normalizeNameForMCP(tool)}-${timestamp}`;
-    // Convert to string for persistence (persistToolResult expects string or specific block types)
-    const contentStr = typeof content === 'string' ? content : jsonStringify(content, null, 2);
-    const persistResult = await persistToolResult(contentStr, persistId);
-    if (isPersistError(persistResult)) {
-        // If file save failed, fall back to returning truncated content info
-        const contentLength = contentStr.length;
-        logEvent('tengu_mcp_large_result_handled', {
-            outcome: 'truncated',
-            reason: 'persist_failed',
-            sizeEstimateTokens,
-        });
-        return `Error: result (${contentLength.toLocaleString()} characters) exceeds maximum allowed tokens. Failed to save output to file: ${persistResult.error}. If this MCP server provides pagination or filtering tools, use them to retrieve specific portions of the data.`;
-    }
-    logEvent('tengu_mcp_large_result_handled', {
-        outcome: 'persisted',
-        reason: 'file_saved',
-        sizeEstimateTokens,
-        persistedSizeChars: persistResult.originalSize,
-    });
-    const formatDescription = getFormatDescription(type, schema);
-    return getLargeOutputInstructions(persistResult.filepath, persistResult.originalSize, formatDescription);
-}
-/** @internal Exported for testing. */
-export async function callMCPToolWithUrlElicitationRetry({ client: connectedClient, clientConnection, tool, args, meta, signal, setAppState, onProgress, callToolFn = callMCPTool, handleElicitation, }) {
-    const MAX_URL_ELICITATION_RETRIES = 3;
-    for (let attempt = 0;; attempt++) {
-        try {
-            return await callToolFn({
-                client: connectedClient,
-                tool,
-                args,
-                meta,
-                signal,
-                onProgress,
-            });
-        }
-        catch (error) {
-            // The MCP SDK's Protocol creates plain McpError (not UrlElicitationRequiredError)
-            // for error responses, so we check the error code instead of instanceof.
-            if (!(error instanceof McpError) ||
-                error.code !== ErrorCode.UrlElicitationRequired) {
-                throw error;
-            }
-            // Limit the number of URL elicitation retries
-            if (attempt >= MAX_URL_ELICITATION_RETRIES) {
-                throw error;
-            }
-            const errorData = error.data;
-            const rawElicitations = errorData != null &&
-                typeof errorData === 'object' &&
-                'elicitations' in errorData &&
-                Array.isArray(errorData.elicitations)
-                ? errorData.elicitations
-                : [];
-            // Validate each element has the required fields for ElicitRequestURLParams
-            const elicitations = rawElicitations.filter((e) => {
-                if (e == null || typeof e !== 'object')
-                    return false;
-                const obj = e;
-                return (obj.mode === 'url' &&
-                    typeof obj.url === 'string' &&
-                    typeof obj.elicitationId === 'string' &&
-                    typeof obj.message === 'string');
-            });
-            const serverName = clientConnection.type === 'connected'
-                ? clientConnection.name
-                : 'unknown';
-            if (elicitations.length === 0) {
-                logMCPDebug(serverName, `Tool '${tool}' returned -32042 but no valid elicitations in error data`);
-                throw error;
-            }
-            logMCPDebug(serverName, `Tool '${tool}' requires URL elicitation (error -32042, attempt ${attempt + 1}), processing ${elicitations.length} elicitation(s)`);
-            // Process each URL elicitation from the error.
-            // The completion notification handler (in registerElicitationHandler) sets
-            // `completed: true` on the matching queue event; the dialog reacts to this flag.
-            for (const elicitation of elicitations) {
-                const { elicitationId } = elicitation;
-                // Run elicitation hooks — they can resolve URL elicitations programmatically
-                const hookResponse = await runElicitationHooks(serverName, elicitation, signal);
-                if (hookResponse) {
-                    logMCPDebug(serverName, `URL elicitation ${elicitationId} resolved by hook: ${jsonStringify(hookResponse)}`);
-                    if (hookResponse.action !== 'accept') {
-                        return {
-                            content: `URL elicitation was ${hookResponse.action === 'decline' ? 'declined' : hookResponse.action + 'ed'} by a hook. The tool "${tool}" could not complete because it requires the user to open a URL.`,
-                        };
-                    }
-                    // Hook accepted — skip the UI and proceed to retry
-                    continue;
-                }
-                // Resolve the URL elicitation via callback (print/SDK mode) or queue (REPL mode).
-                let userResult;
-                if (handleElicitation) {
-                    // Print/SDK mode: delegate to structuredIO which sends a control request
-                    userResult = await handleElicitation(serverName, elicitation, signal);
-                }
-                else {
-                    // REPL mode: queue for ElicitationDialog with two-phase consent/waiting flow
-                    const waitingState = {
-                        actionLabel: 'Retry now',
-                        showCancel: true,
-                    };
-                    userResult = await new Promise(resolve => {
-                        const onAbort = () => {
-                            void resolve({ action: 'cancel' });
-                        };
-                        if (signal.aborted) {
-                            onAbort();
-                            return;
-                        }
-                        signal.addEventListener('abort', onAbort, { once: true });
-                        setAppState(prev => ({
-                            ...prev,
-                            elicitation: {
-                                queue: [
-                                    ...prev.elicitation.queue,
-                                    {
-                                        serverName,
-                                        requestId: `error-elicit-${elicitationId}`,
-                                        params: elicitation,
-                                        signal,
-                                        waitingState,
-                                        respond: result => {
-                                            // Phase 1 consent: accept is a no-op (doesn't resolve retry Promise)
-                                            if (result.action === 'accept') {
-                                                return;
-                                            }
-                                            // Decline or cancel: resolve the retry Promise
-                                            signal.removeEventListener('abort', onAbort);
-                                            void resolve(result);
-                                        },
-                                        onWaitingDismiss: action => {
-                                            signal.removeEventListener('abort', onAbort);
-                                            if (action === 'retry') {
-                                                void resolve({ action: 'accept' });
-                                            }
-                                            else {
-                                                void resolve({ action: 'cancel' });
-                                            }
-                                        },
-                                    },
-                                ],
-                            },
-                        }));
-                    });
-                }
-                // Run ElicitationResult hooks — they can modify or block the response
-                const finalResult = await runElicitationResultHooks(serverName, userResult, signal, 'url', elicitationId);
-                if (finalResult.action !== 'accept') {
-                    logMCPDebug(serverName, `User ${finalResult.action === 'decline' ? 'declined' : finalResult.action + 'ed'} URL elicitation ${elicitationId}`);
-                    return {
-                        content: `URL elicitation was ${finalResult.action === 'decline' ? 'declined' : finalResult.action + 'ed'} by the user. The tool "${tool}" could not complete because it requires the user to open a URL.`,
-                    };
-                }
-                logMCPDebug(serverName, `Elicitation ${elicitationId} completed, retrying tool call`);
-            }
-            // Loop back to retry the tool call
-        }
-    }
-}
-async function callMCPTool({ client: { client, name, config }, tool, args, meta, signal, onProgress, }) {
-    const toolStartTime = Date.now();
-    let progressInterval;
-    try {
-        logMCPDebug(name, `Calling MCP tool: ${tool}`);
-        // Set up progress logging for long-running tools (every 30 seconds)
-        progressInterval = setInterval((startTime, name, tool) => {
-            const elapsed = Date.now() - startTime;
-            const elapsedSeconds = Math.floor(elapsed / 1000);
-            const duration = `${elapsedSeconds}s`;
-            logMCPDebug(name, `Tool '${tool}' still running (${duration} elapsed)`);
-        }, 30000, // Log every 30 seconds
-        toolStartTime, name, tool);
-        // Use Promise.race with our own timeout to handle cases where SDK's
-        // internal timeout doesn't work (e.g., SSE stream breaks mid-request)
-        const timeoutMs = getMcpToolTimeoutMs();
-        let timeoutId;
-        const timeoutPromise = new Promise((_, reject) => {
-            timeoutId = setTimeout((reject, name, tool, timeoutMs) => {
-                reject(new TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS(`MCP server "${name}" tool "${tool}" timed out after ${Math.floor(timeoutMs / 1000)}s`, 'MCP tool timeout'));
-            }, timeoutMs, reject, name, tool, timeoutMs);
-        });
-        const result = await Promise.race([
-            client.callTool({
-                name: tool,
-                arguments: args,
-                _meta: meta,
-            }, CallToolResultSchema, {
-                signal,
-                timeout: timeoutMs,
-                onprogress: onProgress
-                    ? sdkProgress => {
-                        onProgress({
-                            type: 'mcp_progress',
-                            status: 'progress',
-                            serverName: name,
-                            toolName: tool,
-                            progress: sdkProgress.progress,
-                            total: sdkProgress.total,
-                            progressMessage: sdkProgress.message,
-                        });
-                    }
-                    : undefined,
-            }),
-            timeoutPromise,
-        ]).finally(() => {
-            if (timeoutId) {
-                clearTimeout(timeoutId);
-            }
-        });
-        if ('isError' in result && result.isError) {
-            let errorDetails = 'Unknown error';
-            if ('content' in result &&
-                Array.isArray(result.content) &&
-                result.content.length > 0) {
-                const firstContent = result.content[0];
-                if (firstContent &&
-                    typeof firstContent === 'object' &&
-                    'text' in firstContent) {
-                    errorDetails = firstContent.text;
-                }
-            }
-            else if ('error' in result) {
-                // Fallback for legacy error format
-                errorDetails = String(result.error);
-            }
-            logMCPError(name, errorDetails);
-            throw new McpToolCallError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS(errorDetails, 'MCP tool returned error', '_meta' in result && result._meta ? { _meta: result._meta } : undefined);
-        }
-        const elapsed = Date.now() - toolStartTime;
-        const duration = elapsed < 1000
-            ? `${elapsed}ms`
-            : elapsed < 60000
-                ? `${Math.floor(elapsed / 1000)}s`
-                : `${Math.floor(elapsed / 60000)}m ${Math.floor((elapsed % 60000) / 1000)}s`;
-        logMCPDebug(name, `Tool '${tool}' completed successfully in ${duration}`);
-        // Log code indexing tool usage
-        const codeIndexingTool = detectCodeIndexingFromMcpServerName(name);
-        if (codeIndexingTool) {
-            logEvent('tengu_code_indexing_tool_used', {
-                tool: codeIndexingTool,
-                source: 'mcp',
-                success: true,
-            });
-        }
-        const content = await processMCPResult(result, tool, name);
-        return {
-            content,
-            _meta: result._meta,
-            structuredContent: result.structuredContent,
-        };
-    }
-    catch (e) {
-        // Clear intervals on error
-        if (progressInterval !== undefined) {
-            clearInterval(progressInterval);
-        }
-        const elapsed = Date.now() - toolStartTime;
-        if (e instanceof Error && e.name !== 'AbortError') {
-            logMCPDebug(name, `Tool '${tool}' failed after ${Math.floor(elapsed / 1000)}s: ${e.message}`);
-        }
-        // Check for 401 errors indicating expired/invalid OAuth tokens
-        // The MCP SDK's StreamableHTTPError has a `code` property with the HTTP status
-        if (e instanceof Error) {
-            const errorCode = 'code' in e ? e.code : undefined;
-            if (errorCode === 401 || e instanceof UnauthorizedError) {
-                logMCPDebug(name, `Tool call returned 401 Unauthorized - token may have expired`);
-                logEvent('tengu_mcp_tool_call_auth_error', {});
-                throw new McpAuthError(name, `MCP server "${name}" requires re-authorization (token expired)`);
-            }
-            // Check for session expiry — two error shapes can surface here:
-            // 1. Direct 404 + JSON-RPC -32001 from the server (StreamableHTTPError)
-            // 2. -32000 "Connection closed" (McpError) — the SDK closes the transport
-            //    after the onerror handler fires, so the pending callTool() rejects
-            //    with this derived error instead of the original 404.
-            // In both cases, clear the connection cache so the next tool call
-            // creates a fresh session.
-            const isSessionExpired = isMcpSessionExpiredError(e);
-            const isConnectionClosedOnHttp = 'code' in e &&
-                e.code === -32000 &&
-                e.message.includes('Connection closed') &&
-                (config.type === 'http' || config.type === 'claudeai-proxy');
-            if (isSessionExpired || isConnectionClosedOnHttp) {
-                logMCPDebug(name, `MCP session expired during tool call (${isSessionExpired ? '404/-32001' : 'connection closed'}), clearing connection cache for re-initialization`);
-                logEvent('tengu_mcp_session_expired', {});
-                await clearServerCache(name, config);
-                throw new McpSessionExpiredError(name);
-            }
-        }
-        // When the users hits esc, avoid logspew
-        if (!(e instanceof Error) || e.name !== 'AbortError') {
-            throw e;
-        }
-        return { content: undefined };
-    }
-    finally {
-        // Always clear intervals
-        if (progressInterval !== undefined) {
-            clearInterval(progressInterval);
-        }
-    }
-}
-function extractToolUseId(message) {
-    if (message.message.content[0]?.type !== 'tool_use') {
-        return undefined;
-    }
-    return message.message.content[0].id;
-}
-/**
- * Sets up SDK MCP clients by creating transports and connecting them.
- * This is used for SDK MCP servers that run in the same process as the SDK.
- *
- * @param sdkMcpConfigs - The SDK MCP server configurations
- * @param sendMcpMessage - Callback to send MCP messages through the control channel
- * @returns Connected clients, their tools, and transport map for message routing
- */
-export async function setupSdkMcpClients(sdkMcpConfigs, sendMcpMessage) {
-    const clients = [];
-    const tools = [];
-    // Connect to all servers in parallel
-    const results = await Promise.allSettled(Object.entries(sdkMcpConfigs).map(async ([name, config]) => {
-        const transport = new SdkControlClientTransport(name, sendMcpMessage);
-        const client = new Client({
-            name: 'claude-code',
-            title: 'Context Code',
-            version: MACRO.VERSION ?? 'unknown',
-            description: "Anthropic's agentic coding tool",
-            websiteUrl: PRODUCT_URL,
-        }, {
-            capabilities: {},
-        });
-        try {
-            // Connect the client
-            await client.connect(transport);
-            // Get capabilities from the server
-            const capabilities = client.getServerCapabilities();
-            // Create the connected client object
-            const connectedClient = {
-                type: 'connected',
-                name,
-                capabilities: capabilities || {},
-                client,
-                config: { ...config, scope: 'dynamic' },
-                cleanup: async () => {
-                    await client.close();
-                },
-            };
-            // Fetch tools if the server has them
-            const serverTools = [];
-            if (capabilities?.tools) {
-                const sdkTools = await fetchToolsForClient(connectedClient);
-                serverTools.push(...sdkTools);
-            }
-            return {
-                client: connectedClient,
-                tools: serverTools,
-            };
-        }
-        catch (error) {
-            // If connection fails, return failed server
-            logMCPError(name, `Failed to connect SDK MCP server: ${error}`);
-            return {
-                client: {
-                    type: 'failed',
-                    name,
-                    config: { ...config, scope: 'user' },
-                },
-                tools: [],
-            };
-        }
-    }));
-    // Process results and collect clients and tools
-    for (const result of results) {
-        if (result.status === 'fulfilled') {
-            clients.push(result.value.client);
-            tools.push(...result.value.tools);
-        }
-        // If rejected (unexpected), the error was already logged inside the promise
-    }
-    return { clients, tools };
-}