mixdog 1.4.1 → 1.4.3

package/src/runtime/agent/orchestrator/mcp/client-transport.mjs

@@ -8,24 +8,32 @@ import { createMcpOAuth } from './oauth.mjs';
 import { mcpOAuthClientFor, mcpOAuthDisplayName } from './oauth-client.mjs';
 import { googleMcpService, withGoogleMcp } from '../../../connectors/google-mcp.mjs';
 import { gmailAppPasswordService, withGmailAppPasswordMcp } from '../../../connectors/gmail-app-password.mjs';
-import { connectorAccountRequest, withConnectorAccountsMcp } from '../../../connectors/connector-accounts-mcp.mjs';
+import { withConnectorAccountsMcp } from '../../../connectors/connector-accounts-mcp.mjs';
 import {
+  connectorAccountEnabled,
+  connectorAccountId,
   connectorAccountsOf,
   connectorLiveAccountServers,
   gmailAppPasswordAccount,
 } from '../../../shared/connector-catalog.mjs';
-import { isMcpOAuthReauthenticationRequired } from './oauth.mjs';
+import { runAbortable } from '../../../shared/abort-race.mjs';
+import { isMcpOAuthReauthenticationRequired, storedMcpOAuthIdentity } from './oauth.mjs';
+import { shutdownStdioChild } from './child-tree.mjs';
+import { listAllMcpTools } from './client-handshake.mjs';
 import {
   AUTO_DETECT_PORTS,
+  MCP_MAX_TIMER_MS,
   expandEnvVars,
   findMissingMcpEnvVars,
   mcpUrlForLog,
   normalizeMcpTransportUrl,
   resolveMcpHttpHeaders,
+  resolveMcpOAuthCredentialKey,
   resolveMcpOAuthUrl,
   resolveMcpStdioEnvironment,
   resolveMcpTransportKind,
   scrubMcpConnectionMessage,
+  scrubMcpSecrets,
 } from './client-config.mjs';
 
 /**
@@ -76,57 +84,142 @@ export function hasConfiguredMcpAuth(cfg) {
   );
 }
 
-/** One account of a multi-account connector server (connector-catalog.mjs
- *  connectorAccountServer) as connector-accounts-mcp.mjs calls it: through
- *  the transport the account had as a server of its own — its app-password
- *  header, or its own non-interactive OAuth sign-in (refreshed as needed; a
- *  new sign-in goes through 계정 바꾸기, never through a tool call). */
-function connectorAccountClient(serverName, accountCfg, oauthOptions) {
-  const base = { name: accountCfg.name, email: '', appPassword: false, close() {} };
-  let url;
+// A stdio account (Postgres) runs one process per account config, shared by
+// the connector server of every scope like any stdio server (client.mjs):
+// account config → its connection, which closes with its last holder.
+const sharedAccountConnections = new Map();
+
+/** Close one account connection: a stdio child with its whole process tree. */
+async function closeAccountConnection(connection) {
+  connection.dead = true;
+  if (connection.transport?._process) await shutdownStdioChild(connection.transport).catch(() => {});
+  await connection.client.close().catch(() => {});
+}
+
+/** Whether a call failure is the account server's own JSON-RPC answer: its
+ *  connection stays. */
+const answeredError = (error) => error?.name === 'McpError' && error.code !== -32000;
+
+/** The address a remote account is signed in as, '' when none is known. */
+function signedInAs(accountCfg) {
   try {
-    url = resolveMcpOAuthUrl(accountCfg);
-    if (hasConfiguredMcpAuth(accountCfg)) {
-      const email = gmailAppPasswordAccount(accountCfg);
-      const fetchImpl = gmailAppPasswordService(url) ? withGmailAppPasswordMcp() : fetch;
-      return {
-        ...base,
-        email,
-        appPassword: Boolean(email),
-        request: connectorAccountRequest(url, fetchImpl, resolveMcpHttpHeaders(accountCfg)),
-      };
+    const url = resolveMcpOAuthUrl(accountCfg);
+    if (!url || hasConfiguredMcpAuth(accountCfg)) return '';
+    return storedMcpOAuthIdentity(url, resolveMcpOAuthCredentialKey(accountCfg))?.account || '';
+  } catch {
+    return '';
+  }
+}
+
+/** One account of a connector server (connector-catalog.mjs
+ *  connectorAccountServer) as connector-accounts-mcp.mjs calls it: its own
+ *  MCP connection through the transport it had as a server of its own — its
+ *  key header, its app password, its local command, or its own
+ *  non-interactive OAuth sign-in (refreshed as needed; a new sign-in goes
+ *  through 계정 바꾸기, never through a tool call). Connected on first use and
+ *  again after its connection failed. */
+function connectorAccountClient(serverName, accountCfg, { sdk, log, oauthOptions }) {
+  const { interactive: _interactive, ...ownOAuth } = oauthOptions || {};
+  const address = gmailAppPasswordAccount(accountCfg);
+  const shareKey = resolveMcpTransportKind(accountCfg) === 'stdio' ? JSON.stringify(accountCfg) : null;
+  const secretsOf = (connection) => connection?.transport?.oauth?.secrets() || [];
+  const accountError = (error, connection) => {
+    if (isMcpOAuthReauthenticationRequired(error)) {
+      return Object.assign(new Error('Sign-in required; sign this account in again in Connectors.'), {
+        authRequired: true,
+      });
     }
-    const oauth = createMcpOAuth({
-      url,
-      serverName: mcpOAuthDisplayName(accountCfg, serverName),
-      oauthClient: mcpOAuthClientFor(accountCfg, url),
-      ...(oauthOptions?.fetchImpl ? { fetchImpl: oauthOptions.fetchImpl } : {}),
-      ...(googleMcpService(url) ? { fetchImpl: withGoogleMcp(oauthOptions?.fetchImpl) } : {}),
-    });
-    const send = connectorAccountRequest(url, (input, init) => oauth.fetch(input, init));
-    return {
-      ...base,
-      async request(message, options) {
-        try {
-          return await send(message, options);
-        } catch (error) {
-          const reason = scrubMcpConnectionMessage(error?.message || String(error), accountCfg);
-          const scrubbed = new Error(
-            isMcpOAuthReauthenticationRequired(error)
-              ? 'Sign-in required; sign this account in again in Connectors.'
-              : reason
-          );
-          if (isMcpOAuthReauthenticationRequired(error)) scrubbed.authRequired = true;
-          throw scrubbed;
-        }
-      },
-      close: () => oauth.close(),
+    const reason = scrubMcpConnectionMessage(error?.message || String(error), accountCfg, secretsOf(connection));
+    return new Error(appendMcpStderrTail(reason, connection?.stderrTail?.() || ''));
+  };
+  const open = () => {
+    const connection = { users: 0, dead: false };
+    try {
+      const made = createMcpTransport({ name: accountCfg.name, cfg: accountCfg, sdk, log, oauthOptions: ownOAuth });
+      connection.transport = made.transport;
+      connection.stderrTail = made.stderrTail;
+    } catch (error) {
+      // A broken account (no sign-in client, an invalid address) stays listed with why.
+      connection.dead = true;
+      connection.client = { close: async () => {} };
+      connection.ready = Promise.reject(error);
+      connection.ready.catch(() => {});
+      return connection;
+    }
+    const client = new sdk.Client({ name: `mixdog-agent/${serverName}`, version: '1.0.0' });
+    connection.client = client;
+    const retire = () => {
+      connection.dead = true;
+      if (shareKey && sharedAccountConnections.get(shareKey) === connection) sharedAccountConnections.delete(shareKey);
     };
-  } catch (error) {
-    // A broken account (no sign-in client, an invalid address) stays listed with why.
-    const failed = new Error(error?.message || String(error));
-    return { ...base, request: async () => Promise.reject(failed) };
-  }
+    client.onclose = retire;
+    connection.retire = retire;
+    connection.ready = (async () => {
+      await client.connect(connection.transport, { timeout: MCP_MAX_TIMER_MS });
+      const tools = client.getServerCapabilities()?.tools
+        ? (await listAllMcpTools(client, { timeout: MCP_MAX_TIMER_MS }))?.tools
+        : [];
+      if (!Array.isArray(tools)) throw new Error('The account listed its tools in an invalid shape');
+      return { instructions: client.getInstructions() || '', tools };
+    })();
+    connection.ready.catch(() => {
+      retire();
+      void closeAccountConnection(connection);
+    });
+    return connection;
+  };
+  let held = null;
+  const release = () => {
+    const connection = held;
+    held = null;
+    if (!connection || --connection.users > 0) return;
+    connection.retire?.();
+    void closeAccountConnection(connection);
+  };
+  const acquire = () => {
+    if (held && !held.dead) return held;
+    release();
+    let connection = shareKey ? sharedAccountConnections.get(shareKey) : null;
+    if (!connection || connection.dead) {
+      connection = open();
+      if (shareKey && !connection.dead) sharedAccountConnections.set(shareKey, connection);
+    }
+    connection.users += 1;
+    held = connection;
+    return connection;
+  };
+  return {
+    name: accountCfg.name,
+    email: address || signedInAs(accountCfg),
+    async connect(signal) {
+      const connection = acquire();
+      try {
+        return await runAbortable(signal, () => connection.ready);
+      } catch (error) {
+        throw accountError(error, connection);
+      }
+    },
+    async callTool(params, { signal, onprogress } = {}) {
+      const connection = acquire();
+      try {
+        await runAbortable(signal, () => connection.ready);
+        // The caller's deadline governs (it resets on the progress passed up).
+        const result = await connection.client.callTool(params, undefined, {
+          signal,
+          timeout: MCP_MAX_TIMER_MS,
+          ...(onprogress ? { onprogress } : {}),
+        });
+        return scrubMcpSecrets(result, secretsOf(connection));
+      } catch (error) {
+        const failed = accountError(error, connection);
+        if (answeredError(error)) return { content: [{ type: 'text', text: failed.message }], isError: true };
+        // A connection a call failed on is opened again for the next call.
+        if (!signal?.aborted) connection.retire?.();
+        throw failed;
+      }
+    },
+    close: release,
+  };
 }
 
 // The SDK's WebSocket transport opens its socket without a way to set request
@@ -177,13 +270,19 @@ function missingEnvWarnings(name, cfg, strictEnv, log) {
   return warnings;
 }
 
-// A multi-account connector: one server, every account behind it; closing the
-// transport closes every account client.
-function connectorAccountsTransport({ name, cfg, Transport, url, accountServers, oauthOptions, log }) {
-  const accounts = accountServers.map((accountCfg) => connectorAccountClient(name, accountCfg, oauthOptions));
-  const transport = new Transport(new URL(url), {
-    fetch: withConnectorAccountsMcp({ connector: cfg.connector, accounts }),
+// A connector server: one server, every account behind it (its account choice
+// on `connectorAccounts`); closing the transport closes every account client.
+function connectorAccountsTransport({ name, cfg, Transport, url, accountServers, sdk, oauthOptions, log }) {
+  // `accountServers` are the switched-on stored accounts, in order.
+  const stored = connectorAccountsOf(cfg).filter(connectorAccountEnabled);
+  const accounts = accountServers.map((accountCfg, index) => {
+    const account = connectorAccountClient(name, accountCfg, { sdk, log, oauthOptions });
+    account.id = connectorAccountId(cfg, stored[index]);
+    return account;
   });
+  const fetchImpl = withConnectorAccountsMcp({ connector: cfg.connector, accounts });
+  const transport = new Transport(new URL(url), { fetch: fetchImpl });
+  transport.connectorAccounts = fetchImpl.connectorAccounts;
   const close = transport.close.bind(transport);
   transport.close = async () => {
     for (const account of accounts) account.close();
@@ -204,6 +303,7 @@ function remoteHttpTransport({ name, cfg, kind, Transport, url, oauthOptions, lo
   if (!hasConfiguredMcpAuth(cfg)) {
     oauth = createMcpOAuth({
       url,
+      credentialKey: resolveMcpOAuthCredentialKey(cfg),
       serverName: mcpOAuthDisplayName(cfg, name),
       oauthClient: mcpOAuthClientFor(cfg, url),
       ...oauthOptions,
@@ -291,7 +391,7 @@ export function createMcpTransport({ name, cfg, sdk, log, strictEnv, oauthOption
       throw new Error(`Every account of "${name}" is disabled`);
     }
     const transport = accountServers.length
-      ? connectorAccountsTransport({ name, cfg, Transport, url, accountServers, oauthOptions, log })
+      ? connectorAccountsTransport({ name, cfg, Transport, url, accountServers, sdk, oauthOptions, log })
       : remoteHttpTransport({ name, cfg, kind, Transport, url, oauthOptions, log });
     return { transport, autoDetectAdvert: null, stderrTail: noStderrTail, warnings };
   }

package/src/runtime/agent/orchestrator/mcp/client.mjs

@@ -25,6 +25,7 @@ import { currentToolExecutionOwner } from '../../../shared/tool-execution-owner.
 import { positiveInt } from '../../../shared/numbers.mjs';
 import {
   providerSafeMcpToolName,
+  resolveMcpOAuthCredentialKey,
   resolveMcpOAuthUrl,
   resolveMcpRequestTimeouts,
   resolveMcpTransportKind,
@@ -39,6 +40,7 @@ import { mcpOAuthClientFor, mcpOAuthDisplayName } from './oauth-client.mjs';
 import { googleMcpService, withGoogleMcp } from '../../../connectors/google-mcp.mjs';
 import { gmailAppPasswordService } from '../../../connectors/gmail-app-password.mjs';
 import { connectorLiveAccountServers } from '../../../shared/connector-catalog.mjs';
+import { CONVERSATION_META } from '../../../connectors/connector-accounts-mcp.mjs';
 import {
   clearMcpOAuth,
   commitMcpOAuthSwitch,
@@ -52,8 +54,9 @@ import {
 export { probeMcpServerAuth } from './oauth-probe.mjs';
 
 // Config interpretation (transport kind, URL policy, env expansion, headers,
-// timeouts, log scrubbing) lives in client-config.mjs; re-exported so every
-// existing importer resolves unchanged.
+// timeouts, log scrubbing) lives in client-config.mjs; the names importers
+// use (including through namespace loads such as boot.mcpClient) are
+// re-exported here.
 export {
   normalizeMcpTransportUrl,
   mcpUrlForLog,
@@ -62,9 +65,6 @@ export {
   resolveMcpHttpHeaders,
   resolveMcpTransportKind,
   resolveMcpStartupTimeoutMs,
-  resolveMcpCallTimeoutMs,
-  resolveMcpMaxTotalTimeoutMs,
-  resolveMcpRequestTimeouts,
 } from './client-config.mjs';
 const servers = new Map();
 const reconnects = createKeyedSingleflight();
@@ -503,10 +503,15 @@ export async function executeMcpTool(name, args, options = {}) {
   const serverName = server.name;
   const toolName = definition?.mcpToolName || match[2];
   const callSignal = options?.signal || null;
+  // A connector server's call names the conversation it is made in: its
+  // account default, and the account it makes the last used.
+  const conversation = String(options?.conversation || '').trim();
+  const metaFor = (target) =>
+    conversation && target.transport?.connectorAccounts ? { [CONVERSATION_META]: conversation } : undefined;
   const dispatch = (target) =>
     definition?.mcpOperation
       ? _callMcpFeatureWithTimeout(target, definition.mcpOperation, args, callSignal)
-      : _callToolWithTimeout(target, toolName, args, callSignal);
+      : _callToolWithTimeout(target, toolName, args, callSignal, metaFor(target));
   let retryServer = null;
   const secrets = () => oauthSecrets(server.transport, retryServer?.transport);
   const gate = callAdmissionFor(server);
@@ -999,7 +1004,7 @@ export function raceMcpAbort(promise, signal, message) {
   });
 }
 
-async function _callToolWithTimeout(server, toolName, args, signal = null) {
+async function _callToolWithTimeout(server, toolName, args, signal = null, meta = undefined) {
   // The request's signal goes INTO the SDK: an aborted caller (or our own
   // timeout) cancels the live JSON-RPC request (notifications/cancelled)
   // instead of merely walking away from it. The abort race additionally frees
@@ -1008,7 +1013,8 @@ async function _callToolWithTimeout(server, toolName, args, signal = null) {
   return runMcpRequest(
     server,
     signal,
-    (options) => server.client.callTool({ name: toolName, arguments: args }, undefined, options),
+    (options) =>
+      server.client.callTool({ name: toolName, arguments: args, ...(meta ? { _meta: meta } : {}) }, undefined, options),
     {
       abortMessage: `MCP tool call aborted (server="${server?.name}", tool="${toolName}")`,
       timeoutMessage: (ms) =>
@@ -1119,6 +1125,24 @@ export function isMcpTool(name) {
 export function isRegisteredMcpTool(name, scopeId = DEFAULT_MCP_SCOPE_ID) {
   return Boolean(resolveMcpToolTarget(scopeId, name)?.definition);
 }
+/**
+ * The account (`{ name, label }`: its unique name, which binds a call to it,
+ * and what it is shown as) a call of the prefixed tool `name` with `args`
+ * would use on its connector server, made in `conversation`
+ * (connectors/connector-accounts-mcp.mjs): the one `args.account` names, else
+ * the one used last. Null when the tool's server holds no accounts. Throws the
+ * refusal (usable accounts listed) when that account cannot be used.
+ */
+export function resolveMcpToolAccount(name, args, { scopeId = DEFAULT_MCP_SCOPE_ID, conversation = '' } = {}) {
+  const target = resolveMcpToolTarget(normalizeMcpScopeId(scopeId), name);
+  const accounts = target?.server?.transport?.connectorAccounts;
+  if (!accounts || target.definition?.mcpOperation) return null;
+  return accounts.choose({
+    tool: target.definition?.mcpToolName || MCP_TOOL_NAME_RE.exec(name)?.[2],
+    wanted: args?.account,
+    conversation: String(conversation || '').trim(),
+  });
+}
 /** True when the prefixed name is `read_email` of a server whose every
  *  endpoint Mixdog answers in-process (the Gmail app-password connector,
  *  alone or behind the multi-account server): its result is a mail as the
@@ -1272,18 +1296,19 @@ export function isMcpLoginPending(name, options = {}) {
  * for servers that never use MCP OAuth.
  */
 export function getMcpServerOAuthState(cfg) {
-  let url;
+  let key;
   try {
-    url = resolveMcpOAuthUrl(cfg);
+    key = resolveMcpOAuthCredentialKey(cfg);
   } catch {
     return null;
   }
-  if (!url || hasConfiguredMcpAuth(cfg)) return null;
-  const signedIn = hasStoredMcpOAuthTokens(url);
+  if (!key || hasConfiguredMcpAuth(cfg)) return null;
+  const url = resolveMcpOAuthUrl(cfg);
+  const signedIn = hasStoredMcpOAuthTokens(url, key);
   if (!signedIn) return { signedIn };
   // Who it is signed in as (never guessed: empty when the server named nobody)
   // and whether 계정 바꾸기 can make the provider show its account choice.
-  const who = storedMcpOAuthIdentity(url);
+  const who = storedMcpOAuthIdentity(url, key);
   return {
     signedIn,
     account: typeof who?.account === 'string' ? who.account : '',
@@ -1298,32 +1323,38 @@ export function startMcpServerOAuthSwitch(cfg, launch, serverName) {
   if (!url) throw new Error(`MCP server "${serverName}" does not use OAuth sign-in`);
   return startMcpOAuthSwitch({
     url,
+    credentialKey: resolveMcpOAuthCredentialKey(cfg),
     launch,
     serverName: mcpOAuthDisplayName(cfg, serverName),
     oauthClient: mcpOAuthClientFor(cfg, url),
     ...(googleMcpService(url) ? { fetchImpl: withGoogleMcp() } : {}),
   });
 }
-/** Store a switch's sign-in for the server's URL; resolves its rollback. */
+/** Store a switch's sign-in as the server's (its URL's, or its own key's);
+ *  resolves its rollback. */
 export function commitMcpServerOAuthSwitch(cfg, signIn) {
-  return commitMcpOAuthSwitch({ url: resolveMcpOAuthUrl(cfg), signIn });
+  return commitMcpOAuthSwitch({
+    url: resolveMcpOAuthUrl(cfg),
+    credentialKey: resolveMcpOAuthCredentialKey(cfg),
+    signIn,
+  });
 }
 /**
- * Log out of an HTTP/SSE server URL: delete the OAuth tokens and client
- * registration stored for it, shared by every server configured with that
- * exact URL, and drop them from live connections. `options.revoke` also
- * revokes the grant where the authorization server documents how; resolves
- * `{ revoked }`.
+ * Log out of an HTTP/SSE server: delete the OAuth tokens and client
+ * registration stored for it (shared by every server configured with that
+ * exact URL, unless it has its own credential key), and drop them from live
+ * connections. `options.revoke` also revokes the grant where the
+ * authorization server documents how; resolves `{ revoked }`.
  */
 export async function clearMcpServerOAuth(cfg, options = {}) {
-  let url;
+  let key;
   try {
-    url = resolveMcpOAuthUrl(cfg);
+    key = resolveMcpOAuthCredentialKey(cfg);
   } catch {
     // A config without a valid remote URL never connected, so never logged in.
     return { revoked: false };
   }
-  if (url) return clearMcpOAuth({ url, revoke: options.revoke === true });
+  if (key) return clearMcpOAuth({ url: resolveMcpOAuthUrl(cfg), credentialKey: key, revoke: options.revoke === true });
   return { revoked: false };
 }
 /**

package/src/runtime/agent/orchestrator/mcp/oauth-client.mjs

@@ -6,7 +6,7 @@
 //   - else the catalog connector's (connector-catalog.mjs `oauthClient`), with
 //     its scopes and the provider's offline-access parameter.
 import { createHash } from 'node:crypto';
-import keychain from '../../../../lib/keychain-cjs.cjs';
+import { keychainSecretStore as keychain } from '../../../shared/config.mjs';
 import { connectorById, connectorOfServer, gmailAppPasswordAccount } from '../../../shared/connector-catalog.mjs';
 import { GOOGLE_AUTH_PARAMS, googleOAuthClient } from '../../../shared/google-oauth-client.mjs';
 import { normalizeMcpTransportUrl } from './client-config.mjs';

package/src/runtime/agent/orchestrator/mcp/oauth-credentials.mjs

@@ -145,11 +145,16 @@ export function createCredentialCache({ url, credentialStore, account }) {
         }
         exists = Boolean(saved);
       }
+      const signedIn = Boolean(creds.tokens);
       change();
       hold();
+      // Other processes follow a refresh through the revision marker; only a
+      // sign-in or sign-out is announced as a settings change (it may let a
+      // server that needed sign-in connect, or end its connection).
+      const announce = remove ? signedIn : Boolean(creds.tokens) !== signedIn;
       if (remove) {
         await writeRevisionMarker(account, null);
-        if (exists) await credentialStore.deleteSecretAsync(account);
+        if (exists) await credentialStore.deleteSecretAsync(account, { announce });
         await writeIdentityFile(account, null);
         creds.observed = null;
       } else {
@@ -158,7 +163,8 @@ export function createCredentialCache({ url, credentialStore, account }) {
         const { tokens, clientInformation, redirectUrl, discovery, identity } = creds;
         await credentialStore.setSecretAsync(
           account,
-          JSON.stringify({ url, revision, tokens, clientInformation, redirectUrl, discovery, identity })
+          JSON.stringify({ url, revision, tokens, clientInformation, redirectUrl, discovery, identity }),
+          { announce }
         );
         await writeIdentityFile(account, creds);
         creds.observed = revision;

package/src/runtime/agent/orchestrator/mcp/oauth-login.mjs

@@ -6,6 +6,72 @@ import { identityFromTokenResponse } from './oauth-account.mjs';
 import { answerOAuthCallback } from './oauth-callback.mjs';
 import { anySignal, loginFailed, reauthenticationRequired, scopeNotGranted } from './oauth-shared.mjs';
 
+// Fetch for the SDK: transport-URL normalized, no redirects, bounded by the
+// login `signal`. The token endpoint's answer is read for who the tokens
+// belong to (oauth-account.mjs): the SDK keeps only the token fields.
+function makeSafeFetch({ fetchImpl, flow, signal }) {
+  return async (input, init = {}) => {
+    const response = await fetchImpl(normalizeMcpTransportUrl(input), {
+      ...init,
+      redirect: 'error',
+      signal: anySignal(signal, init.signal),
+    });
+    if (response.ok && /(^|&)grant_type=/.test(String(init.body ?? ''))) {
+      flow.identity = identityFromTokenResponse(
+        await response
+          .clone()
+          .json()
+          .catch(() => null)
+      );
+    }
+    return response;
+  };
+}
+
+// The caller's progress hooks (mcp-oauth-login.mjs): the callback arrived,
+// then the tokens are stored.
+function reportProgress(browser, hook) {
+  try {
+    browser?.[hook]?.();
+  } catch {
+    /* progress reporting never fails the login */
+  }
+}
+
+// The callback promise of one login, and the browser page held open for the
+// loopback callback until the code exchange and scope check end: `settle()` is
+// success, `settle({ code })` a failure. Bounded by `signal`, like the
+// exchange itself. `setFlushing` receives each answered page's flush.
+function awaitCallback({ flow, signal, stopListening, setFlushing }) {
+  let abort;
+  let respond;
+  const settle = (failure) => {
+    const answer = respond;
+    respond = undefined;
+    if (!answer) return undefined;
+    const flushed = answer(failure);
+    setFlushing(flushed);
+    return flushed;
+  };
+  const callback = new Promise((resolve, reject) => {
+    const finish = (code, page) => {
+      if (page) respond = page;
+      return code ? resolve(code) : reject(loginFailed());
+    };
+    flow.finishCallback = finish;
+    // Timeout, cancel or abort: the held page gets the generic failure now
+    // (the exchange or a credential write may be stalled past the deadline),
+    // and the listener closes once it is flushed.
+    abort = () => {
+      finish();
+      settle({});
+      stopListening();
+    };
+    signal.addEventListener('abort', abort, { once: true });
+  });
+  return { callback, settle, abort };
+}
+
 /**
  * The browser login of one connection over its credential `cache` and login
  * `flow` state: the loopback callback listener and the SDK authorization
@@ -65,61 +131,19 @@ export function createLoginFlow({ url, cache, flow, provider, lifetimeSignal, op
     // the token fields, so the token endpoint's answer is read here.
     flow.identity = undefined;
     flow.signal = signal;
-    const safeFetch = async (input, init = {}) => {
-      const response = await fetchImpl(normalizeMcpTransportUrl(input), {
-        ...init,
-        redirect: 'error',
-        signal: anySignal(signal, init.signal),
-      });
-      if (response.ok && /(^|&)grant_type=/.test(String(init.body ?? ''))) {
-        flow.identity = identityFromTokenResponse(
-          await response
-            .clone()
-            .json()
-            .catch(() => null)
-        );
-      }
-      return response;
-    };
-    // The caller's progress hooks (mcp-oauth-login.mjs): the callback arrived,
-    // then the tokens are stored.
-    const progress = (hook) => {
-      try {
-        browser?.[hook]?.();
-      } catch {
-        /* progress reporting never fails the login */
-      }
-    };
-    let abort;
-    // The browser page held open for the loopback callback until the code
-    // exchange and scope check end: `settle()` is success, `settle({ code })`
-    // a failure. Bounded by `signal`, like the exchange itself.
-    let respond;
-    const settle = (failure) => {
-      const answer = respond;
-      respond = undefined;
-      if (!answer) return undefined;
-      flushing = answer(failure);
-      return flushing;
-    };
-    const callback = new Promise((resolve, reject) => {
-      const finish = (code, page) => {
-        if (page) respond = page;
-        return code ? resolve(code) : reject(loginFailed());
-      };
-      flow.finishCallback = finish;
-      // Timeout, cancel or abort: the held page gets the generic failure now
-      // (the exchange or a credential write may be stalled past the deadline),
-      // and the listener closes once it is flushed.
-      abort = () => {
-        finish();
-        settle({});
-        stopListening();
-      };
-      signal.addEventListener('abort', abort, { once: true });
+    const safeFetch = makeSafeFetch({ fetchImpl, flow, signal });
+    const progress = (hook) => reportProgress(browser, hook);
+    const { callback, settle, abort } = awaitCallback({
+      flow,
+      signal,
+      stopListening,
+      setFlushing: (page) => {
+        flushing = page;
+      },
     });
     // A discovery/registration error can precede waiting for the callback.
     callback.catch(() => {});
+    let codeReceived = false;
     try {
       signal.throwIfAborted();
       const { auth } = await import('@modelcontextprotocol/sdk/client/auth.js');
@@ -141,6 +165,7 @@ export function createLoginFlow({ url, cache, flow, provider, lifetimeSignal, op
       });
       if (result === 'REDIRECT') {
         const code = await callback;
+        codeReceived = true;
         signal.throwIfAborted();
         progress('onCallback');
         const exchanged = await cache.withLock(async () => {
@@ -157,6 +182,12 @@ export function createLoginFlow({ url, cache, flow, provider, lifetimeSignal, op
       await settle();
     } catch (error) {
       await settle({ code: error?.code });
+      // An authorization server that no longer knows our client_id answers the
+      // browser with an HTTP error, never a redirect or a token-endpoint
+      // invalid_client, so the SDK cannot see it: register again next time.
+      if (interactive && flow.browserOpened && !codeReceived && !provider.preRegistered) {
+        await provider.invalidateCredentials('client').catch(() => {});
+      }
       // SDK errors may contain authorization server response bodies/secrets.
       if (error?.code === 'reauthenticationRequired' || !interactive) throw reauthenticationRequired();
       // Our own error names scopes only (no token data): the one to pass on.

package/src/runtime/agent/orchestrator/mcp/oauth-probe.mjs

@@ -12,7 +12,7 @@ import {
 } from './client-config.mjs';
 import { hasConfiguredMcpAuth } from './client-transport.mjs';
 
-export const MCP_AUTH_PROBE_TIMEOUT_MS = 10_000;
+const MCP_AUTH_PROBE_TIMEOUT_MS = 10_000;
 
 const INITIALIZE_PROBE = JSON.stringify({
   jsonrpc: '2.0',