mixdog 1.2.6 → 1.3.1

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

@@ -1,18 +1,33 @@
 import { normalizeMcpTransportUrl } from './client-config.mjs';
+import { withAccountParams } from './oauth-account.mjs';
 import { loginFailed, reauthenticationRequired } from './oauth-shared.mjs';
 
 /**
  * The SDK's OAuth client provider over one connection's credential `cache`
  * and login `flow` state.
  */
-export function createOAuthProvider({ cache, flow, lifetimeSignal }) {
+export function createOAuthProvider({ cache, flow, lifetimeSignal, client = null, credentialStore = null }) {
   const { creds, ready, update } = cache;
   // The SDK saves only inside a login, which holds the lock and has just
   // adopted the stored entry.
   const save = async (change) => {
     if (!(await update(change))) throw loginFailed();
   };
+  // A pre-registered client (oauth-client.mjs) is the static client
+  // information: nothing is registered, and its secret (the user's lives in
+  // the keychain) goes with the token requests.
+  const staticClient = async () => {
+    const secret = client.secretAccount
+      ? await credentialStore?.getSecretAsync(client.secretAccount)
+      : client.clientSecret;
+    return { client_id: client.clientId, ...(secret ? { client_secret: secret } : {}) };
+  };
   return {
+    /** A pre-registered client: a refresh needs no stored registration. */
+    preRegistered: Boolean(client),
+    // A pre-registered client's provider issues tokens for its own APIs
+    // (Google): no RFC 8707 resource indicator is sent.
+    ...(client ? { validateResourceURL: async () => undefined } : {}),
     get redirectUrl() {
       return creds.redirectUrl;
     },
@@ -23,11 +38,13 @@ export function createOAuthProvider({ cache, flow, lifetimeSignal }) {
         grant_types: ['authorization_code', 'refresh_token'],
         response_types: ['code'],
         token_endpoint_auth_method: 'none',
+        ...(client?.scopes ? { scope: client.scopes.join(' ') } : {}),
       };
     },
     state: () => flow.state,
     clientInformation: async () => {
       await ready();
+      if (client) return staticClient();
       // A connect that cannot open a sign-in never registers a client (the
       // SDK registers one after dropping a rejected registration): the next
       // explicit sign-in registers it.
@@ -46,6 +63,11 @@ export function createOAuthProvider({ cache, flow, lifetimeSignal }) {
       lifetimeSignal.throwIfAborted();
       await save(() => {
         creds.tokens = value;
+        // A browser sign-in may be another account: its identity replaces the
+        // stored one (null when the server named nobody). A refresh keeps it
+        // unless the response names the account again.
+        if (flow.browserOpened) creds.identity = flow.identity ?? null;
+        else if (flow.identity) creds.identity = flow.identity;
       });
     },
     saveCodeVerifier: (value) => {
@@ -56,10 +78,11 @@ export function createOAuthProvider({ cache, flow, lifetimeSignal }) {
       return flow.verifier;
     },
     discoveryState: () => creds.discovery,
-    saveDiscoveryState: (value) =>
-      save(() => {
-        creds.discovery = value;
-      }),
+    // Kept in memory and stored with the login's next write (the client
+    // registration or the tokens), sparing a keychain write of its own.
+    saveDiscoveryState: (value) => {
+      creds.discovery = value;
+    },
     // The SDK invalidates 'all' when the token endpoint rejects the client
     // (invalid_client / unauthorized_client) and 'tokens' when it rejects the
     // grant (invalid_grant). The registration goes in both cases: an
@@ -88,8 +111,24 @@ export function createOAuthProvider({ cache, flow, lifetimeSignal }) {
         !flow.verifier
       )
         throw loginFailed();
+      // A pre-registered client is stored with this login's redirect, as a
+      // registration would be: the exchange and later refreshes (and the
+      // revocation on 연결 해제) read them from the entry.
+      if (client) {
+        const issuedTo = await staticClient();
+        await save(() => {
+          creds.clientInformation = issuedTo;
+        });
+      }
       flow.browserOpened = true;
-      await flow.launchBrowser(target.href);
+      // A pre-registered client asks for its own scopes (the server's list
+      // may name far more) plus its provider's parameters (Google's
+      // access_type=offline, without which no refresh token is issued).
+      if (client?.scopes) target.searchParams.set('scope', client.scopes.join(' '));
+      for (const [key, value] of Object.entries(client?.authParams || {})) target.searchParams.set(key, value);
+      // The explicit sign-in's account mode (mcp-oauth-login.mjs) decides the
+      // provider's documented account-choice parameter, if any.
+      await flow.launchBrowser(withAccountParams(target.href, flow.launchBrowser.accountMode || 'connect').href);
     },
   };
 }

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

@@ -1,4 +1,4 @@
-import { createHash } from 'node:crypto';
+import { createHash, randomBytes } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import keychain from '../../../../lib/keychain-cjs.cjs';
 import { openInBrowser } from '../../../shared/open-url.mjs';
@@ -12,8 +12,10 @@ import {
   TOKENS_FLAG,
   createCredentialCache,
   credentialFile,
+  readIdentityFile,
   readStoredCredentials,
   withCredentialLock,
+  writeIdentityFile,
   writeRevisionMarker,
 } from './oauth-credentials.mjs';
 import { createLoginFlow } from './oauth-login.mjs';
@@ -55,18 +57,198 @@ export function hasStoredMcpOAuthTokens(url) {
   }
 }
 
+/** Who the stored sign-in of one MCP server URL belongs to, without a keychain
+ *  read: `{ account, workspace, forcedChoice }` (empty strings when the server
+ *  named nobody), or null when signed out. */
+export function storedMcpOAuthIdentity(url) {
+  return readIdentityFile(mcpOAuthAccount(normalizeMcpTransportUrl(url)));
+}
+
+// RFC 7009 revocation of the stored grant, only where the authorization server
+// advertises its revocation endpoint (RFC 8414 metadata): it revokes the token
+// this client was issued, nothing workspace-wide. True when the server
+// confirmed it.
+async function revokeStoredGrant(saved, fetchImpl) {
+  let value;
+  try {
+    value = JSON.parse(saved);
+  } catch {
+    return false;
+  }
+  const endpoint = value?.discovery?.authorizationServerMetadata?.revocation_endpoint;
+  const token = value?.tokens?.refresh_token || value?.tokens?.access_token;
+  const clientId = value?.clientInformation?.client_id;
+  if (typeof endpoint !== 'string' || !/^https:\/\//.test(endpoint) || !token || !clientId) return false;
+  const body = new URLSearchParams({
+    token,
+    token_type_hint: value.tokens.refresh_token ? 'refresh_token' : 'access_token',
+    client_id: clientId,
+  });
+  if (value.clientInformation.client_secret) body.set('client_secret', value.clientInformation.client_secret);
+  try {
+    const response = await fetchImpl(endpoint, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body,
+      redirect: 'error',
+      signal: AbortSignal.timeout(5_000),
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
 /** Log out of one MCP server URL: delete its stored tokens and client
  *  registration and drop them from live connections, which then need an
- *  explicit reconnect to log in again. */
-export async function clearMcpOAuth({ url, credentialStore = keychain }) {
+ *  explicit reconnect to log in again. With `revoke`, the grant is first
+ *  revoked at the authorization server where it documents a revocation
+ *  endpoint. Resolves `{ revoked }`. */
+export async function clearMcpOAuth({ url, credentialStore = keychain, revoke = false, fetchImpl = fetch }) {
   url = normalizeMcpTransportUrl(url);
   const account = mcpOAuthAccount(url);
+  let revoked = false;
   await withCredentialLock(account, async () => {
+    const saved = await readStoredCredentials(credentialStore, account);
+    if (revoke && saved != null) revoked = await revokeStoredGrant(saved, fetchImpl);
     await writeRevisionMarker(account, null);
-    if ((await readStoredCredentials(credentialStore, account)) != null)
-      await credentialStore.deleteSecretAsync(account);
+    if (saved != null) await credentialStore.deleteSecretAsync(account);
+    await writeIdentityFile(account, null);
   });
   scopes.get(credentialStore)?.get(url)?.oauth.clear();
+  return { revoked };
+}
+
+async function storeEntry(account, url, value, credentialStore) {
+  const revision = randomBytes(16).toString('hex');
+  const { tokens, clientInformation, redirectUrl, discovery, identity } = value;
+  await writeRevisionMarker(account, revision, Boolean(tokens));
+  await credentialStore.setSecretAsync(
+    account,
+    JSON.stringify({ url, revision, tokens, clientInformation, redirectUrl, discovery, identity })
+  );
+  await writeIdentityFile(account, value);
+}
+
+/**
+ * 계정 바꾸기 for one MCP server URL, transactionally: a browser sign-in with
+ * the provider's documented account choice that runs beside the stored
+ * sign-in, reusing its client registration and discovery but never its tokens,
+ * and stores nothing. `done` resolves the new sign-in (`{ tokens, identity, … }`)
+ * or rejects (cancel, denial, timeout), leaving the stored sign-in and every
+ * live connection as they were. `answer(pasted)` completes it with a pasted
+ * redirect URL (remote sign-in); `cancel()` aborts it.
+ */
+export function startMcpOAuthSwitch({
+  url,
+  launch,
+  serverName,
+  credentialStore = keychain,
+  fetchImpl = fetch,
+  timeoutMs = MCP_OAUTH_TIMEOUT_MS,
+  oauthClient = null,
+}) {
+  url = normalizeMcpTransportUrl(url);
+  const lifetime = new AbortController();
+  const creds = {
+    tokens: undefined,
+    clientInformation: undefined,
+    redirectUrl: undefined,
+    discovery: undefined,
+    identity: undefined,
+    // Never null: the in-memory entry always exists.
+    observed: 'switch',
+  };
+  // An in-memory entry: a registration made during the switch stays here
+  // until the commit stores it with the tokens.
+  const cache = {
+    creds,
+    held: new Set(),
+    ready: async () => {},
+    adoptStored: async () => {},
+    update: async (change) => {
+      change();
+      return true;
+    },
+    withLock: (fn) => fn(),
+  };
+  const flow = {
+    listener: undefined,
+    state: undefined,
+    verifier: undefined,
+    allowBrowser: false,
+    browserOpened: false,
+    launchBrowser: launch,
+    finishCallback: undefined,
+  };
+  const provider = createOAuthProvider({
+    cache,
+    flow,
+    lifetimeSignal: lifetime.signal,
+    client: oauthClient,
+    credentialStore,
+  });
+  const loginFlow = createLoginFlow({
+    url,
+    cache,
+    flow,
+    provider,
+    lifetimeSignal: lifetime.signal,
+    openBrowser: launch,
+    fetchImpl,
+    timeoutMs,
+  });
+  const done = (async () => {
+    const saved = await readStoredCredentials(credentialStore, mcpOAuthAccount(url));
+    if (saved) {
+      const value = JSON.parse(saved);
+      if (value.url === url) {
+        creds.clientInformation = value.clientInformation;
+        creds.redirectUrl = value.redirectUrl;
+        creds.discovery = value.discovery;
+      }
+    }
+    await loginFlow.login({}, lifetime.signal, true, launch, undefined, serverName);
+    const { tokens, clientInformation, redirectUrl, discovery, identity } = creds;
+    if (!tokens) throw new Error('MCP OAuth login failed, cancelled, or timed out');
+    return { tokens, clientInformation, redirectUrl, discovery, identity: identity ?? null };
+  })();
+  return {
+    done,
+    answer(pasted) {
+      if (!flow.finishCallback || !flow.browserOpened || !flow.state || !creds.redirectUrl) {
+        throw new Error(MCP_OAUTH_CALLBACK_NOT_PENDING);
+      }
+      const { code } = parsePastedMcpOAuthCallback(pasted, { redirectUrl: creds.redirectUrl, state: flow.state });
+      loginFlow.stopListening();
+      loginFlow.answerCallback(code);
+    },
+    cancel() {
+      lifetime.abort();
+      flow.finishCallback?.();
+      loginFlow.closeListener();
+    },
+  };
+}
+
+/** Store the sign-in a switch returned as the URL's sign-in; resolves a
+ *  `rollback()` that restores the previous one (or none). Live connections
+ *  adopt either through the revision marker on their next request. */
+export async function commitMcpOAuthSwitch({ url, signIn, credentialStore = keychain }) {
+  url = normalizeMcpTransportUrl(url);
+  const account = mcpOAuthAccount(url);
+  let previous = null;
+  await withCredentialLock(account, async () => {
+    previous = await readStoredCredentials(credentialStore, account);
+    await storeEntry(account, url, signIn, credentialStore);
+  });
+  return () =>
+    withCredentialLock(account, async () => {
+      if (previous) return storeEntry(account, url, JSON.parse(previous), credentialStore);
+      await writeRevisionMarker(account, null);
+      await credentialStore.deleteSecretAsync(account);
+      await writeIdentityFile(account, null);
+    });
 }
 
 // The keychain is the only durable store. Exact URLs, including query strings,
@@ -166,6 +348,7 @@ function createSharedOAuth({
   openBrowser = openInBrowser,
   fetchImpl = fetch,
   timeoutMs = MCP_OAUTH_TIMEOUT_MS,
+  oauthClient = null,
 }) {
   const lifetime = new AbortController();
   const cache = createCredentialCache({ url, credentialStore, account: mcpOAuthAccount(url) });
@@ -179,7 +362,13 @@ function createSharedOAuth({
     launchBrowser: openBrowser,
     finishCallback: undefined,
   };
-  const provider = createOAuthProvider({ cache, flow, lifetimeSignal: lifetime.signal });
+  const provider = createOAuthProvider({
+    cache,
+    flow,
+    lifetimeSignal: lifetime.signal,
+    client: oauthClient,
+    credentialStore,
+  });
   const { login, stopListening, closeListener, answerCallback } = createLoginFlow({
     url,
     cache,

package/src/runtime/agent/orchestrator/mcp/server-connectors.mjs

@@ -0,0 +1,17 @@
+// Which catalog connector each connected MCP server is (connector-catalog.mjs
+// connectorOfServer), recorded by the client as servers connect, so a tool
+// name alone (`mcp__<server>__<tool>`) finds its catalog defaults at dispatch.
+import { connectorOfServer } from '../../../shared/connector-catalog.mjs';
+
+const byServer = new Map();
+
+export function rememberServerConnector(name, cfg) {
+  const id = connectorOfServer(cfg);
+  if (id) byServer.set(String(name), id);
+  else byServer.delete(String(name));
+}
+
+/** The catalog id of connected server `name`, or ''. */
+export function serverConnector(name) {
+  return byServer.get(String(name)) || '';
+}

package/src/runtime/agent/orchestrator/providers/anthropic-oauth-client-version.mjs

@@ -10,7 +10,7 @@ import { createNpmVersionSource, maxSemver } from './npm-cli-version.mjs';
 // source release just to advance the user-agent version.
 // Claude Opus 5.5 requires 2.1.280 or newer. The release workflow raises this
 // to the published CLI version (scripts/sync-client-version-floors.mjs).
-export const DEFAULT_CLI_VERSION = '2.1.302';
+export const DEFAULT_CLI_VERSION = '2.1.304';
 export const CLAUDE_CLI_NPM_PACKAGE = '@anthropic-ai/claude-code';
 
 const CACHE_SCHEMA_VERSION = 1;

package/src/runtime/agent/orchestrator/providers/anthropic-oauth-credentials.mjs

@@ -209,6 +209,7 @@ export function describeAnthropicOAuthCredentials() {
     return {
       ...oauthCredentialStatus({ hasRefresh, expiresAt, detail, refreshSkewMs: TOKEN_REFRESH_SKEW_MS }),
       ...accountIdentityFields(creds.identity),
+      plan: creds.subscriptionType || null,
     };
   } catch (err) {
     return {

package/src/runtime/agent/orchestrator/providers/antigravity-oauth-catalog.mjs

@@ -187,9 +187,14 @@ export function normalizeAntigravityCatalog(rawModels) {
   return models.sort((a, b) => a.display.localeCompare(b.display));
 }
 
-/** Catalog to resolve wire ids against: in-memory mirror, disk cache, then the curated fallback. */
+/**
+ * Catalog to resolve wire ids against: in-memory mirror, disk cache, then the
+ * curated fallback. Sends never refresh the catalog, so the account's last live
+ * list is used even past its TTL: it names the wire ids this account was
+ * offered, which the curated list can only approximate.
+ */
 function antigravityCatalogModels() {
-  if (!_mirror) _mirror = antigravityModelCache.loadSync();
+  if (!_mirror) _mirror = antigravityModelCache.loadSync({ allowStale: true });
   return _mirror || ANTIGRAVITY_MODELS;
 }
 

package/src/runtime/agent/orchestrator/providers/antigravity-oauth-login.mjs

@@ -218,7 +218,12 @@ async function provisionProject(context, tierId) {
 }
 
 /** Resolve account eligibility and return the project from a fresh status load. */
-export async function discoverProject(
+export async function discoverProject(accessToken, options = {}) {
+  return (await discoverAccount(accessToken, options)).projectId;
+}
+
+/** Project plus the account's tier id (paid tier first), from the same status load. */
+export async function discoverAccount(
   accessToken,
   { fetchFn = fetch, onProgress = null, signal = null, email = '' } = {}
 ) {
@@ -235,7 +240,8 @@ export async function discoverProject(
   const refreshed = await loadProjectState(context);
   const projectId = extractProjectId(refreshed);
   if (!projectId) throw new Error('[antigravity-oauth] loadCodeAssist did not return a cloudaicompanionProject');
-  return projectId;
+  const tierId = refreshed.paidTier?.id || refreshed.currentTier?.id;
+  return { projectId, tierId: typeof tierId === 'string' ? tierId : '' };
 }
 
 export async function exchangeAuthorizationCode({ code, verifier, fetchFn = fetch, onProgress = null, signal = null }) {
@@ -267,12 +273,13 @@ export async function exchangeAuthorizationCode({ code, verifier, fetchFn = fetc
     throw new Error('[antigravity-oauth] token exchange response missing access_token or refresh_token');
   }
   const { email, userId } = await fetchAccountInfo(json.access_token, { fetchFn, signal });
-  const projectId = await discoverProject(json.access_token, { fetchFn, onProgress, signal, email });
+  const { projectId, tierId } = await discoverAccount(json.access_token, { fetchFn, onProgress, signal, email });
   const tokens = {
     access_token: json.access_token,
     refresh_token: json.refresh_token,
     expires_at: typeof json.expires_in === 'number' ? Date.now() + json.expires_in * 1000 : 0,
     project_id: projectId,
+    tier_id: tierId,
     email,
     user_id: userId,
   };

package/src/runtime/agent/orchestrator/providers/antigravity-oauth-tokens.mjs

@@ -204,6 +204,7 @@ export function loadTokens() {
       refresh_token: String(raw.refresh_token),
       expires_at: _normalizeExpiresAt(raw.expires_at ?? raw.expiresAt),
       project_id: String(raw.project_id || raw.projectId || ''),
+      tier_id: String(raw.tier_id || ''),
       email: String(raw.email || ''),
       user_id: String(raw.user_id || raw.userId || ''),
       source: 'own',
@@ -222,6 +223,7 @@ export function saveTokens(tokens) {
       refresh_token: tokens.refresh_token,
       expires_at: tokens.expires_at || 0,
       project_id: tokens.project_id || tokens.projectId || '',
+      tier_id: tokens.tier_id || '',
       email: tokens.email || '',
       user_id: tokens.user_id || tokens.userId || '',
     },
@@ -274,6 +276,7 @@ export function describeAntigravityOAuthCredentials() {
       ...accountIdentityFields({ id: tokens.user_id, email: tokens.email }),
       email: tokens.email || '',
       projectId: tokens.project_id || '',
+      plan: tokens.tier_id || null,
     };
   } catch {
     return credentialsNotSet();
@@ -340,6 +343,7 @@ export function refreshTokens({ fetchFn = fetch } = {}) {
       refresh_token: json.refresh_token || current.refresh_token,
       expires_at: typeof json.expires_in === 'number' ? Date.now() + json.expires_in * 1000 : 0,
       project_id: current.project_id,
+      tier_id: current.tier_id,
       email: current.email,
       user_id: current.user_id,
     };

package/src/runtime/agent/orchestrator/providers/auto-effort.mjs

@@ -31,14 +31,14 @@ export const AUTO_EFFORT_LEVELS = Object.freeze(['easy', 'normal', 'hard', 'very
 const STEP_OF_LEVEL = [-1, 0, 1, 2];
 
 // The chosen level minimises the expected cost under the judge distribution.
-// A miss costs one per level, plus extra for an opposite call and for a
-// needless "very hard" (xhigh). Opposite calls are asymmetric: "easy" for a
-// hard turn degrades the answer, "hard" for an easy turn only costs tokens.
-// On the held-out test splits the heavier under-call cost cut hard-as-easy
-// calls by a third (20 -> 13 of 7,180) for -0.2 points of exact accuracy.
+// A miss costs one per level, plus extra for an opposite call. Opposite calls
+// are asymmetric: "easy" for a hard turn degrades the answer, "hard" for an
+// easy turn only costs tokens. On the held-out test splits the heavier
+// under-call cost cut hard-as-easy calls by a third (20 -> 13 of 7,180) for
+// -0.2 points of exact accuracy. "Very hard" carries no extra cost: an extra
+// penalty there let judge v7 pick xhigh on only 17% of very hard turns.
 export const AUTO_EFFORT_UNDER_OPPOSITE_COST = 3;
 export const AUTO_EFFORT_OVER_OPPOSITE_COST = 1;
-export const AUTO_EFFORT_FALSE_VERY_HARD_COST = 1;
 // Ties keep the default first, then the cheaper side.
 const TIE_ORDER = [1, 0, 2, 3];
 
@@ -49,8 +49,7 @@ function expectedCost(values, level) {
       p *
       (Math.abs(level - actual) +
         (level === 0 && actual >= 2 ? AUTO_EFFORT_UNDER_OPPOSITE_COST : 0) +
-        (actual === 0 && level >= 2 ? AUTO_EFFORT_OVER_OPPOSITE_COST : 0) +
-        (level === 3 && actual < 3 ? AUTO_EFFORT_FALSE_VERY_HARD_COST : 0));
+        (actual === 0 && level >= 2 ? AUTO_EFFORT_OVER_OPPOSITE_COST : 0));
   });
   return cost;
 }

package/src/runtime/agent/orchestrator/providers/cursor-client-version.mjs

@@ -4,7 +4,7 @@ import { createRemoteVersionSource } from './npm-cli-version.mjs';
 // documented version endpoint; the official installer script embeds the
 // current build (…/lab/<build>/…), parsed best-effort. Any format change or
 // failure falls back to the floor.
-export const CURSOR_CLIENT_VERSION_FLOOR = 'cli-2026.10.16-e3cb207';
+export const CURSOR_CLIENT_VERSION_FLOOR = 'cli-2026.10.19-6bbf2c4';
 const BUILD_PATTERN = /downloads\.cursor\.com\/lab\/(\d{4}\.\d{2}\.\d{2}-[0-9a-f]{6,40})\//;
 export const CURSOR_INSTALL_URL = 'https://cursor.com/install';
 

package/src/runtime/agent/orchestrator/providers/lib/anthropic-request-utils.mjs

@@ -10,6 +10,7 @@ import { mergeFlatSchemaProperty } from './flat-schema-merge.mjs';
 import { reportedCostUsd } from './usage-primitives.mjs';
 import { reportInvalidTool, wireInputSchema } from './claude-bridge-schema.mjs';
 import { normalizeServerToolUse } from './anthropic-server-tool-usage.mjs';
+import { ANTHROPIC_TOOL_CALL_IDS, withWireToolCallIds } from './tool-call-wire-ids.mjs';
 export const ANTHROPIC_CACHE_TTL_STABLE = { type: 'ephemeral', ttl: '1h' };
 const ANTHROPIC_CACHE_TTL_VOLATILE = { type: 'ephemeral' };
 
@@ -232,7 +233,8 @@ const ANTHROPIC_NATIVE_PROVIDERS = new Set(['anthropic', 'anthropic-oauth']);
 
 // `provider`: the engine's provider name. A gateway on a native Messages
 // route (wire-route.mjs) also replays the references it tagged itself.
-export function toAnthropicMessages(messages, availableTools, provider = '') {
+export function toAnthropicMessages(transcript, availableTools, provider = '') {
+  const messages = withWireToolCallIds(transcript, ANTHROPIC_TOOL_CALL_IDS);
   const ownProvider = String(provider || '').toLowerCase();
   const availableNames = anthropicToolNameSet(availableTools);
   const result = [];

package/src/runtime/agent/orchestrator/providers/lib/tool-call-wire-ids.mjs

@@ -0,0 +1,65 @@
+// Tool-call ids at the wire. A transcript keeps each tool call's id as the
+// provider that produced it minted it; after a model switch another provider
+// may refuse it (Anthropic accepts only [A-Za-z0-9_-]; OpenAI chat caps the
+// length). Each request builder projects the ids onto its own rule just
+// before lowering: a valid id passes unchanged (so native replay items and
+// the provider's own ids stay byte-exact), an invalid one becomes a
+// deterministic, collision-free stand-in, and a call and its result always
+// map to the same value. Persisted history is never rewritten.
+import { createHash } from 'node:crypto';
+
+export const ANTHROPIC_TOOL_CALL_IDS = Object.freeze({ allowed: /^[A-Za-z0-9_-]+$/, maxLength: 64 });
+export const OPENAI_RESPONSES_TOOL_CALL_IDS = Object.freeze({ allowed: /^[A-Za-z0-9_.:-]+$/, maxLength: 64 });
+export const OPENAI_CHAT_TOOL_CALL_IDS = Object.freeze({ allowed: /^[A-Za-z0-9_.:-]+$/, maxLength: 40 });
+
+const HASH_CHARS = 10;
+
+function standIn(id, rule, salt) {
+  const hash = createHash('sha256').update(`${salt}\u0000${id}`).digest('hex').slice(0, HASH_CHARS);
+  const stem = String(id)
+    .replace(/[^A-Za-z0-9_-]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    .slice(0, Math.max(0, rule.maxLength - HASH_CHARS - 1));
+  return stem ? `${stem}_${hash}` : `call_${hash}`.slice(0, rule.maxLength);
+}
+
+const isValid = (id, rule) => id.length > 0 && id.length <= rule.maxLength && rule.allowed.test(id);
+
+/** id → wire id for every tool call and result in `messages` under `rule`. */
+export function toolCallWireIdMap(messages, rule) {
+  const ids = new Set();
+  for (const message of Array.isArray(messages) ? messages : []) {
+    if (message?.role === 'assistant')
+      for (const call of message.toolCalls || []) if (call?.id) ids.add(String(call.id));
+    if (message?.role === 'tool' && message.toolCallId) ids.add(String(message.toolCallId));
+  }
+  const map = new Map();
+  const taken = new Set([...ids].filter((id) => isValid(id, rule)));
+  for (const id of ids) {
+    if (isValid(id, rule)) continue;
+    let salt = 0;
+    let wire = standIn(id, rule, salt);
+    while (taken.has(wire)) wire = standIn(id, rule, ++salt);
+    taken.add(wire);
+    map.set(id, wire);
+  }
+  return map;
+}
+
+/** `messages` with tool-call ids projected onto `rule`; the same array when none needs it. */
+export function withWireToolCallIds(messages, rule) {
+  const map = toolCallWireIdMap(messages, rule);
+  if (!map.size) return messages;
+  return messages.map((message) => {
+    if (message?.role === 'tool' && map.has(String(message.toolCallId))) {
+      return { ...message, toolCallId: map.get(String(message.toolCallId)) };
+    }
+    if (message?.role !== 'assistant' || !message.toolCalls?.some((call) => map.has(String(call?.id)))) return message;
+    return {
+      ...message,
+      toolCalls: message.toolCalls.map((call) =>
+        map.has(String(call?.id)) ? { ...call, id: map.get(String(call.id)) } : call
+      ),
+    };
+  });
+}

package/src/runtime/agent/orchestrator/providers/openai-compat-retry-profile.mjs

@@ -104,10 +104,16 @@ export const COMPAT_RETRY_PROFILES = Object.freeze({
   }),
 });
 
-/** withRetry options (attempt budget, schedule, jitter) for a provider; {} for the shared defaults. */
+// A provider without a profile (custom endpoints, gateways, local servers)
+// keeps the shared ladder, but a Retry-After beyond a minute is not waited
+// out: it surfaces with its wait so the account pool can rotate and the
+// notice can name when to try again.
+export const COMPAT_DEFAULT_MAX_RETRY_AFTER_MS = 60_000;
+
+/** withRetry options (attempt budget, schedule, jitter) for a provider; only the advice ceiling for the shared defaults. */
 export function compatRetryOptions(providerName) {
   const profile = COMPAT_RETRY_PROFILES[providerName];
-  if (!profile) return {};
+  if (!profile) return { maxRetryAfterMs: COMPAT_DEFAULT_MAX_RETRY_AFTER_MS };
   return {
     maxAttempts: profile.maxAttempts,
     backoffMs: profile.backoffMs,

package/src/runtime/agent/orchestrator/providers/openai-compat-wire.mjs

@@ -17,6 +17,11 @@ import {
 } from './media-normalization.mjs';
 import { customToolCallFromResponseItem, nativeToolSearchCallFromArguments } from './custom-tool-wire.mjs';
 import { providerReplayItems } from './lib/provider-replay.mjs';
+import {
+  OPENAI_CHAT_TOOL_CALL_IDS,
+  OPENAI_RESPONSES_TOOL_CALL_IDS,
+  withWireToolCallIds,
+} from './lib/tool-call-wire-ids.mjs';
 import { acceptedWireTools } from './lib/claude-bridge-schema.mjs';
 import { ensureResponsesCallOutputs } from './lib/wire-pairing.mjs';
 import { responsesEffortUpdates } from './effort-configuration.mjs';
@@ -34,7 +39,8 @@ export function resolveCompatMaxOutputTokens(opts = {}) {
   );
 }
 
-export function toOpenAIMessages(messages, providerName, options = {}) {
+export function toOpenAIMessages(transcript, providerName, options = {}) {
+  const messages = withWireToolCallIds(transcript, OPENAI_CHAT_TOOL_CALL_IDS);
   // NOTE: chat.completions has no equivalent slot for replaying reasoning
   // encrypted_content the way the Responses API does (no `type:'reasoning'`
   // input item). Whatever reasoningItems may be attached to assistant
@@ -421,7 +427,8 @@ export function xaiSystemInstructions(messages) {
   return instructions || undefined;
 }
 
-export function toXaiResponsesInput(messages, providerState, options = {}) {
+export function toXaiResponsesInput(transcript, providerState, options = {}) {
+  const messages = withWireToolCallIds(transcript, OPENAI_RESPONSES_TOOL_CALL_IDS);
   const includeSystem = options.includeSystem !== false;
   // Generic Responses callers (opencode-go gateway) keep their own state
   // slot and replay tag so a provider switch never replays foreign items.