@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-mcp-adapter/mcp-auth-flow.js

@@ -2,10 +2,14 @@ import {
   auth as runSdkAuth,
   extractWWWAuthenticateParams,
   LATEST_PROTOCOL_VERSION,
-  UnauthorizedError
+  UnauthorizedError,
+  validateClientMetadataUrl
 } from "@modelcontextprotocol/client";
 import open from "open";
-import { McpOAuthProvider } from "./mcp-oauth-provider.js";
+import {
+  getOAuthCallbackPort,
+  McpOAuthProvider
+} from "./mcp-oauth-provider.js";
 import {
   ensureCallbackServer,
   waitForCallback,
@@ -16,21 +20,28 @@ import {
 } from "./mcp-callback-server.js";
 import {
   getAuthForUrl,
-  isTokenExpired,
-  hasStoredTokens,
+  getAuthEntry,
   clearAllCredentials,
   clearClientInfo,
-  clearTokens,
   clearCodeVerifier,
   getOAuthState,
   clearOAuthState,
   getAuthBaseDir,
+  beginOAuthRevocation,
+  captureOAuthAuthority,
   OAuthCredentialStoreError
 } from "./mcp-auth.js";
 import { isServerDisabled } from "./types.js";
-import { formatTerminalError, interpolateEnvRecord, interpolateEnvVars } from "./utils.js";
+import { formatTerminalError, interpolateEnvVars } from "./utils.js";
+import { createOAuthFetch, oauthHeaderResolver, resolveOAuthHeaders } from "./mcp-auth-fetch.js";
+import { isBuiltInAgentPlugin } from "./agent-plugin-provenance.js";
 import { abortable, throwIfAborted } from "./abort.js";
 import { combineAbortSignals, isAbortError } from "./runtime-owner.js";
+function pluginAwareOAuthHeaders(definition) {
+  return oauthHeaderResolver(definition?.headers, {
+    literal: definition ? isBuiltInAgentPlugin(definition, "headers") : false
+  });
+}
 function applyOAuthConfig(discovery, config) {
   return {
     ...discovery,
@@ -73,8 +84,19 @@ function getRuntimeState(runtime) {
     throw new Error("Unknown OAuth runtime");
   return state;
 }
+function getAuthStorageIdentity(options) {
+  return options.credentialStore === "encrypted-file" ? ["encrypted-file"] : ["os", getAuthBaseDir(options)];
+}
 function getPendingAuthKey(serverName, options) {
-  return `${serverName}|${getAuthBaseDir(options)}`;
+  return JSON.stringify([serverName, ...getAuthStorageIdentity(options)]);
+}
+function hasOAuthAuthority(authority) {
+  try {
+    authority();
+    return true;
+  } catch {
+    return false;
+  }
 }
 export function hasPendingAuth(serverName, options, runtime) {
   const state = getRuntimeState(runtime ?? legacyRuntime);
@@ -104,6 +126,20 @@ export function extractOAuthConfig(definition) {
       throw new Error("OAuth clientSecret must be a string");
     config.clientSecret = definition.oauth.clientSecret.startsWith("!") ? definition.oauth.clientSecret : interpolateEnvVars(definition.oauth.clientSecret);
   }
+  if (definition.oauth?.clientMetadataUrl !== undefined) {
+    if (typeof definition.oauth.clientMetadataUrl !== "string") {
+      throw new Error("OAuth clientMetadataUrl must be a string");
+    }
+    const clientMetadataUrl = interpolateEnvVars(definition.oauth.clientMetadataUrl).trim();
+    if (!clientMetadataUrl) {
+      throw new Error("OAuth clientMetadataUrl must not be empty");
+    }
+    validateClientMetadataUrl(clientMetadataUrl);
+    config.clientMetadataUrl = clientMetadataUrl;
+  }
+  if (config.clientMetadataUrl !== undefined && config.clientSecret !== undefined && !config.clientId) {
+    throw new Error("OAuth clientSecret requires an explicit clientId when clientMetadataUrl is configured");
+  }
   if (definition.oauth?.scope !== undefined) {
     if (typeof definition.oauth.scope !== "string")
       throw new Error("OAuth scope must be a string");
@@ -200,15 +236,18 @@ export function extractOAuthConfig(definition) {
   return config;
 }
 async function probeAuthDiscovery(serverUrl, definition, signal) {
-  const discoveryHeaders = definition?.headers ? Object.fromEntries(Object.entries(definition.headers).filter(([, value]) => !value.startsWith("!") || value.startsWith("!!"))) : undefined;
-  const headers = new Headers(interpolateEnvRecord(discoveryHeaders));
-  headers.set("content-type", "application/json");
+  const serviceHeaders = resolveOAuthHeaders(definition?.headers, {
+    commands: false,
+    literal: definition ? isBuiltInAgentPlugin(definition, "headers") : false
+  });
+  const probeFetch = createOAuthFetch(serverUrl, () => serviceHeaders, signal, { timeout: false });
+  const headers = new Headers({ "content-type": "application/json" });
   const controller = new AbortController;
   const discoverySignal = combineAbortSignals(signal, controller.signal);
   const timer = setTimeout(() => controller.abort(), 5000);
   try {
     headers.set("accept", "application/json, text/event-stream");
-    const response = await fetch(new URL(serverUrl), {
+    const response = await probeFetch(new URL(serverUrl), {
       method: "POST",
       headers,
       body: JSON.stringify({
@@ -235,9 +274,26 @@ async function probeAuthDiscovery(serverUrl, definition, signal) {
   }
 }
 function parseOAuthRedirectUri(redirectUri) {
+  const dynamicPortPlaceholder = "{port}";
+  const placeholderCount = redirectUri.split(dynamicPortPlaceholder).length - 1;
+  if (placeholderCount > 1) {
+    throw new Error("OAuth redirectUri may contain at most one {port} placeholder");
+  }
+  let parsedRedirectUri = redirectUri;
+  const dynamicPort = placeholderCount === 1;
+  if (dynamicPort) {
+    const authorityStart = redirectUri.indexOf("://") + 3;
+    const pathStart = redirectUri.slice(authorityStart).search(/[/?#]/);
+    const authorityEnd = pathStart === -1 ? redirectUri.length : authorityStart + pathStart;
+    const authority = redirectUri.slice(authorityStart, authorityEnd);
+    if (authorityStart < 3 || !authority.endsWith(`:${dynamicPortPlaceholder}`)) {
+      throw new Error("OAuth redirectUri {port} placeholder must be the loopback URI port");
+    }
+    parsedRedirectUri = redirectUri.replace(dynamicPortPlaceholder, "1");
+  }
   let url;
   try {
-    url = new URL(redirectUri);
+    url = new URL(parsedRedirectUri);
   } catch (error) {
     throw new Error(`Invalid OAuth redirectUri: ${redirectUri}`, { cause: error });
   }
@@ -249,6 +305,9 @@ function parseOAuthRedirectUri(redirectUri) {
   }
   const hostname = url.hostname.toLowerCase();
   const isLocalhost = hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]" || hostname === "::1";
+  if (dynamicPort && (url.protocol !== "http:" || !isLocalhost)) {
+    throw new Error("OAuth redirectUri {port} placeholder is allowed only for an http:// localhost or loopback URI");
+  }
   if (url.port) {
     const parsedPort = Number.parseInt(url.port, 10);
     if (!Number.isInteger(parsedPort) || parsedPort <= 0 || parsedPort > 65535) {
@@ -265,15 +324,21 @@ function parseOAuthRedirectUri(redirectUri) {
     throw new Error("OAuth localhost redirectUri must include an explicit numeric port");
   }
   const port = Number.parseInt(url.port, 10);
-  if (!Number.isInteger(port) || port <= 0 || port > 65535) {
-    throw new Error("OAuth localhost redirectUri must include an explicit numeric port");
-  }
   const callbackHost = hostname === "[::1]" ? "::1" : hostname;
-  return { mode: "local", port, callbackHost, callbackPath: url.pathname };
+  return {
+    mode: "local",
+    ...dynamicPort ? {} : { port },
+    callbackHost,
+    callbackPath: url.pathname,
+    dynamicPort,
+    resolveRedirectUri: (assignedPort) => dynamicPort ? redirectUri.replace(dynamicPortPlaceholder, String(assignedPort)) : redirectUri
+  };
 }
-export async function startAuth(serverName, serverUrl, definition, options = {}) {
+export async function startAuth(serverName, serverUrl, definition, options = {}, operationAuthority) {
   if (isServerDisabled(definition))
     throw new Error(`MCP server "${serverName}" is disabled`);
+  const authority = operationAuthority ?? captureOAuthAuthority(serverName);
+  authority();
   const runtime = getRuntime(options);
   const runtimeState = getRuntimeState(runtime);
   const config = definition ? extractOAuthConfig(definition) : {};
@@ -283,20 +348,26 @@ export async function startAuth(serverName, serverUrl, definition, options = {})
   throwIfAborted(signal);
   if (config.grantType === "client_credentials") {
     const storedAuth = await getAuthForUrl(serverName, serverUrl, authStorageOptions);
+    authority();
     if (storedAuth?.clientInfo && !storedAuth.tokens && !config.clientId) {
       clearClientInfo(serverName, authStorageOptions);
       clearCodeVerifier(serverName, authStorageOptions);
-      await clearOAuthState(serverName, authStorageOptions);
+      clearOAuthState(serverName, authStorageOptions);
     }
+    authority();
     const authProvider = new McpOAuthProvider(serverName, serverUrl, config, {
       onRedirect: async () => {
         throw new Error("Browser redirect is not used for client_credentials flow");
       }
-    }, authStorageOptions, runtime.signal);
+    }, authStorageOptions, runtime.signal, undefined, authority);
     try {
+      const fetchFn = createOAuthFetch(serverUrl, pluginAwareOAuthHeaders(definition), signal);
+      authProvider.setAuthFetch(fetchFn);
       const discovery = applyOAuthConfig(await probeAuthDiscovery(serverUrl, definition, signal), config);
+      authority();
       throwIfAborted(signal);
-      const result = await abortable(runSdkAuth(authProvider, { serverUrl, ...discovery }), signal);
+      const result = await abortable(runSdkAuth(authProvider, { serverUrl, ...discovery, fetchFn }), signal);
+      authority();
       throwIfAborted(signal);
       if (result !== "AUTHORIZED") {
         throw new UnauthorizedError("Failed to authorize");
@@ -308,6 +379,7 @@ export async function startAuth(serverName, serverUrl, definition, options = {})
   }
   const existingPendingAuth = runtimeState.pendingAuths.get(getPendingAuthKey(serverName, authStorageOptions));
   if (existingPendingAuth?.serverUrl === serverUrl) {
+    existingPendingAuth.authority();
     return { authorizationUrl: existingPendingAuth.authorizationUrl };
   }
   const redirectTarget = config.redirectUri !== undefined ? parseOAuthRedirectUri(config.redirectUri) : undefined;
@@ -316,16 +388,27 @@ export async function startAuth(serverName, serverUrl, definition, options = {})
   if (!manualRedirect) {
     try {
       await ensureCallbackServer({
-        strictPort: Boolean(config.clientId) || config.redirectUri !== undefined,
+        strictPort: redirectTarget?.mode === "local" ? !redirectTarget.dynamicPort : Boolean(config.clientId),
         oauthState,
         reserveState: true,
-        ...redirectTarget?.mode === "local" ? { port: redirectTarget.port, callbackHost: redirectTarget.callbackHost, callbackPath: redirectTarget.callbackPath } : {}
+        ...redirectTarget?.mode === "local" ? {
+          ...redirectTarget.port !== undefined ? { port: redirectTarget.port } : {},
+          callbackHost: redirectTarget.callbackHost,
+          callbackPath: redirectTarget.callbackPath
+        } : {}
       });
+      authority();
       throwIfAborted(signal);
+      if (redirectTarget?.mode === "local" && redirectTarget.dynamicPort) {
+        config.redirectUri = redirectTarget.resolveRedirectUri(getOAuthCallbackPort());
+      }
     } catch (error) {
       releaseCallbackServer(oauthState);
       try {
-        await cleanupAndReleaseCallbackServerIfIdle(() => clearOAuthState(serverName, authStorageOptions));
+        await cleanupAndReleaseCallbackServerIfIdle(() => {
+          if (hasOAuthAuthority(authority))
+            clearOAuthState(serverName, authStorageOptions);
+        });
       } catch (cleanupError) {
         throw new AggregateError([error, cleanupError], "OAuth startup cleanup failed");
       }
@@ -333,38 +416,46 @@ export async function startAuth(serverName, serverUrl, definition, options = {})
     }
   }
   let capturedUrl;
+  authority();
   const authProvider = new McpOAuthProvider(serverName, serverUrl, config, {
     onRedirect: async (url) => {
       capturedUrl = url;
     }
-  }, authStorageOptions, runtime.signal, oauthState);
+  }, authStorageOptions, runtime.signal, oauthState, authority);
   try {
     const storedAuth = await getAuthForUrl(serverName, serverUrl, authStorageOptions);
+    authority();
     if (storedAuth?.clientInfo && !config.clientId) {
       if (!storedAuth.tokens) {
         clearClientInfo(serverName, authStorageOptions);
         clearCodeVerifier(serverName, authStorageOptions);
-        await clearOAuthState(serverName, authStorageOptions);
+        clearOAuthState(serverName, authStorageOptions);
       } else {
         const redirectUris = storedAuth.clientInfo.redirectUris;
-        if (!Array.isArray(redirectUris) || !redirectUris.includes(authProvider.redirectUrl ?? "")) {
+        const redirectUriMatches = Array.isArray(redirectUris) && redirectUris.includes(authProvider.redirectUrl ?? "");
+        if (!redirectUriMatches && !storedAuth.tokens.refreshToken) {
           clearClientInfo(serverName, authStorageOptions);
-          clearTokens(serverName, authStorageOptions);
           clearCodeVerifier(serverName, authStorageOptions);
-          await clearOAuthState(serverName, authStorageOptions);
+          clearOAuthState(serverName, authStorageOptions);
         }
       }
     }
     throwIfAborted(signal);
+    const getHeaders = pluginAwareOAuthHeaders(definition);
+    const fetchFn = createOAuthFetch(serverUrl, getHeaders, signal);
+    authProvider.setAuthFetch(fetchFn);
     const discovery = applyOAuthConfig(await probeAuthDiscovery(serverUrl, definition, signal), config);
+    authority();
     throwIfAborted(signal);
-    const result = await abortable(runSdkAuth(authProvider, { serverUrl, ...discovery }), signal);
+    const result = await abortable(runSdkAuth(authProvider, { serverUrl, ...discovery, fetchFn }), signal);
+    authority();
     throwIfAborted(signal);
     if (result === "AUTHORIZED") {
       authProvider.deactivate();
       releaseCallbackServer(oauthState);
-      await clearOAuthState(serverName, authStorageOptions);
+      clearOAuthState(serverName, authStorageOptions);
       await stopCallbackServerIfIdle();
+      authority();
       return { authorizationUrl: "" };
     }
     if (!capturedUrl) {
@@ -378,8 +469,11 @@ export async function startAuth(serverName, serverUrl, definition, options = {})
       manualRedirect,
       ...manualRedirect ? { manualCompletionController: new AbortController } : {},
       discovery,
-      authStorageOptions
+      getHeaders,
+      authStorageOptions,
+      authority
     }, oauthState, signal, generation);
+    authority();
     return { authorizationUrl: capturedUrl.toString() };
   } catch (error) {
     authProvider.deactivate();
@@ -394,7 +488,9 @@ export async function startAuth(serverName, serverUrl, definition, options = {})
 async function setPendingAuth(runtime, serverName, pendingAuth, oauthState, signal, generation = getRuntimeState(runtime).generation) {
   const state = getRuntimeState(runtime);
   const key = getPendingAuthKey(serverName, pendingAuth.authStorageOptions);
+  pendingAuth.authority();
   await clearPendingAuth(runtime, serverName, undefined, pendingAuth.authStorageOptions);
+  pendingAuth.authority();
   throwIfAborted(signal);
   if (generation !== state.generation)
     throw new Error("OAuth runtime stopped");
@@ -411,29 +507,39 @@ async function setPendingAuth(runtime, serverName, pendingAuth, oauthState, sign
 async function clearPendingAuth(runtime, serverName, oauthState, fallbackStorageOptions = {}, reason = new Error("Authorization cancelled")) {
   const state = getRuntimeState(runtime);
   const key = getPendingAuthKey(serverName, fallbackStorageOptions);
-  const pendingAuth = state.pendingAuths.get(key);
-  const authStorageOptions = pendingAuth?.authStorageOptions ?? fallbackStorageOptions;
   const pendingState = state.pendingAuthStates.get(key);
-  if (oauthState && pendingState && pendingState !== oauthState)
+  if (oauthState && pendingState !== oauthState) {
+    cancelPendingCallback(oauthState);
     return;
-  const timer = state.pendingAuthCleanupTimers.get(key);
-  if (timer) {
-    clearTimeout(timer);
-    state.pendingAuthCleanupTimers.delete(key);
   }
-  pendingAuth?.manualCompletionController?.abort(reason);
-  pendingAuth?.authProvider.deactivate();
-  state.pendingAuths.delete(key);
-  state.pendingAuthStates.delete(key);
+  const { pendingAuth } = detachPending(state, key, reason);
+  const authStorageOptions = pendingAuth?.authStorageOptions ?? fallbackStorageOptions;
   const stateToRelease = pendingState ?? oauthState;
   if (stateToRelease) {
-    cancelPendingCallback(stateToRelease);
-    const storedState = await getOAuthState(serverName, authStorageOptions);
-    if (storedState === stateToRelease) {
-      await clearOAuthState(serverName, authStorageOptions);
+    if (!pendingState)
+      cancelPendingCallback(stateToRelease);
+    if (pendingAuth && hasOAuthAuthority(pendingAuth.authority)) {
+      const storedState = getOAuthState(serverName, authStorageOptions);
+      if (storedState === stateToRelease)
+        clearOAuthState(serverName, authStorageOptions);
     }
   }
 }
+function detachPending(state, key, reason) {
+  const pendingAuth = state.pendingAuths.get(key);
+  const oauthState = state.pendingAuthStates.get(key);
+  const timer = state.pendingAuthCleanupTimers.get(key);
+  if (timer)
+    clearTimeout(timer);
+  state.pendingAuthCleanupTimers.delete(key);
+  state.pendingAuths.delete(key);
+  state.pendingAuthStates.delete(key);
+  pendingAuth?.manualCompletionController?.abort(reason);
+  pendingAuth?.authProvider.deactivate();
+  if (oauthState)
+    cancelPendingCallback(oauthState);
+  return { pendingAuth, oauthState };
+}
 async function clearPendingAuthAndReleaseIfIdle(runtime, serverName, oauthState, fallbackStorageOptions = {}, reason) {
   await cleanupAndReleaseCallbackServerIfIdle(() => clearPendingAuth(runtime, serverName, oauthState, fallbackStorageOptions, reason));
 }
@@ -455,6 +561,18 @@ async function cleanupAndReleaseCallbackServerIfIdle(cleanup) {
   if (cleanupFailure)
     throw cleanupFailure.error;
 }
+function detachPendingAuthsForServer(serverName, reason) {
+  for (const runtime of activeRuntimes) {
+    const state = getRuntimeState(runtime);
+    for (const [key, pendingAuth] of state.pendingAuths) {
+      if (pendingAuth.serverName !== serverName)
+        continue;
+      if (state.pendingAuths.get(key) !== pendingAuth)
+        continue;
+      detachPending(state, key, reason);
+    }
+  }
+}
 function getSearchParamsFromInput(input) {
   try {
     const url = new URL(input);
@@ -579,12 +697,16 @@ export async function completeAuth(serverName, authorizationCode, options = {})
   if (!pendingAuth) {
     throw new Error(`No pending OAuth flow for server: ${serverName}`);
   }
+  pendingAuth.authority();
   const oauthState = runtimeState.pendingAuthStates.get(key);
   throwIfAborted(signal);
   let keepPendingForRetry = false;
   let caughtError;
   try {
+    const fetchFn = createOAuthFetch(pendingAuth.serverUrl, pendingAuth.getHeaders, signal);
+    pendingAuth.authProvider.setAuthFetch(fetchFn);
     const discoveryState = await pendingAuth.authProvider.discoveryState();
+    pendingAuth.authority();
     const metadata = discoveryState?.authorizationServerMetadata;
     const expectedIssuer = metadata?.issuer ?? discoveryState?.authorizationServerUrl;
     const requiresIssuer = metadata?.authorization_response_iss_parameter_supported === true;
@@ -599,8 +721,10 @@ export async function completeAuth(serverName, authorizationCode, options = {})
       serverUrl: pendingAuth.serverUrl,
       authorizationCode: code,
       ...iss !== undefined ? { iss } : {},
-      ...pendingAuth.discovery
+      ...pendingAuth.discovery,
+      fetchFn
     }), signal);
+    pendingAuth.authority();
     throwIfAborted(signal);
     if (result !== "AUTHORIZED") {
       throw new UnauthorizedError("Failed to authorize");
@@ -619,28 +743,39 @@ export async function completeAuth(serverName, authorizationCode, options = {})
         }
         throw cleanupError;
       }
+      if (caughtError === undefined)
+        pendingAuth.authority();
     }
   }
 }
 export async function authenticate(serverName, serverUrl, definition, options = {}) {
   if (isServerDisabled(definition))
     throw new Error(`MCP server "${serverName}" is disabled`);
+  const authority = captureOAuthAuthority(serverName);
   const runtime = getRuntime(options);
   const runtimeState = getRuntimeState(runtime);
   const authStorageOptions = options.authStorageOptions ?? {};
   const signal = combineAbortSignals(runtime.signal, options.signal);
   throwIfAborted(signal);
-  const authKey = `${serverName}|${serverUrl}|${getAuthBaseDir(authStorageOptions)}`;
+  const authKey = JSON.stringify([serverName, serverUrl, ...getAuthStorageIdentity(authStorageOptions)]);
   const inFlight = runtimeState.pendingAuthentications.get(authKey);
   if (inFlight) {
-    return inFlight;
+    try {
+      inFlight.authority();
+      return inFlight.promise;
+    } catch {
+      if (runtimeState.pendingAuthentications.get(authKey) === inFlight) {
+        runtimeState.pendingAuthentications.delete(authKey);
+      }
+    }
   }
   const operation = (async () => {
     const { authorizationUrl } = await startAuth(serverName, serverUrl, definition, {
       ...options,
       ...signal ? { signal } : {},
       runtime
-    });
+    }, authority);
+    authority();
     if (!authorizationUrl) {
       return "authenticated";
     }
@@ -667,7 +802,7 @@ export async function authenticate(serverName, serverUrl, definition, options =
 ${authorizationUrl}`);
       }
       try {
-        await abortable(open(authorizationUrl), signal);
+        await abortable(Promise.resolve(options.openAuthorizationUrl ? options.openAuthorizationUrl(authorizationUrl) : open(authorizationUrl)), signal);
       } catch (error) {
         if (isAbortError(error, signal))
           throw error;
@@ -694,54 +829,70 @@ ${authorizationUrl}`);
       throw error;
     }
   })();
-  runtimeState.pendingAuthentications.set(authKey, operation);
+  const pendingAuthentication = { promise: operation, authority };
+  runtimeState.pendingAuthentications.set(authKey, pendingAuthentication);
   try {
-    return await operation;
+    const result = await operation;
+    authority();
+    return result;
   } finally {
-    if (runtimeState.pendingAuthentications.get(authKey) === operation) {
+    if (runtimeState.pendingAuthentications.get(authKey) === pendingAuthentication) {
       runtimeState.pendingAuthentications.delete(authKey);
     }
   }
 }
 export async function getValidToken(serverName, serverUrl, options = {}) {
+  const authority = captureOAuthAuthority(serverName);
   const runtime = getRuntime(options);
   const authStorageOptions = options.authStorageOptions ?? {};
   const signal = combineAbortSignals(runtime.signal, options.signal);
   throwIfAborted(signal);
   const entry = await getAuthForUrl(serverName, serverUrl, authStorageOptions);
+  if (!hasOAuthAuthority(authority))
+    return null;
   throwIfAborted(signal);
   if (!entry?.tokens) {
     return null;
   }
-  const expired = await isTokenExpired(serverName, authStorageOptions);
+  const expired = entry.tokens.expiresAt ? entry.tokens.expiresAt < Date.now() / 1000 : false;
   if (expired === false) {
+    authority();
     return entry.tokens;
   }
   if (expired === true && entry.tokens.refreshToken) {
     console.log(`MCP Auth: Token expired for ${serverName}, attempting refresh`);
     try {
-      const authProvider = new McpOAuthProvider(serverName, serverUrl, {}, {
+      const config = options.definition ? extractOAuthConfig(options.definition) : {};
+      const fetchFn = createOAuthFetch(serverUrl, pluginAwareOAuthHeaders(options.definition), signal);
+      authority();
+      const authProvider = new McpOAuthProvider(serverName, serverUrl, config, {
         onRedirect: async () => {}
-      }, authStorageOptions, runtime.signal);
+      }, authStorageOptions, runtime.signal, undefined, authority);
       try {
+        authProvider.setAuthFetch(fetchFn);
         const clientInfo = await authProvider.clientInformation();
+        authority();
         throwIfAborted(signal);
         if (!clientInfo) {
           console.log(`MCP Auth: No client info for refresh for ${serverName}`);
           return null;
         }
-        const discovery = await probeAuthDiscovery(serverUrl, undefined, signal);
+        const discovery = applyOAuthConfig(await probeAuthDiscovery(serverUrl, options.definition, signal), config);
+        authority();
         throwIfAborted(signal);
         const result = await abortable(runSdkAuth(authProvider, {
           serverUrl,
           ...discovery,
-          ...options.skipIssuerMetadataValidation === true ? { skipIssuerMetadataValidation: true } : {}
+          ...options.skipIssuerMetadataValidation === true ? { skipIssuerMetadataValidation: true } : {},
+          fetchFn
         }), signal);
+        authority();
         throwIfAborted(signal);
         if (result !== "AUTHORIZED") {
           return null;
         }
         const refreshed = await getAuthForUrl(serverName, serverUrl, authStorageOptions);
+        authority();
         throwIfAborted(signal);
         return refreshed?.tokens ?? null;
       } finally {
@@ -750,37 +901,39 @@ export async function getValidToken(serverName, serverUrl, options = {}) {
     } catch (error) {
       if (isAbortError(error, signal) || error instanceof OAuthCredentialStoreError)
         throw error;
-      console.error(`MCP Auth: Token refresh failed for ${serverName}`, { error });
+      console.error(`MCP Auth: Token refresh failed for ${serverName}`);
       return null;
     }
   }
-  return entry.tokens;
+  authority();
+  return null;
 }
 export async function getAuthStatus(serverName, options = {}) {
   getRuntime(options);
   const authStorageOptions = options.authStorageOptions ?? {};
-  const hasTokens = await hasStoredTokens(serverName, authStorageOptions);
-  if (!hasTokens)
+  const entry = getAuthEntry(serverName, authStorageOptions);
+  if (!entry?.tokens)
     return "not_authenticated";
-  const expired = await isTokenExpired(serverName, authStorageOptions);
-  return expired ? "expired" : "authenticated";
+  return entry.tokens.expiresAt && entry.tokens.expiresAt < Date.now() / 1000 ? "expired" : "authenticated";
 }
 export async function removeAuth(serverName, options = {}) {
   const runtime = getRuntime(options);
   const signal = combineAbortSignals(runtime.signal, options.signal);
   throwIfAborted(signal);
   const authStorageOptions = options.authStorageOptions ?? {};
-  const oauthState = await getOAuthState(serverName, authStorageOptions);
-  throwIfAborted(signal);
-  if (oauthState) {
-    cancelPendingCallback(oauthState);
+  const releaseRevocation = beginOAuthRevocation(serverName);
+  try {
+    detachPendingAuthsForServer(serverName, new Error("Authorization cancelled by logout"));
+    const storedOAuthState = getOAuthState(serverName, authStorageOptions);
+    if (storedOAuthState)
+      cancelPendingCallback(storedOAuthState);
+    await stopCallbackServerIfIdle();
+    throwIfAborted(signal);
+    clearAllCredentials(serverName, authStorageOptions);
+    console.log(`MCP Auth: Removed credentials for ${serverName}`);
+  } finally {
+    releaseRevocation();
   }
-  await clearPendingAuthAndReleaseIfIdle(runtime, serverName, oauthState, authStorageOptions);
-  throwIfAborted(signal);
-  clearAllCredentials(serverName, authStorageOptions);
-  await clearOAuthState(serverName, authStorageOptions);
-  throwIfAborted(signal);
-  console.log(`MCP Auth: Removed credentials for ${serverName}`);
 }
 export function supportsOAuth(definition) {
   if (!definition.url)