@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-mcp-adapter/server-manager.js

@@ -1,10 +1,12 @@
 import { mkdirSync, statSync } from "node:fs";
+import { BlockList, isIP } from "node:net";
 import { isDeepStrictEqual } from "node:util";
 import {
   Client,
   SdkError,
   SdkErrorCode,
   SdkHttpError,
+  SseError,
   SSEClientTransport,
   StreamableHTTPClientTransport,
   UnauthorizedError
@@ -21,19 +23,26 @@ import { resolveNpxBinary } from "./npx-resolver.js";
 import { createJsonSchemaValidator } from "./json-schema-validator.js";
 import { logger } from "./logger.js";
 import { RESOURCE_MIME_TYPE } from "./ui-app-bridge-helpers.js";
+import { isBuiltInAgentPlugin } from "./agent-plugin-provenance.js";
 import { McpOAuthProvider } from "./mcp-oauth-provider.js";
 import { extractOAuthConfig, supportsOAuth } from "./mcp-auth-flow.js";
-import { inspectAuthForUrl, invalidateAuthEntryCache } from "./mcp-auth.js";
+import {
+  captureOAuthAuthority,
+  inspectAuthForUrl,
+  invalidateAuthEntryCache
+} from "./mcp-auth.js";
 import { getBearerTokenForUrl } from "./mcp-bearer-store.js";
-import { registerSamplingHandler } from "./sampling-handler.js";
+import { handleSamplingRequest, registerSamplingHandler } from "./sampling-handler.js";
 import {
+  handleElicitationRequest,
   handleUrlElicitation,
   registerElicitationHandler
 } from "./elicitation-handler.js";
+import { attachTaskSession } from "./mcp-tasks.js";
 import {
   interpolateEnvVars,
+  expandHomePath,
   resolveBearerToken,
-  resolveCommandSecret,
   resolveCommandSecretsRecord,
   resolveConfigPath,
   resolveServerUrl
@@ -46,12 +55,45 @@ import {
   traceTransportKind,
   wrapTransportWithMcpTrace
 } from "./mcp-trace.js";
+import { createOAuthFetch, resolveOAuthHeaders } from "./mcp-auth-fetch.js";
 import { createRequestHeadersCommandFetch } from "./request-headers-command.js";
+import { createCaFetch, validateCaFile } from "./http-ca.js";
+import { BearerCommandResolver } from "./bearer-command-resolver.js";
 const MAX_CAPTURED_STDERR_BYTES = 8 * 1024;
 const MAX_CAPTURED_STDERR_LINES = 3;
 const abortCleanupPromises = new WeakMap;
-function isUnauthorizedHttpError(error) {
-  return error instanceof UnauthorizedError || error instanceof SdkHttpError && error.status === 401;
+function isLiteralLocalAddress(url) {
+  const hostname = new URL(url).hostname.replace(/^\[|\]$/g, "");
+  const family = isIP(hostname);
+  if (!family)
+    return false;
+  const local = new BlockList;
+  local.addSubnet("10.0.0.0", 8);
+  local.addSubnet("172.16.0.0", 12);
+  local.addSubnet("192.168.0.0", 16);
+  local.addSubnet("169.254.0.0", 16);
+  local.addSubnet("fc00::", 7, "ipv6");
+  local.addSubnet("fe80::", 10, "ipv6");
+  return local.check(hostname, family === 6 ? "ipv6" : "ipv4");
+}
+function localNetworkFailureCodes(error, seen = new Set) {
+  if (typeof error !== "object" || error === null || seen.has(error))
+    return [];
+  seen.add(error);
+  const codes = [];
+  if ("code" in error && typeof error.code === "string" && ["EHOSTUNREACH", "ENETUNREACH", "EACCES"].includes(error.code)) {
+    codes.push(error.code);
+  }
+  if ("cause" in error)
+    codes.push(...localNetworkFailureCodes(error.cause, seen));
+  if (error instanceof AggregateError) {
+    for (const nested of error.errors)
+      codes.push(...localNetworkFailureCodes(nested, seen));
+  }
+  return [...new Set(codes)];
+}
+export function isUnauthorizedHttpError(error) {
+  return error instanceof UnauthorizedError || error instanceof SdkHttpError && error.status === 401 || error instanceof Error && /^Error POSTing to endpoint \(HTTP 401\):/.test(error.message);
 }
 function shouldFallbackToSse(error, definition) {
   if (definition.protocolVersion === "2026-07-28")
@@ -102,12 +144,25 @@ export function isTransientHttpConnectError(error) {
   }
   return false;
 }
+function createBearerCommandFetch(resolver, delegate) {
+  const innerFetch = delegate ? (input, init) => delegate(input, init) : (input, init) => globalThis.fetch(input, init);
+  return async (input, init) => {
+    const request = new Request(input, init);
+    const token = await resolver.resolve(request.signal);
+    const headers = new Headers(request.headers);
+    headers.set("Authorization", `Bearer ${token}`);
+    return innerFetch(new Request(request, { headers }));
+  };
+}
 
 export class McpServerManager {
   defaultCwd;
   connections = new Map;
   connectPromises = new Map;
+  connectOAuthAuthorities = new Map;
   reconnectPromises = new Map;
+  reconnectOAuthAuthorities = new Map;
+  reconnectAttempts = new Map;
   uiStreamListeners = new Map;
   samplingConfig;
   metadataListChangedListener;
@@ -192,34 +247,67 @@ export class McpServerManager {
       ...timeout !== undefined ? { timeout } : {}
     };
   }
+  arbitrateConnectionAttempt(name, oauthAuthority, promises, authorities, attempts) {
+    const existingPromise = promises.get(name);
+    if (!existingPromise)
+      return;
+    const existingAuthority = authorities.get(name);
+    let reusable = oauthAuthority === undefined && existingAuthority === undefined;
+    if (oauthAuthority && existingAuthority) {
+      try {
+        existingAuthority();
+        reusable = true;
+      } catch {
+        reusable = false;
+      }
+    }
+    if (reusable)
+      return existingPromise;
+    const replacedAttempt = attempts.get(name);
+    replacedAttempt?.abort(new Error(`MCP connection ${name} was replaced`));
+    if (attempts.get(name) === replacedAttempt)
+      attempts.delete(name);
+    if (promises.get(name) === existingPromise)
+      promises.delete(name);
+    if (authorities.get(name) === existingAuthority)
+      authorities.delete(name);
+    return;
+  }
   async connect(name, definition, signal) {
+    validateCaFile(definition);
     if (isServerDisabled(definition))
       throw new Error(`MCP server "${name}" is disabled`);
     if (this.stopped)
       throw new Error("MCP server manager is closed");
     const ownedSignal = combineAbortSignals(this.runtimeSignal, signal);
     throwIfAborted(ownedSignal);
+    const oauthAuthority = definition.url && supportsOAuth(definition) ? captureOAuthAuthority(name, false) : undefined;
     const closing = this.closePromises.get(name);
     if (closing)
       await abortable(closing, ownedSignal);
     throwIfAborted(ownedSignal);
-    if (this.connectPromises.has(name)) {
-      return abortable(this.connectPromises.get(name), ownedSignal);
-    }
+    const existingConnect = this.arbitrateConnectionAttempt(name, oauthAuthority, this.connectPromises, this.connectOAuthAuthorities, this.connectAttempts);
+    if (existingConnect)
+      return abortable(existingConnect, ownedSignal);
     const existing = this.connections.get(name);
     if (existing?.status === "connected") {
       existing.lastUsedAt = Date.now();
       return existing;
     }
+    const existingReconnect = this.arbitrateConnectionAttempt(name, oauthAuthority, this.reconnectPromises, this.reconnectOAuthAuthorities, this.reconnectAttempts);
+    if (existingReconnect)
+      return abortable(existingReconnect, ownedSignal);
     const credentialsInvalidated = existing?.status === "needs-auth" && existing.credentialsInvalidated === true;
     const generation = this.closeGenerations.get(name) ?? 0;
     const attemptController = new AbortController;
     const attemptSignal = combineAbortSignals(ownedSignal, attemptController.signal);
-    const connectionAttempt = this.createConnection(name, definition, attemptSignal, ownedSignal, credentialsInvalidated);
+    const connectionAttempt = this.createConnection(name, definition, attemptSignal, ownedSignal, credentialsInvalidated, oauthAuthority, attemptController);
     const promise = definition.url ? connectionAttempt.catch(async (error) => {
       throw await this.enrichHttpConnectionError(definition, error);
     }) : connectionAttempt;
     this.connectPromises.set(name, promise);
+    if (oauthAuthority)
+      this.connectOAuthAuthorities.set(name, oauthAuthority);
     this.connectAttempts.set(name, attemptController);
     try {
       const connection = await promise;
@@ -237,27 +325,50 @@ export class McpServerManager {
     } finally {
       if (this.connectPromises.get(name) === promise)
         this.connectPromises.delete(name);
+      if (this.connectOAuthAuthorities.get(name) === oauthAuthority) {
+        this.connectOAuthAuthorities.delete(name);
+      }
       if (this.connectAttempts.get(name) === attemptController)
         this.connectAttempts.delete(name);
     }
   }
   async reconnect(name, definition, staleConnection, signal) {
+    validateCaFile(definition);
     if (isServerDisabled(definition))
       throw new Error(`MCP server "${name}" is disabled`);
     if (this.stopped)
       throw new Error("MCP server manager is closed");
     const ownedSignal = combineAbortSignals(this.runtimeSignal, signal);
     throwIfAborted(ownedSignal);
-    const inFlight = this.reconnectPromises.get(name);
-    if (inFlight) {
+    const oauthAuthority = definition.url && supportsOAuth(definition) ? captureOAuthAuthority(name, false) : undefined;
+    const existingConnect = this.arbitrateConnectionAttempt(name, oauthAuthority, this.connectPromises, this.connectOAuthAuthorities, this.connectAttempts);
+    if (existingConnect)
+      return abortable(existingConnect, ownedSignal);
+    const inFlight = this.arbitrateConnectionAttempt(name, oauthAuthority, this.reconnectPromises, this.reconnectOAuthAuthorities, this.reconnectAttempts);
+    if (inFlight)
       return abortable(inFlight, ownedSignal);
-    }
-    const promise = this.doReconnect(name, definition, staleConnection, ownedSignal).finally(() => {
+    const attemptController = new AbortController;
+    const attemptSignal = combineAbortSignals(ownedSignal, attemptController.signal);
+    const promise = this.doReconnect(name, definition, staleConnection, attemptSignal, oauthAuthority, attemptController).catch((error) => {
+      if (attemptController.signal.aborted && !this.containsCleanupFailure(error)) {
+        throw new Error(`MCP connection for ${name} was closed while reconnecting`, { cause: error });
+      }
+      throw error;
+    }).finally(() => {
       if (this.reconnectPromises.get(name) === promise) {
         this.reconnectPromises.delete(name);
       }
+      if (this.reconnectAttempts.get(name) === attemptController) {
+        this.reconnectAttempts.delete(name);
+      }
+      if (this.reconnectOAuthAuthorities.get(name) === oauthAuthority) {
+        this.reconnectOAuthAuthorities.delete(name);
+      }
     });
     this.reconnectPromises.set(name, promise);
+    if (oauthAuthority)
+      this.reconnectOAuthAuthorities.set(name, oauthAuthority);
+    this.reconnectAttempts.set(name, attemptController);
     return abortable(promise, ownedSignal);
   }
   async refreshTools(name, expectedConnection, signal) {
@@ -492,7 +603,7 @@ export class McpServerManager {
     const nextResources = resources.status === "fulfilled" ? resources.value : undefined;
     const nextPrompts = promptResult.status === "fulfilled" && !promptResult.value.failed ? promptResult.value : undefined;
     const confirmed = nextTools !== undefined && nextResources !== undefined && nextPrompts !== undefined;
-    const changed = nextTools !== undefined && (!isDeepStrictEqual(expectedConnection.tools, nextTools.tools) || !isDeepStrictEqual(expectedConnection.toolListHints, nextTools.hints)) || nextResources !== undefined && !isDeepStrictEqual(expectedConnection.resources, nextResources) || nextPrompts !== undefined && (!isDeepStrictEqual(expectedConnection.prompts, nextPrompts.prompts) || expectedConnection.promptDiscoveryFailed !== false);
+    const changed = nextTools !== undefined && (!isDeepStrictEqual(expectedConnection.tools, nextTools.tools) || !isDeepStrictEqual(expectedConnection.toolListHints, nextTools.hints)) || nextResources !== undefined && (!isDeepStrictEqual(expectedConnection.resources, nextResources.resources) || expectedConnection.resourceDiscoveryFailed !== nextResources.failed) || nextPrompts !== undefined && (!isDeepStrictEqual(expectedConnection.prompts, nextPrompts.prompts) || expectedConnection.promptDiscoveryFailed !== false);
     if (!changed) {
       this.retryPendingMetadataPublication(name, expectedConnection);
       if (confirmed)
@@ -506,8 +617,10 @@ export class McpServerManager {
       expectedConnection.toolListHints = nextTools.hints;
       expectedConnection.toolsRevision = (expectedConnection.toolsRevision ?? 0) + 1;
     }
-    if (nextResources !== undefined)
-      expectedConnection.resources = nextResources;
+    if (nextResources !== undefined) {
+      expectedConnection.resources = nextResources.resources;
+      expectedConnection.resourceDiscoveryFailed = nextResources.failed;
+    }
     if (nextPrompts !== undefined) {
       expectedConnection.prompts = nextPrompts.prompts;
       expectedConnection.promptDiscoveryFailed = false;
@@ -549,19 +662,48 @@ export class McpServerManager {
   removeResourceUpdatedListener(token) {
     this.resourceUpdatedListeners.delete(token);
   }
-  async doReconnect(name, definition, staleConnection, signal) {
+  async doReconnect(name, definition, staleConnection, signal, oauthAuthority, attemptOwner) {
     throwIfAborted(signal);
     const current = this.connections.get(name);
     if (current !== staleConnection) {
       return current ?? this.connect(name, definition, signal);
     }
-    const staleInFlight = staleConnection.inFlight;
-    await this.close(name);
-    const fresh = await this.connect(name, definition, signal);
-    fresh.inFlight = Math.max(fresh.inFlight, staleInFlight);
+    const generation = this.closeGenerations.get(name) ?? 0;
+    const credentialsInvalidated = staleConnection.status === "needs-auth" && staleConnection.credentialsInvalidated === true;
+    const candidateAttempt = this.createConnection(name, definition, signal, signal, credentialsInvalidated, oauthAuthority, attemptOwner);
+    const fresh = definition.url ? await candidateAttempt.catch(async (error) => {
+      throw await this.enrichHttpConnectionError(definition, error);
+    }) : await candidateAttempt;
+    if (signal?.aborted || this.reconnectAttempts.get(name) !== attemptOwner || (this.closeGenerations.get(name) ?? 0) !== generation) {
+      await this.disposeConnection(fresh);
+      throwIfAborted(signal);
+      throw new Error(`MCP connection for ${name} was closed while reconnecting`);
+    }
+    const routeAtPublish = this.connections.get(name);
+    if (routeAtPublish !== staleConnection) {
+      await this.disposeConnection(fresh);
+      return routeAtPublish ?? this.connect(name, definition, signal);
+    }
+    fresh.inFlight = Math.max(fresh.inFlight, staleConnection.inFlight);
+    this.connections.set(name, fresh);
+    this.watchListenSubscription(name, fresh, fresh.listenSubscription);
+    if ([...this.resourceUpdatedListeners.values()].some((registration) => registration.serverName === name)) {
+      this.ensureListen(name, fresh);
+    }
+    staleConnection.status = "closed";
+    try {
+      await this.disposeConnection(staleConnection);
+    } catch (error) {
+      const failures = error instanceof AggregateError ? error.errors : [error];
+      const details = failures.map((failure) => failure instanceof Error ? failure.message : String(failure)).join("; ");
+      logger.debug(`MCP: stale connection cleanup failed for ${name}: ${details}`);
+    }
+    if ((this.closeGenerations.get(name) ?? 0) !== generation || this.connections.get(name) !== fresh || fresh.status === "closed") {
+      throw new Error(`MCP connection for ${name} was closed while reconnecting`);
+    }
     return fresh;
   }
-  async createConnection(name, definition, signal, requestSignal, credentialsInvalidated = false) {
+  async createConnection(name, definition, signal, requestSignal, credentialsInvalidated = false, oauthAuthority, attemptOwner) {
     throwIfAborted(signal);
     const tracingEnabled = isMcpTraceEnabled(definition, this.traceSettings);
     const traceWriter = tracingEnabled ? this.traceWriter ??= createMcpTraceWriter(this.defaultCwd, this.traceSettings ?? {}) : undefined;
@@ -579,9 +721,13 @@ export class McpServerManager {
     const requestOptions = this.buildRequestOptions(definition, requestSignal);
     if (definition.command) {
       client = this.createClient(name, definition);
-      let command = definition.command;
-      let args = (definition.args ?? []).map((argument) => interpolateEnvVars(argument));
-      const cwd = resolveConfigPath(definition.cwd) ?? this.defaultCwd;
+      let command = resolveConfigPath(definition.command) ?? definition.command;
+      const literalArgs = isBuiltInAgentPlugin(definition, "args");
+      const literalCwd = isBuiltInAgentPlugin(definition, "cwd");
+      let args = literalArgs ? [...definition.args ?? []] : (definition.args ?? []).map((argument) => expandHomePath(interpolateEnvVars(argument)) ?? argument);
+      const cwd = (literalCwd ? expandHomePath(definition.cwd) : resolveConfigPath(definition.cwd)) ?? this.defaultCwd;
+      if (definition.pluginDataDir)
+        mkdirSync(definition.pluginDataDir, { recursive: true });
       if (cwd !== undefined) {
         const cwdStats = statSync(cwd, { throwIfNoEntry: false });
         if (!cwdStats)
@@ -598,12 +744,10 @@ export class McpServerManager {
         }
       }
       throwIfAborted(signal);
-      if (definition.pluginDataDir)
-        mkdirSync(definition.pluginDataDir, { recursive: true });
       const stdioTransport = new StdioClientTransport({
         command,
         args,
-        env: resolveEnv(definition.env, name, definition.literalEnv === true),
+        env: resolveEnv(definition.env, name, isBuiltInAgentPlugin(definition, "env") || definition.literalEnv === true, definition.inheritEnv !== false),
         ...cwd !== undefined ? { cwd } : {},
         stderr: definition.debug ? "inherit" : "pipe"
       });
@@ -614,7 +758,7 @@ export class McpServerManager {
       }
       transport = stdioTransport;
     } else if (definition.url) {
-      const httpConnection = await this.connectHttpClient(definition, name, requestOptions, signal, traceObserver, invalidated);
+      const httpConnection = await this.connectHttpClient(definition, name, requestOptions, signal, traceObserver, invalidated, oauthAuthority, attemptOwner);
       client = httpConnection.client;
       transport = httpConnection.transport;
       invalidated = httpConnection.credentialsInvalidated;
@@ -672,20 +816,63 @@ export class McpServerManager {
       if (autoOpenedSubscription)
         connection.listenFilter = this.catalogListenFilter(connection);
       client.onclose = () => {
-        if (this.connections.get(name) === connection) {
-          connection.status = "closed";
-        }
+        if (connection.status === "closed")
+          return;
+        connection.status = "closed";
+        if (this.connections.get(name) !== connection)
+          return;
+        this.metadataListChangedListener?.(name, "remote-close");
       };
       const [toolResult, resources, promptResult] = await Promise.all([
         this.fetchAllTools(client, requestOptions),
         this.fetchAllResources(client, requestOptions),
         this.fetchAllPrompts(client, requestOptions)
       ]);
+      if (connection.status !== "connected") {
+        throw new Error(`MCP connection for ${name} closed during metadata discovery`);
+      }
       connection.tools = toolResult.tools;
       connection.toolListHints = toolResult.hints;
-      connection.resources = resources;
+      connection.resources = resources.resources;
+      connection.resourceDiscoveryFailed = resources.failed;
       connection.prompts = promptResult.prompts;
       connection.promptDiscoveryFailed = promptResult.failed;
+      if (definition.tasks !== false) {
+        try {
+          const attachment = await attachTaskSession({
+            client,
+            serverName: name,
+            definition,
+            transport,
+            requestTimeoutMs: this.getResolvedRequestTimeoutMs(definition),
+            clientInfo: { name: `pi-mcp-${name}`, version: "1.0.0" },
+            clientCapabilities: this.buildClientCapabilities(),
+            ...this.elicitationConfig ? {
+              onElicitation: (request, signal) => handleElicitationRequest({
+                ...this.elicitationConfig,
+                serverName: name,
+                onUrlAccepted: (elicitationId) => this.rememberUrlElicitation(name, elicitationId)
+              }, request, signal)
+            } : {},
+            ...this.samplingConfig ? {
+              onSampling: (request, signal) => handleSamplingRequest({
+                ...this.samplingConfig,
+                serverName: name,
+                getSignal: () => combineAbortSignals(this.samplingConfig.getSignal(), signal)
+              }, request)
+            } : {}
+          });
+          if (attachment && connection.status === "connected") {
+            connection.taskSession = attachment.session;
+            connection.taskChannel = attachment.channel;
+          } else if (attachment) {
+            attachment.channel.rejectAll("MCP connection closed");
+            await attachment.session.close().catch(() => {});
+          }
+        } catch (error) {
+          logger.debug(`Task session attach failed for ${name}: ${String(error)}`);
+        }
+      }
       return connection;
     } catch (error) {
       const abortCleanup = abortCleanupPromises.get(transport);
@@ -731,6 +918,12 @@ export class McpServerManager {
   }
   async enrichHttpConnectionError(definition, error) {
     const originalMessage = error instanceof Error ? error.message : String(error);
+    if (process.platform === "darwin") {
+      const codes = localNetworkFailureCodes(error);
+      if (codes.length > 0 && isLiteralLocalAddress(resolveServerUrl(definition))) {
+        return new Error(`${originalMessage} — ${codes.join(", ")} — macOS Local Network Privacy may be blocking access. Check System Settings > Privacy & Security > Local Network for the app hosting DM; enable access if listed and restart it. Try launching DM from Terminal.app or SSH. Routing or firewall problems can also cause this error.`, { cause: error });
+      }
+    }
     if (isTransientHttpConnectError(error)) {
       return new Error(`${originalMessage} — endpoint is temporarily unavailable (HTTP 503)`, { cause: error });
     }
@@ -870,6 +1063,7 @@ export class McpServerManager {
     if (!connection || connection.client !== client || connection.status !== "connected")
       return;
     connection.resources = resources;
+    connection.resourceDiscoveryFailed = false;
     this.metadataListChangedListener?.(serverName, "resources-list-changed");
     this.pendingMetadataPublications.delete(serverName);
   }
@@ -897,17 +1091,32 @@ export class McpServerManager {
     }
     accepted.add(elicitationId);
   }
-  async connectHttpClient(definition, serverName, requestOptions, signal, traceObserver, credentialsInvalidated = false) {
+  async connectHttpClient(definition, serverName, requestOptions, signal, traceObserver, credentialsInvalidated = false, oauthAuthority, attemptOwner) {
     throwIfAborted(signal);
     const serverUrl = resolveServerUrl(definition);
     const url = new URL(serverUrl);
-    const hasCommandHeader = Object.values(definition.headers ?? {}).some((value) => value.startsWith("!") && !value.startsWith("!!"));
-    const headers = resolveCommandSecretsRecord(definition.headers, (key) => `MCP server "${serverName}" HTTP header "${key}"`) ?? {};
+    const literalHeaders = isBuiltInAgentPlugin(definition, "headers");
+    const hasCommandHeader = !literalHeaders && Object.values(definition.headers ?? {}).some((value) => value.startsWith("!") && !value.startsWith("!!"));
+    const oauthEnabled = supportsOAuth(definition);
+    let headers;
+    if (literalHeaders) {
+      headers = { ...definition.headers };
+    } else if (oauthEnabled) {
+      headers = Object.fromEntries(resolveOAuthHeaders(definition.headers));
+    } else {
+      headers = resolveCommandSecretsRecord(definition.headers, (key) => `MCP server "${serverName}" HTTP header "${key}"`) ?? {};
+    }
     const commandBearer = definition.bearerToken?.startsWith("!") && !definition.bearerToken.startsWith("!!") ? definition.bearerToken : undefined;
+    let bearerCommandResolver;
     if (definition.auth === "bearer") {
-      const token = commandBearer ? resolveCommandSecret(commandBearer, `MCP server "${serverName}" HTTP bearer token`) : resolveBearerToken(definition) ?? (definition.bearerToken === undefined && definition.bearerTokenEnv === undefined && definition.bearerTokenStore === true ? getBearerTokenForUrl(serverName, serverUrl) : undefined);
-      if (token)
-        headers["Authorization"] = `Bearer ${token}`;
+      if (commandBearer) {
+        bearerCommandResolver = new BearerCommandResolver(commandBearer, `MCP server "${serverName}" HTTP bearer token`);
+        await bearerCommandResolver.resolve(signal);
+      } else {
+        const token = resolveBearerToken(definition) ?? (definition.bearerToken === undefined && definition.bearerTokenEnv === undefined && definition.bearerTokenStore === true ? getBearerTokenForUrl(serverName, serverUrl) : undefined);
+        if (token)
+          headers["Authorization"] = `Bearer ${token}`;
+      }
     }
     if (hasCommandHeader || commandBearer) {
       try {
@@ -916,80 +1125,137 @@ export class McpServerManager {
         throw new Error(`Failed to resolve MCP server "${serverName}" HTTP command secret: command returned an invalid header value`);
       }
     }
-    const requestInit = Object.keys(headers).length > 0 ? { headers } : undefined;
-    const requestFetch = definition.requestHeadersCommand ? createRequestHeadersCommandFetch(definition.requestHeadersCommand) : undefined;
-    const createAuthProvider = () => new McpOAuthProvider(serverName, serverUrl, extractOAuthConfig(definition), { onRedirect: async () => {} }, this.authStorageOptions, this.oauthRuntime?.signal);
-    let implicitStoredAuth;
-    if (definition.auth === undefined && supportsOAuth(definition)) {
-      try {
-        implicitStoredAuth = inspectAuthForUrl(serverName, serverUrl, this.authStorageOptions);
-      } catch {}
-    }
-    const hasImplicitStoredTokens = implicitStoredAuth?.status === "present" && implicitStoredAuth.entry.tokens !== undefined;
-    if (hasImplicitStoredTokens)
-      invalidateAuthEntryCache(serverName);
-    let authState = supportsOAuth(definition) ? definition.auth === undefined ? hasImplicitStoredTokens ? { status: "implicit-stored", provider: createAuthProvider() } : { status: "implicit-deferred" } : { status: "explicit", provider: createAuthProvider() } : { status: "disabled" };
-    const attempt = async (kind) => {
-      const authProvider = "provider" in authState ? authState.provider : undefined;
-      const transportOptions = {
-        ...requestInit !== undefined ? { requestInit } : {},
-        ...requestFetch !== undefined ? { fetch: requestFetch } : {},
-        ...authProvider !== undefined ? { authProvider } : {},
-        ...authProvider !== undefined && definition.oauth !== false && definition.oauth?.skipIssuerMetadataValidation === true ? { skipIssuerMetadataValidation: true } : {}
+    const requestInit = !oauthEnabled && Object.keys(headers).length > 0 ? { headers } : undefined;
+    const serviceHeaders = oauthEnabled ? new Headers(headers) : new Headers;
+    let caFetch = createCaFetch(definition);
+    try {
+      const createAuthProvider = () => {
+        const currentConnectAttempt = this.connectAttempts.get(serverName);
+        const currentReconnectAttempt = this.reconnectAttempts.get(serverName);
+        if (currentConnectAttempt && currentConnectAttempt !== attemptOwner || currentReconnectAttempt && currentReconnectAttempt !== attemptOwner) {
+          throw new Error(`MCP connection for ${serverName} was replaced while connecting`);
+        }
+        if (!oauthAuthority)
+          throw new Error(`Missing OAuth authority for ${serverName}`);
+        const provider = new McpOAuthProvider(serverName, serverUrl, extractOAuthConfig(definition), { onRedirect: async () => {} }, this.authStorageOptions, this.oauthRuntime?.signal, undefined, oauthAuthority);
+        provider.setAuthFetch(createOAuthFetch(serverUrl, () => serviceHeaders, combineAbortSignals(this.oauthRuntime?.signal, signal), {
+          ...caFetch ? { delegate: caFetch.fetch } : {}
+        }));
+        return provider;
       };
-      const baseTransport = kind === "streamable-http" ? new StreamableHTTPClientTransport(url, transportOptions) : new SSEClientTransport(url, transportOptions);
-      const transport = traceObserver ? wrapTransportWithMcpTrace(baseTransport, serverName, kind, traceObserver) : baseTransport;
-      const client = this.createClient(serverName, definition);
-      try {
-        await this.connectClientWithAbort(client, transport, requestOptions, signal);
-        return { status: "connected", client, transport };
-      } catch (error) {
-        const abortCleanupFailed = error instanceof AggregateError && error.message === "MCP connection abort cleanup failed";
-        if (!abortCleanupFailed) {
+      let implicitStoredAuth;
+      if (definition.auth === undefined && supportsOAuth(definition)) {
+        try {
+          implicitStoredAuth = inspectAuthForUrl(serverName, serverUrl, this.authStorageOptions);
+        } catch {}
+      }
+      const hasImplicitStoredTokens = implicitStoredAuth?.status === "present" && implicitStoredAuth.entry.tokens !== undefined;
+      if (hasImplicitStoredTokens)
+        invalidateAuthEntryCache(serverName);
+      let authState = supportsOAuth(definition) ? definition.auth === undefined ? hasImplicitStoredTokens ? { status: "implicit-stored", provider: createAuthProvider() } : { status: "implicit-deferred" } : { status: "explicit", provider: createAuthProvider() } : { status: "disabled" };
+      const commandFetch = definition.requestHeadersCommand ? createRequestHeadersCommandFetch(definition.requestHeadersCommand, caFetch?.fetch) : caFetch?.fetch;
+      const bearerFetch = bearerCommandResolver ? createBearerCommandFetch(bearerCommandResolver, commandFetch) : commandFetch;
+      const requestFetch = oauthEnabled ? createOAuthFetch(serverUrl, () => serviceHeaders, this.oauthRuntime?.signal, {
+        timeout: false,
+        ...bearerFetch ? { delegate: bearerFetch } : {}
+      }) : bearerFetch;
+      const attempt = async (kind) => {
+        const authProvider = "provider" in authState ? authState.provider : undefined;
+        let sseFetchFailure;
+        const transportFetch = kind === "sse" && process.platform === "darwin" && isLiteralLocalAddress(serverUrl) ? async (input, init) => {
           try {
-            await (abortCleanupPromises.get(transport) ?? client.close());
-          } catch (cleanupError) {
-            throw new AggregateError([error, cleanupError], "MCP HTTP connection cleanup failed");
+            return await (requestFetch ?? globalThis.fetch)(input, init);
+          } catch (error) {
+            if (localNetworkFailureCodes(error).length > 0)
+              sseFetchFailure = error;
+            throw error;
           }
+        } : requestFetch;
+        const transportOptions = {
+          ...requestInit !== undefined ? { requestInit } : {},
+          ...transportFetch !== undefined ? { fetch: transportFetch } : {},
+          ...authProvider !== undefined ? { authProvider } : {},
+          ...authProvider !== undefined && definition.oauth !== false && definition.oauth?.skipIssuerMetadataValidation === true ? { skipIssuerMetadataValidation: true } : {}
+        };
+        const baseTransport = kind === "streamable-http" ? new StreamableHTTPClientTransport(url, transportOptions) : new SSEClientTransport(url, transportOptions);
+        const transport = traceObserver ? wrapTransportWithMcpTrace(baseTransport, serverName, kind, traceObserver) : baseTransport;
+        const client = this.createClient(serverName, definition);
+        try {
+          await this.connectClientWithAbort(client, transport, requestOptions, signal);
+          return { status: "connected", client, transport };
+        } catch (error) {
+          if (error instanceof SseError && sseFetchFailure !== undefined) {
+            error = new AggregateError([error, sseFetchFailure], error.message);
+          }
+          const abortCleanupFailed = error instanceof AggregateError && error.message === "MCP connection abort cleanup failed";
+          if (!abortCleanupFailed) {
+            try {
+              await (abortCleanupPromises.get(transport) ?? client.close());
+            } catch (cleanupError) {
+              throw new AggregateError([error, cleanupError], "MCP HTTP connection cleanup failed");
+            }
+          }
+          return { status: "failed", client, transport, error };
         }
-        return { status: "failed", client, transport, error };
-      }
-    };
-    let kind = definition.httpTransport ?? "streamable-http";
-    let invalidated = credentialsInvalidated;
-    for (;; ) {
-      const result = await attempt(kind);
-      if (result.status === "connected")
-        return { ...result, credentialsInvalidated: invalidated };
-      if (result.error instanceof AggregateError && result.error.message === "MCP connection abort cleanup failed") {
-        throw result.error;
-      }
-      if (signal?.aborted)
-        throwIfAborted(signal);
-      if (authState.status === "implicit-deferred" && isUnauthorizedHttpError(result.error)) {
-        authState = { status: "implicit-challenged", provider: createAuthProvider() };
-        continue;
-      }
-      if (isUnauthorizedHttpError(result.error)) {
-        if (supportsOAuth(definition)) {
-          if (!invalidated) {
-            invalidateAuthEntryCache(serverName);
-            invalidated = true;
+      };
+      let kind = definition.httpTransport ?? "streamable-http";
+      let invalidated = credentialsInvalidated;
+      for (;; ) {
+        const result = await attempt(kind);
+        if (result.status === "connected") {
+          const ownedCa = caFetch;
+          if (ownedCa) {
+            const close = result.transport.close.bind(result.transport);
+            const onclose = result.transport.onclose;
+            result.transport.onclose = () => {
+              ownedCa.close().catch((error) => {
+                logger.debug(`MCP: CA dispatcher cleanup failed for ${serverName}: ${String(error)}`);
+              });
+              onclose?.();
+            };
+            result.transport.close = async () => {
+              try {
+                await close();
+              } finally {
+                await ownedCa.close();
+              }
+            };
+            caFetch = undefined;
           }
-          return {
-            client: result.client,
-            transport: result.transport,
-            status: "needs-auth",
-            credentialsInvalidated: invalidated
-          };
+          return { ...result, credentialsInvalidated: invalidated };
+        }
+        if (result.error instanceof AggregateError && result.error.message === "MCP connection abort cleanup failed") {
+          throw result.error;
+        }
+        if (signal?.aborted)
+          throwIfAborted(signal);
+        if (authState.status === "implicit-deferred" && isUnauthorizedHttpError(result.error)) {
+          authState = { status: "implicit-challenged", provider: createAuthProvider() };
+          continue;
+        }
+        if (isUnauthorizedHttpError(result.error)) {
+          if (supportsOAuth(definition)) {
+            if (!invalidated) {
+              invalidateAuthEntryCache(serverName);
+              invalidated = true;
+            }
+            return {
+              client: result.client,
+              transport: result.transport,
+              status: "needs-auth",
+              credentialsInvalidated: invalidated
+            };
+          }
+          throw result.error;
+        }
+        if (definition.httpTransport === undefined && kind === "streamable-http" && shouldFallbackToSse(result.error, definition)) {
+          kind = "sse";
+          continue;
         }
         throw result.error;
       }
-      if (definition.httpTransport === undefined && kind === "streamable-http" && shouldFallbackToSse(result.error, definition)) {
-        kind = "sse";
-        continue;
-      }
-      throw result.error;
+    } finally {
+      await caFetch?.close();
     }
   }
   async fetchAllTools(client, requestOptions) {
@@ -1041,7 +1307,7 @@ export class McpServerManager {
   async fetchAllResources(client, requestOptions, strict = false) {
     const capabilities = client.getServerCapabilities?.();
     if (!capabilities?.resources)
-      return [];
+      return { resources: [], failed: false };
     try {
       const allResources = [];
       let cursor;
@@ -1050,7 +1316,7 @@ export class McpServerManager {
         allResources.push(...result.resources ?? []);
         cursor = result.nextCursor;
       } while (cursor);
-      return allResources;
+      return { resources: allResources, failed: false };
     } catch (error) {
       if (requestOptions?.signal?.aborted) {
         throwIfAborted(requestOptions.signal);
@@ -1059,7 +1325,7 @@ export class McpServerManager {
         throw error;
       if (strict)
         throw error;
-      return [];
+      return { resources: [], failed: true };
     }
   }
   attachAdapterNotificationHandlers(serverName, client) {
@@ -1126,7 +1392,9 @@ export class McpServerManager {
   async close(name) {
     this.closeGenerations.set(name, (this.closeGenerations.get(name) ?? 0) + 1);
     this.connectAttempts.get(name)?.abort(new Error(`MCP connection ${name} was closed`));
+    this.reconnectAttempts.get(name)?.abort(new Error(`MCP connection ${name} was closed`));
     this.pendingMetadataPublications.delete(name);
+    const pendingReconnect = this.reconnectPromises.get(name);
     const connection = this.connections.get(name);
     if (!connection) {
       const pendingClose = this.closePromises.get(name);
@@ -1135,9 +1403,11 @@ export class McpServerManager {
         return;
       }
       const pendingConnect = this.connectPromises.get(name);
-      if (pendingConnect) {
+      for (const pending of [pendingConnect, pendingReconnect]) {
+        if (!pending)
+          continue;
         try {
-          await pendingConnect;
+          await pending;
         } catch (error) {
           if (this.containsCleanupFailure(error))
             throw error;
@@ -1153,10 +1423,22 @@ export class McpServerManager {
         this.closePromises.delete(name);
     });
     this.closePromises.set(name, closing);
-    return closing;
+    await closing;
+    if (pendingReconnect) {
+      try {
+        await pendingReconnect;
+      } catch (error) {
+        if (this.containsCleanupFailure(error))
+          throw error;
+      }
+    }
   }
   async disposeConnection(connection) {
     const results = await Promise.allSettled([
+      Promise.resolve().then(async () => {
+        connection.taskChannel?.rejectAll("MCP connection closed");
+        await connection.taskSession?.close();
+      }).catch(() => {}),
       Promise.resolve().then(() => connection.client.close()),
       this.traceWriter?.flush() ?? Promise.resolve()
     ]);
@@ -1166,12 +1448,17 @@ export class McpServerManager {
   }
   async closeAll() {
     this.stopped = true;
-    const names = new Set([...this.connections.keys(), ...this.connectPromises.keys()]);
+    const names = new Set([
+      ...this.connections.keys(),
+      ...this.connectPromises.keys(),
+      ...this.reconnectPromises.keys()
+    ]);
     for (const name of names) {
       this.closeGenerations.set(name, (this.closeGenerations.get(name) ?? 0) + 1);
       this.connectAttempts.get(name)?.abort(new Error(`MCP connection ${name} was closed`));
+      this.reconnectAttempts.get(name)?.abort(new Error(`MCP connection ${name} was closed`));
     }
-    const pendingConnects = [...this.connectPromises.values()];
+    const pendingConnects = [...this.connectPromises.values(), ...this.reconnectPromises.values()];
     const currentNames = [...this.connections.keys()];
     const pendingResults = await Promise.allSettled(pendingConnects);
     const results = await Promise.allSettled(currentNames.map((name) => this.close(name)));
@@ -1242,11 +1529,13 @@ export class McpServerManager {
     return Date.now() - connection.lastUsedAt > timeoutMs;
   }
 }
-function resolveEnv(env, serverName, literalEnv = false) {
+function resolveEnv(env, serverName, literalEnv = false, inheritEnv = true) {
   const resolved = {};
-  for (const [key, value] of Object.entries(process.env)) {
-    if (value !== undefined)
-      resolved[key] = value;
+  if (inheritEnv) {
+    for (const [key, value] of Object.entries(process.env)) {
+      if (value !== undefined)
+        resolved[key] = value;
+    }
   }
   if (literalEnv)
     return env ? { ...resolved, ...env } : resolved;