@duckmind/dm-linux-x64 0.65.4 → 0.65.6

package/extensions/dm-mcp-adapter/mcp-bearer-store.js

@@ -1,14 +1,7 @@
 import { createHash } from "node:crypto";
-import { createRequire } from "node:module";
-import { dirname, join } from "node:path";
-const require = createRequire(import.meta.url);
+import { createSecureKeyringStore, getTestSecureKeyringEntries, getTestSecureKeyringReadCount, removeTestSecureKeyringEntry, resetTestSecureKeyring, setTestSecureKeyringEntry } from "./secure-keyring.js";
 const BEARER_SECRET_SERVICE = "dm-mcp-adapter.bearer";
-const TEST_AUTH_STORE_ENV = "DM_MCP_ADAPTER_TEST_AUTH_STORE";
 const BEARER_SECRET_CHUNK_SIZE = 1000;
-const BEARER_SECRET_VALUE_LIMIT = 1280;
-let KeyringEntryClass;
-const memoryBearerEntries = new Map;
-let testBearerSecretStoreReadCount = 0;
 
 export class BearerCredentialStoreError extends Error {
   code = "BEARER_CREDENTIAL_STORE_UNAVAILABLE";
@@ -19,129 +12,8 @@ export class BearerCredentialStoreError extends Error {
     this.operation = operation;
   }
 }
-const memoryBearerSecretStore = {
-  read(account) {
-    testBearerSecretStoreReadCount++;
-    return memoryBearerEntries.get(account);
-  },
-  write(account, payload) {
-    memoryBearerEntries.set(account, payload);
-  },
-  remove(account) {
-    memoryBearerEntries.delete(account);
-  }
-};
-const sizeLimitedBearerSecretStore = {
-  read(account) {
-    testBearerSecretStoreReadCount++;
-    return memoryBearerEntries.get(account);
-  },
-  write(account, payload) {
-    if (payload.length > BEARER_SECRET_VALUE_LIMIT) {
-      throw new Error(`Value of 'password encoded as UTF-16' is longer than the platform limit of ${BEARER_SECRET_VALUE_LIMIT * 2} chars`);
-    }
-    memoryBearerEntries.set(account, payload);
-  },
-  remove(account) {
-    memoryBearerEntries.delete(account);
-  }
-};
-const unavailableBearerSecretStore = {
-  read() {
-    testBearerSecretStoreReadCount++;
-    throw new Error("simulated secure credential store unavailable");
-  },
-  write() {
-    throw new Error("simulated secure credential store unavailable");
-  },
-  remove() {
-    throw new Error("simulated secure credential store unavailable");
-  }
-};
-const keyringBearerSecretStore = {
-  read(account) {
-    return getKeyringEntry(account).getPassword() ?? undefined;
-  },
-  write(account, payload) {
-    getKeyringEntry(account).setPassword(payload);
-  },
-  remove(account) {
-    getKeyringEntry(account).deleteCredential();
-  }
-};
 function getBearerSecretStore() {
-  if (process.env[TEST_AUTH_STORE_ENV] === "memory")
-    return memoryBearerSecretStore;
-  if (process.env[TEST_AUTH_STORE_ENV] === "sizelimited")
-    return sizeLimitedBearerSecretStore;
-  if (process.env[TEST_AUTH_STORE_ENV] === "unavailable")
-    return unavailableBearerSecretStore;
-  return keyringBearerSecretStore;
-}
-function getKeyringEntry(account) {
-  try {
-    KeyringEntryClass ??= loadKeyringEntryClass();
-    return new KeyringEntryClass(BEARER_SECRET_SERVICE, account);
-  } catch (error) {
-    throw new Error("Bearer token secure credential storage is unavailable. Configure the OS credential store and retry.", { cause: error });
-  }
-}
-function loadKeyringEntryClass(keyringRequire = require, platform = process.platform, arch = process.arch) {
-  try {
-    return keyringRequire("@napi-rs/keyring").Entry;
-  } catch (loaderError) {
-    try {
-      return loadKeyringNativeBindingFallback(keyringRequire, platform, arch).Entry;
-    } catch (fallbackError) {
-      const message = fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
-      throw new Error(`Failed to load @napi-rs/keyring; absolute-path native binding fallback also failed: ${message}`, { cause: loaderError });
-    }
-  }
-}
-function loadKeyringNativeBindingFallback(keyringRequire, platform, arch) {
-  const targets = getKeyringNativeBindingSuffixes(platform, arch).map((suffix) => ({
-    packageName: `@napi-rs/keyring-${suffix}`,
-    bindingFile: `keyring.${suffix}.node`
-  }));
-  let lastError;
-  for (const target of targets) {
-    try {
-      const packageJsonPath = keyringRequire.resolve(`${target.packageName}/package.json`);
-      return keyringRequire(join(dirname(packageJsonPath), target.bindingFile));
-    } catch (error) {
-      lastError = error;
-    }
-  }
-  throw lastError instanceof Error ? lastError : new Error(String(lastError));
-}
-function getKeyringNativeBindingSuffixes(platform, arch) {
-  if (platform === "darwin") {
-    if (arch === "arm64")
-      return ["darwin-arm64"];
-    if (arch === "x64")
-      return ["darwin-x64"];
-  }
-  if (platform === "win32") {
-    if (arch === "arm64")
-      return ["win32-arm64-msvc"];
-    if (arch === "x64")
-      return ["win32-x64-msvc"];
-    if (arch === "ia32")
-      return ["win32-ia32-msvc"];
-  }
-  if (platform === "linux") {
-    if (arch === "arm64")
-      return ["linux-arm64-gnu", "linux-arm64-musl"];
-    if (arch === "arm")
-      return ["linux-arm-gnueabihf"];
-    if (arch === "riscv64")
-      return ["linux-riscv64-gnu"];
-    if (arch === "x64")
-      return ["linux-x64-gnu", "linux-x64-musl"];
-  }
-  if (platform === "freebsd" && arch === "x64")
-    return ["freebsd-x64"];
-  return [];
+  return createSecureKeyringStore(BEARER_SECRET_SERVICE);
 }
 function getBearerAccount(serverName) {
   if (typeof serverName !== "string") {
@@ -294,18 +166,17 @@ export function inspectBearerTokenForUrl(serverName, serverUrl) {
   }
 }
 export function resetTestBearerTokenStore() {
-  memoryBearerEntries.clear();
-  testBearerSecretStoreReadCount = 0;
+  resetTestSecureKeyring();
 }
 export function getTestBearerTokenStoreEntries() {
-  return [...memoryBearerEntries.entries()];
+  return getTestSecureKeyringEntries().filter(([key]) => key.startsWith(`${BEARER_SECRET_SERVICE}\x00`)).map(([key, value]) => [key.slice(BEARER_SECRET_SERVICE.length + 1), value]);
 }
 export function removeTestBearerTokenStoreEntry(account) {
-  memoryBearerEntries.delete(account);
+  removeTestSecureKeyringEntry(BEARER_SECRET_SERVICE, account);
 }
 export function setTestBearerTokenStoreEntry(account, payload) {
-  memoryBearerEntries.set(account, payload);
+  setTestSecureKeyringEntry(BEARER_SECRET_SERVICE, account, payload);
 }
 export function getTestBearerTokenStoreReadCount() {
-  return testBearerSecretStoreReadCount;
+  return getTestSecureKeyringReadCount();
 }

package/extensions/dm-mcp-adapter/mcp-code.js

@@ -1,13 +1,17 @@
 import { formatWithOptions } from "node:util";
 import { Worker } from "node:worker_threads";
+import { throwIfAborted } from "./abort.js";
 import { guardMcpOutput, guardedMcpDetails, resolveMcpOutputGuardOptions } from "./mcp-output-guard.js";
+import { evaluateJev, validateJevSettings } from "./jev-client.js";
 import { executeCall } from "./proxy-modes.js";
 import { combineAbortSignals } from "./runtime-owner.js";
 import { paginate, rankSuggestions, rankToolMatches } from "./search-ranking.js";
+import { semanticSearch } from "./semantic-search.js";
 import { isServerInActiveFailureBackoff } from "./failure-backoff.js";
-import { findToolByName, formatSchema } from "./tool-metadata.js";
+import { findToolByName, formatSchema, hasSchemaDescriptions } from "./tool-metadata.js";
 import { renderTsShape } from "./ts-shape.js";
 export const DEFAULT_MCP_SCRIPT_TIMEOUT_MS = 30000;
+const MCP_SCRIPT_INTERMEDIATE_MAX_BYTES = 16 * 1024 * 1024;
 
 class McpScriptTimeoutError extends Error {
   constructor(timeoutMs) {
@@ -73,6 +77,9 @@ function parseWorkerMessage(value) {
   if (message.type === "call" && typeof message.id === "number" && typeof message.path === "string") {
     return "args" in message ? { type: "call", id: message.id, path: message.path, args: message.args } : { type: "call", id: message.id, path: message.path };
   }
+  if (message.type === "evaluate" && typeof message.id === "number" && "input" in message) {
+    return { type: "evaluate", id: message.id, input: message.input };
+  }
   if ((message.type === "search" || message.type === "describe") && typeof message.id === "number") {
     return "input" in message ? { type: message.type, id: message.id, input: message.input } : { type: message.type, id: message.id };
   }
@@ -84,51 +91,164 @@ function parseWorkerMessage(value) {
   }
   return null;
 }
-export async function runMcpScript(state, code, timeoutMs = DEFAULT_MCP_SCRIPT_TIMEOUT_MS, getPiTools, signal) {
+export async function runMcpScript(state, code, timeoutMs = DEFAULT_MCP_SCRIPT_TIMEOUT_MS, getPiTools, signal, jevEvaluator = evaluateJev, semanticEvaluator) {
   const resolvedTimeoutMs = Number.isFinite(timeoutMs) && timeoutMs > 0 ? Math.floor(timeoutMs) : DEFAULT_MCP_SCRIPT_TIMEOUT_MS;
   const output = [];
   const externalSignal = combineAbortSignals(state.owner?.signal, signal);
   const timeoutController = new AbortController;
   const callSignal = combineAbortSignals(externalSignal, timeoutController.signal);
+  const observedSources = new Set;
   const calls = [];
   const snapshotCalls = () => calls.map(({ startedAt, ...operation }) => ({
     ...operation,
     durationMs: "error" in operation && operation.error === "incomplete" ? Math.max(0, Date.now() - startedAt) : operation.durationMs
   }));
   let callsSnapshot;
+  let intermediateBytes = 0;
+  const reserveIntermediateBytes = (dataJson) => {
+    const bytes = Buffer.byteLength(dataJson, "utf8");
+    if (bytes > MCP_SCRIPT_INTERMEDIATE_MAX_BYTES - intermediateBytes)
+      return false;
+    intermediateBytes += bytes;
+    return true;
+  };
   const callTool = async (path, args) => {
     const startedAt = Date.now();
     const index = calls.push({ operation: "call", path, ok: false, error: "incomplete", durationMs: 0, startedAt }) - 1;
-    const result = await executeCall(state, path, args, undefined, getPiTools, callSignal, "script");
+    let dataJson;
+    const result = await executeCall(state, path, args, undefined, getPiTools, callSignal, "script", {
+      onSuccess(data) {
+        dataJson = JSON.stringify(data);
+      }
+    });
     const details = result.details;
+    if (typeof details.server === "string")
+      observedSources.add(details.server);
     if (details.error !== undefined) {
       const errorCode = String(details.error);
       const suggestions = Array.isArray(details.suggestions) ? details.suggestions.filter((suggestion) => typeof suggestion === "string") : [];
       const message = errorCode === "tool_not_found" ? `Tool "${path}" not found. Use await tools.search({ query: "..." }) inside mcpScript.${suggestions.length > 0 ? ` Did you mean: ${suggestions.join(", ")}` : ""}` : typeof details.message === "string" ? details.message : textFromContent(result.content);
       calls[index] = { operation: "call", path, ok: false, error: errorCode, durationMs: Date.now() - startedAt, startedAt };
       return {
-        ok: false,
-        error: { code: errorCode, message }
+        envelope: { ok: false, error: { code: errorCode, message } }
+      };
+    }
+    throwIfAborted(callSignal);
+    if (dataJson === undefined)
+      throw new Error("MCP intermediate result was not JSON serializable");
+    if (!reserveIntermediateBytes(dataJson)) {
+      const code = "intermediate_result_too_large";
+      calls[index] = { operation: "call", path, ok: false, error: code, durationMs: Date.now() - startedAt, startedAt };
+      return {
+        envelope: {
+          ok: false,
+          error: { code, message: "MCP result exceeds the remaining mcpScript intermediate transfer budget (16 MiB per script). Request less data or use a new script." }
+        }
       };
     }
     calls[index] = { operation: "call", path, ok: true, durationMs: Date.now() - startedAt, startedAt };
-    return {
+    return { dataJson };
+  };
+  const jevSettings = validateJevSettings(state.config.settings?.jev);
+  let evaluationAttempts = 0;
+  let evaluationBytes = 0;
+  let evaluationTokensRemaining = jevSettings.maxEvaluationTokensPerScript;
+  const tokenBudgetExhausted = () => ({ ok: false, error: { code: "budget_exhausted", message: "Jev evaluation token budget exhausted." } });
+  const chargeEvaluationTokens = (envelope) => {
+    if (!envelope.ok)
+      return envelope;
+    const used = envelope.data.usage.inputTokens + envelope.data.usage.outputTokens;
+    if (!Number.isSafeInteger(used) || used < 0 || used > evaluationTokensRemaining) {
+      evaluationTokensRemaining = 0;
+      return tokenBudgetExhausted();
+    }
+    evaluationTokensRemaining -= used;
+    return envelope;
+  };
+  const admitEvaluation = (input) => {
+    if (++evaluationAttempts > jevSettings.maxEvaluationsPerScript) {
+      return { ok: false, error: { code: "budget_exhausted", message: "Jev evaluation count budget exhausted." } };
+    }
+    if (evaluationTokensRemaining === 0)
+      return tokenBudgetExhausted();
+    let serialized;
+    try {
+      serialized = JSON.stringify(input);
+    } catch {
+      return { ok: false, error: { code: "invalid_request", message: "Invalid Jev evaluation request." } };
+    }
+    if (serialized === undefined)
+      return { ok: false, error: { code: "invalid_request", message: "Invalid Jev evaluation request." } };
+    const bytes = Buffer.byteLength(serialized, "utf8");
+    if (bytes > jevSettings.maxEvaluationBytesPerScript - evaluationBytes) {
+      return { ok: false, error: { code: "budget_exhausted", message: "Jev evaluation byte budget exhausted." } };
+    }
+    evaluationBytes += bytes;
+    return;
+  };
+  const evaluate = async (input) => {
+    const startedAt = Date.now();
+    const index = calls.push({ operation: "evaluate", ok: false, error: "incomplete", durationMs: 0, startedAt }) - 1;
+    let envelope;
+    const rejected = admitEvaluation(input);
+    if (rejected) {
+      envelope = rejected;
+    } else {
+      envelope = await jevEvaluator(state, input, {
+        purpose: "script",
+        ...callSignal ? { signal: callSignal } : {},
+        ...observedSources.size > 0 ? { observedSources: [...observedSources] } : {}
+      });
+    }
+    envelope = chargeEvaluationTokens(envelope);
+    throwIfAborted(callSignal);
+    if (!reserveIntermediateBytes(JSON.stringify(envelope))) {
+      envelope = { ok: false, error: { code: "budget_exhausted", message: "Jev evaluation exceeds the remaining mcpScript intermediate transfer budget (16 MiB per script)." } };
+    }
+    calls[index] = envelope.ok ? {
+      operation: "evaluate",
       ok: true,
-      data: details.mcpResult !== undefined ? details.mcpResult : textFromContent(result.content)
-    };
+      model: envelope.data.model,
+      inputTokens: envelope.data.usage.inputTokens,
+      outputTokens: envelope.data.usage.outputTokens,
+      durationMs: Date.now() - startedAt,
+      startedAt
+    } : { operation: "evaluate", ok: false, error: envelope.error.code, durationMs: Date.now() - startedAt, startedAt };
+    return { envelope };
   };
-  const searchTools = (input) => {
+  const searchTools = async (input) => {
     const startedAt = Date.now();
     const query = typeof input?.query === "string" ? input.query : "";
+    const index = calls.push({ operation: "search", query, ok: false, error: "incomplete", durationMs: 0, startedAt }) - 1;
     let error;
     try {
-      if (query.trim() === "") {
+      if (input?.searchMode !== undefined && input.searchMode !== "lexical" && input.searchMode !== "semantic") {
+        error = "invalid_search_mode";
+        return { items: [], total: 0, hasMore: false, nextOffset: null, error: { code: "invalid_search_mode", message: "Search mode must be lexical or semantic." } };
+      }
+      if (query.trim() === "" && input?.searchMode !== "semantic") {
         return { items: [], total: 0, hasMore: false, nextOffset: null };
       }
       const server = typeof input?.server === "string" ? input.server : undefined;
       const limit = typeof input?.limit === "number" ? input.limit : 12;
       const offset = typeof input?.offset === "number" ? input.offset : 0;
-      const page = paginate(rankToolMatches(state, query, server), offset, limit);
+      const searchMode = input?.searchMode === "semantic" ? "semantic" : "lexical";
+      if (searchMode === "semantic" && input?.regex === true) {
+        error = "invalid_search_mode";
+        return { items: [], total: 0, hasMore: false, nextOffset: null, error: { code: "invalid_search_mode", message: "Semantic search cannot be combined with regex search." } };
+      }
+      const semantic = searchMode === "semantic" ? await semanticSearch(state, query, server, callSignal, async (semanticState, semanticInput, options) => {
+        const rejected = admitEvaluation(semanticInput);
+        if (rejected)
+          return rejected;
+        const envelope = await (semanticEvaluator ?? evaluateJev)(semanticState, semanticInput, options);
+        return chargeEvaluationTokens(envelope);
+      }, [...observedSources]) : undefined;
+      if (semantic && !semantic.ok) {
+        error = semantic.error.code;
+        return { items: [], total: 0, hasMore: false, nextOffset: null, error: semantic.error };
+      }
+      const page = paginate(semantic?.matches ?? rankToolMatches(state, query, server), offset, limit);
       return {
         ...page,
         items: page.items.map(({ server: matchServer, tool, score }) => ({
@@ -137,13 +257,14 @@ export async function runMcpScript(state, code, timeoutMs = DEFAULT_MCP_SCRIPT_T
           server: matchServer,
           ...tool.description ? { description: tool.description } : {},
           score
-        }))
+        })),
+        ...semantic ? { backend: semantic.backend } : {}
       };
     } catch (caught) {
       error = caught;
       throw caught;
     } finally {
-      calls.push(error === undefined ? { operation: "search", query, ok: true, durationMs: Date.now() - startedAt, startedAt } : { operation: "search", query, ok: false, error: error instanceof Error ? error.message : String(error), durationMs: Date.now() - startedAt, startedAt });
+      calls[index] = error === undefined ? { operation: "search", query, ok: true, durationMs: Date.now() - startedAt, startedAt } : { operation: "search", query, ok: false, error: error instanceof Error ? error.message : String(error), durationMs: Date.now() - startedAt, startedAt };
     }
   };
   const describeTool = (input) => {
@@ -157,13 +278,19 @@ export async function runMcpScript(state, code, timeoutMs = DEFAULT_MCP_SCRIPT_T
         const tool = findToolByName(metadata, path);
         if (!tool)
           continue;
-        const inputTypeScript = tool.inputSchema ? renderTsShape(tool.inputSchema) ?? formatSchema(tool.inputSchema) : null;
+        const inputShape = tool.inputSchema ? renderTsShape(tool.inputSchema) : null;
+        const inputTypeScript = inputShape ?? (tool.inputSchema ? formatSchema(tool.inputSchema) : null);
         return {
           path: tool.name,
           name: tool.originalName,
           server,
           ...tool.description ? { description: tool.description } : {},
-          ...inputTypeScript ? { inputTypeScript } : {}
+          ...inputTypeScript ? { inputTypeScript } : {},
+          ...inputShape && hasSchemaDescriptions(tool.inputSchema) ? { inputGuidance: formatSchema(tool.inputSchema) } : {},
+          ...tool.outputSchema !== undefined ? {
+            outputSchemaTarget: "data.structuredContent",
+            outputSchema: tool.outputSchema
+          } : {}
         };
       }
       const suggestions = path ? rankSuggestions(state, path, 5) : [];
@@ -221,15 +348,19 @@ export async function runMcpScript(state, code, timeoutMs = DEFAULT_MCP_SCRIPT_T
           return;
         }
         (async () => {
-          let envelope;
+          let payload;
           if (message.type === "call") {
-            envelope = await callTool(message.path, message.args);
+            payload = await callTool(message.path, message.args);
+          } else if (message.type === "evaluate") {
+            payload = await evaluate(message.input);
           } else if (message.type === "search") {
-            envelope = searchTools(message.input);
+            payload = { envelope: await searchTools(message.input) };
           } else {
-            envelope = describeTool(message.input);
+            payload = { envelope: describeTool(message.input) };
           }
-          const response = { type: "result", id: message.id, envelope };
+          if (completed || callSignal?.aborted)
+            return;
+          const response = { type: "result", id: message.id, ...payload };
           activeWorker.postMessage(response);
         })().catch(reject);
       });

package/extensions/dm-mcp-adapter/mcp-install.js

@@ -0,0 +1,40 @@
+const SERVER_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
+function isLoopbackHostname(hostname) {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]" || hostname === "::1";
+}
+function deriveServerName(url) {
+  const hostname = url.hostname.replace(/^\[|\]$/g, "");
+  const firstLabel = isLoopbackHostname(url.hostname) ? "local-mcp" : hostname.split(".")[0];
+  const normalized = (firstLabel || "mcp").toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+  return normalized || "mcp";
+}
+export function normalizeMcpInstallRequest(request) {
+  if (typeof request.url !== "string" || request.url.trim() === "") {
+    throw new Error("MCP install requires a non-empty URL");
+  }
+  let parsed;
+  try {
+    parsed = new URL(request.url.trim());
+  } catch (error) {
+    throw new Error("MCP install URL must be an absolute URL", { cause: error });
+  }
+  if (parsed.username || parsed.password)
+    throw new Error("MCP install URL must not contain credentials");
+  if (parsed.hash)
+    throw new Error("MCP install URL must not contain a fragment");
+  if (parsed.protocol !== "https:" && !(parsed.protocol === "http:" && isLoopbackHostname(parsed.hostname))) {
+    throw new Error("MCP install URL must use HTTPS, except for loopback HTTP servers");
+  }
+  const serverName = request.serverName?.trim() || deriveServerName(parsed);
+  if (!SERVER_NAME_PATTERN.test(serverName)) {
+    throw new Error("MCP server name must be 1-64 letters, numbers, underscores, or hyphens and start with a letter or number");
+  }
+  return { url: parsed.toString(), serverName };
+}
+export function canonicalMcpServerUrl(value) {
+  try {
+    return new URL(value).toString();
+  } catch {
+    return;
+  }
+}

package/extensions/dm-mcp-adapter/mcp-oauth-provider.js

@@ -7,9 +7,11 @@ import {
   updateClientInfo,
   clearAllCredentials,
   clearCodeVerifier,
-  invalidateAuthEntryCache
+  invalidateAuthEntryCache,
+  captureOAuthAuthority
 } from "./mcp-auth.js";
 import { OAuthMetadataSchema, OpenIdProviderDiscoveryMetadataSchema } from "@modelcontextprotocol/core";
+import { createOAuthFetch } from "./mcp-auth-fetch.js";
 import { resolveCommandSecret } from "./utils.js";
 import { getAppClientUri, getAppName } from "./agent-dir.js";
 function defaultClientName() {
@@ -127,10 +129,9 @@ function validateConfiguredIssuer(metadataUrl, issuer, skipIssuerValidation) {
     throw new Error(`OAuth authorization-server metadata issuer does not match authServerMetadataUrl origin: expected ${new URL(metadataUrl).origin}`);
   }
 }
-async function loadConfiguredDiscoveryState(metadataUrl, serverUrl, skipIssuerValidation, signal) {
-  const response = await fetch(metadataUrl, {
-    headers: { accept: "application/json" },
-    ...signal !== undefined ? { signal } : {}
+async function loadConfiguredDiscoveryState(metadataUrl, serverUrl, skipIssuerValidation, fetchFn) {
+  const response = await fetchFn(metadataUrl, {
+    headers: { accept: "application/json" }
   });
   if (!response.ok) {
     await response.text().catch(() => {});
@@ -156,7 +157,9 @@ export class McpOAuthProvider {
   callbacks;
   storageOptions;
   runtimeSignal;
+  clientMetadataUrl;
   redirectUrlSnapshot;
+  authFetch;
   active = true;
   flowClientInfo;
   flowCodeVerifier;
@@ -165,19 +168,30 @@ export class McpOAuthProvider {
   flowState;
   invalidatedAccessToken;
   invalidatedClientId;
+  staleRedirectClientId;
   lastObservedClientId;
   lastSavedAccessToken;
   pendingAuthAccessToken;
-  constructor(serverName, serverUrl, config, callbacks, storageOptions = {}, runtimeSignal, initialState) {
+  assertAuthority;
+  constructor(serverName, serverUrl, config, callbacks, storageOptions = {}, runtimeSignal, initialState, authority) {
     this.serverName = serverName;
     this.serverUrl = serverUrl;
     this.config = config;
     this.callbacks = callbacks;
     this.storageOptions = storageOptions;
     this.runtimeSignal = runtimeSignal;
+    this.assertAuthority = authority ?? captureOAuthAuthority(serverName);
+    this.assertAuthority();
+    if (config.clientId === undefined && config.clientMetadataUrl !== undefined) {
+      this.clientMetadataUrl = config.clientMetadataUrl;
+    }
+    this.authFetch = createOAuthFetch(serverUrl, undefined, runtimeSignal);
     this.flowState = initialState;
     this.redirectUrlSnapshot = config.grantType === "client_credentials" ? undefined : config.redirectUri ?? `http://localhost:${getOAuthCallbackPort()}${getOAuthCallbackPath()}`;
   }
+  setAuthFetch(fetchFn) {
+    this.authFetch = fetchFn;
+  }
   get usesClientCredentials() {
     return this.config.grantType === "client_credentials";
   }
@@ -188,6 +202,7 @@ export class McpOAuthProvider {
     this.active = false;
     this.invalidatedAccessToken = undefined;
     this.invalidatedClientId = undefined;
+    this.staleRedirectClientId = undefined;
     this.lastObservedClientId = undefined;
     this.lastSavedAccessToken = undefined;
     this.pendingAuthAccessToken = undefined;
@@ -207,7 +222,9 @@ export class McpOAuthProvider {
   throwIfInactive() {
     if (!this.active)
       throw new Error("OAuth flow is no longer active");
+    this.assertAuthority();
     this.runtimeSignal?.throwIfAborted();
+    this.authFetch.throwIfHeaderResolutionFailed();
   }
   get redirectUrl() {
     return this.redirectUrlSnapshot;
@@ -242,15 +259,18 @@ export class McpOAuthProvider {
     };
   }
   async clientInformation() {
+    this.throwIfInactive();
     if (this.invalidatedClientId !== undefined) {
       invalidateAuthEntryCache(this.serverName);
     }
     const issuer = this.discoveredIssuer;
     const stored = await getAuthForUrl(this.serverName, this.serverUrl, this.storageOptions);
+    this.throwIfInactive();
     this.assertStoredIssuerBindings(stored, issuer);
     if (this.config.clientId) {
       const storedClient = stored?.clientInfo?.clientId === this.config.clientId ? stored.clientInfo : undefined;
       if (issuer && (storedClient?.issuer !== issuer || storedClient.configPreRegistered !== true)) {
+        this.throwIfInactive();
         updateClientInfo(this.serverName, { clientId: this.config.clientId, issuer, configPreRegistered: true }, this.serverUrl, this.storageOptions);
       }
       const clientSecret = this.config.clientSecret?.startsWith("!") ? resolveCommandSecret(this.config.clientSecret, `MCP server "${this.serverName}" OAuth clientSecret`) : this.config.clientSecret;
@@ -263,10 +283,21 @@ export class McpOAuthProvider {
     const clientInfo = this.flowClientInfo ?? stored?.clientInfo;
     if (clientInfo?.clientId === this.invalidatedClientId)
       return;
+    const clientMetadataUrl = this.clientMetadataUrl;
+    const supportsClientMetadataDocument = this.flowDiscoveryState?.authorizationServerMetadata?.client_id_metadata_document_supported;
+    if (clientMetadataUrl !== undefined && supportsClientMetadataDocument !== undefined) {
+      if (supportsClientMetadataDocument === true && clientInfo?.clientId !== clientMetadataUrl && (stored?.tokens?.refreshToken === undefined || this.invalidatedAccessToken !== undefined)) {
+        return;
+      }
+      if (supportsClientMetadataDocument !== true && clientInfo?.clientId === clientMetadataUrl) {
+        return;
+      }
+    }
     if (clientInfo) {
       this.invalidatedClientId = undefined;
+      const isConfiguredCimd = clientMetadataUrl !== undefined && clientInfo.clientId === clientMetadataUrl;
       const isConfigStub = clientInfo.configPreRegistered === true || clientInfo.clientSecret === undefined && clientInfo.clientIdIssuedAt === undefined && clientInfo.clientSecretExpiresAt === undefined && clientInfo.redirectUris === undefined;
-      if (isConfigStub) {
+      if (isConfigStub && !isConfiguredCimd) {
         return;
       }
       if (clientInfo.clientSecretExpiresAt && clientInfo.clientSecretExpiresAt < Date.now() / 1000) {
@@ -278,8 +309,11 @@ export class McpOAuthProvider {
       if (issuer && clientInfo.issuer === undefined) {
         clientInfo.issuer = issuer;
         this.flowClientInfo = clientInfo;
+        this.throwIfInactive();
         updateClientInfo(this.serverName, clientInfo, this.serverUrl, this.storageOptions);
       }
+      const redirectUriIsStale = this.redirectUrl !== undefined && (!Array.isArray(clientInfo.redirectUris) || !clientInfo.redirectUris.includes(this.redirectUrl));
+      this.staleRedirectClientId = redirectUriIsStale ? clientInfo.clientId : undefined;
       this.lastObservedClientId = clientInfo.clientId;
       return {
         client_id: clientInfo.clientId,
@@ -318,10 +352,12 @@ export class McpOAuthProvider {
     updateClientInfo(this.serverName, clientInfo, this.serverUrl, this.storageOptions);
   }
   async tokens(ctx) {
+    this.throwIfInactive();
     if (this.invalidatedAccessToken !== undefined) {
       invalidateAuthEntryCache(this.serverName);
     }
     const entry = await getAuthForUrl(this.serverName, this.serverUrl, this.storageOptions);
+    this.throwIfInactive();
     if (!entry?.tokens || entry.tokens.accessToken === this.invalidatedAccessToken)
       return;
     this.invalidatedAccessToken = undefined;
@@ -329,6 +365,7 @@ export class McpOAuthProvider {
     this.assertStoredIssuerBindings(entry, issuer);
     if (issuer && entry.tokens.issuer === undefined) {
       entry.tokens.issuer = issuer;
+      this.throwIfInactive();
       updateTokens(this.serverName, entry.tokens, this.serverUrl, this.storageOptions);
     }
     if (ctx !== undefined) {
@@ -382,8 +419,11 @@ export class McpOAuthProvider {
   async discoveryState() {
     this.throwIfInactive();
     if (!this.flowDiscoveryState && this.config.authServerMetadataUrl !== undefined) {
-      this.flowDiscoveryState = await loadConfiguredDiscoveryState(this.config.authServerMetadataUrl, this.serverUrl, this.config.skipIssuerMetadataValidation === true, this.runtimeSignal);
+      const discoveryState = await loadConfiguredDiscoveryState(this.config.authServerMetadataUrl, this.serverUrl, this.config.skipIssuerMetadataValidation === true, this.authFetch);
+      this.throwIfInactive();
+      this.flowDiscoveryState = discoveryState;
     }
+    this.throwIfInactive();
     return this.flowDiscoveryState ? structuredClone(this.flowDiscoveryState) : undefined;
   }
   async saveState(state) {
@@ -411,6 +451,7 @@ export class McpOAuthProvider {
         this.flowState = undefined;
         this.invalidatedAccessToken = undefined;
         this.invalidatedClientId = undefined;
+        this.staleRedirectClientId = undefined;
         this.lastObservedClientId = undefined;
         this.lastSavedAccessToken = undefined;
         this.pendingAuthAccessToken = undefined;
@@ -426,6 +467,9 @@ export class McpOAuthProvider {
         this.invalidatedAccessToken = this.pendingAuthAccessToken ?? this.lastSavedAccessToken;
         this.lastSavedAccessToken = undefined;
         this.pendingAuthAccessToken = undefined;
+        if (this.staleRedirectClientId !== undefined) {
+          this.invalidatedClientId = this.staleRedirectClientId;
+        }
         invalidateAuthEntryCache(this.serverName);
         break;
       case "verifier":