mixdog 1.2.2 → 1.2.3

package/src/runtime/agent/orchestrator/providers/opencode-go.mjs

@@ -1,30 +1,49 @@
 import { randomUUID } from 'node:crypto';
 import { AnthropicProvider } from './anthropic.mjs';
 import { OpenAICompatProvider, OPENAI_COMPAT_PRESETS } from './openai-compat.mjs';
-import { currentUsageContext } from '../../../shared/llm/usage-context.mjs';
 import { getModelMetadataSync, getModelsDevRowSync } from './model-catalog.mjs';
+import { toInclusiveUsage, withInclusiveUsage } from './lib/inclusive-usage.mjs';
+import { providerOffersWire, resolveWireRoute, sendOnRoute } from './wire-route.mjs';
+import { gatewayMessagesOpts } from './wire-gateway.mjs';
+
+// The Go Anthropic route: the shared request builder gets the model's output
+// ceiling (models.dev limit) through the gateway options.
+class OpenCodeGoMessagesEngine extends AnthropicProvider {
+  _sendOnce(messages, model, tools, opts) {
+    return super._sendOnce(messages, model, tools, gatewayMessagesOpts(this.config, model, messages, opts));
+  }
+}
 
 // OpenCode Go publishes OpenAI chat/completions, OpenAI Responses, and
 // Anthropic Messages endpoints, and each upstream brand answers on only one
-// of them (muse-spark / gpt / grok 500 on chat/completions; minimax expects
-// Messages). models.dev names the SDK package per model, which is the
-// authoritative wire selector; the prefix tables are the cold-catalog fallback.
-const ANTHROPIC_MODEL_PREFIXES = ['minimax-', 'qwen'];
-const RESPONSES_MODEL_PREFIXES = ['muse-spark-', 'gpt-', 'grok-'];
+// of them (muse-spark / gpt / grok 500 on chat/completions; minimax and
+// Claude expect Messages). models.dev names the SDK package per model, which
+// is the authoritative wire selector; wire-route.mjs holds the cold-catalog
+// prefix fallback. `@ai-sdk/google` names the Gemini generateContent wire
+// (opencode-go-gemini.mjs).
 const WIRE_API_BY_NPM = Object.freeze({
   '@ai-sdk/openai': 'responses',
   '@ai-sdk/anthropic': 'messages',
   '@ai-sdk/openai-compatible': 'chat',
+  '@ai-sdk/google': 'gemini',
 });
 
+function openCodeGoCatalogWire(model) {
+  const npm = getModelsDevRowSync(String(model || ''), 'opencode-go')?.npm;
+  return typeof npm === 'string' && Object.hasOwn(WIRE_API_BY_NPM, npm) ? WIRE_API_BY_NPM[npm] : null;
+}
+
+function resolveOpenCodeGoWireRoute(model, ctx = {}) {
+  const catalogWire = openCodeGoCatalogWire(model);
+  // Each Go model answers on the one wire the catalog names: it narrows the
+  // offered endpoints, so an override cannot pick a wire the model lacks.
+  const endpoints = providerOffersWire('opencode-go', catalogWire) ? [catalogWire] : null;
+  return resolveWireRoute('opencode-go', model, { ...ctx, catalogWire, endpoints });
+}
+
 /** Wire API for a Go model: 'responses' | 'messages' | 'chat'. */
 function openCodeGoWireApi(model) {
-  const id = String(model || '').toLowerCase();
-  const npm = getModelsDevRowSync(String(model || ''), 'opencode-go')?.npm;
-  if (npm && WIRE_API_BY_NPM[npm]) return WIRE_API_BY_NPM[npm];
-  if (RESPONSES_MODEL_PREFIXES.some((prefix) => id.startsWith(prefix))) return 'responses';
-  if (ANTHROPIC_MODEL_PREFIXES.some((prefix) => id.startsWith(prefix))) return 'messages';
-  return 'chat';
+  return resolveOpenCodeGoWireRoute(model).wire;
 }
 
 export function isAnthropicGoModel(model) {
@@ -48,42 +67,8 @@ export function openCodeGoEndpointForModel(model, configuredBaseURL) {
   return `${bases.openai}/chat/completions`;
 }
 
-// Usage objects already converted to the inclusive convention; a converted
-// object passing through another normalization (nested send) stays as is,
-// and one source object always converts to the same object, so an abandoned
-// attempt and the error that later carries it stay one record.
-const inclusiveUsage = new WeakSet();
-const convertedUsage = new WeakMap();
-
-export function toInclusiveOpenCodeGoUsage(usage) {
-  if (!usage || inclusiveUsage.has(usage)) return usage;
-  if (convertedUsage.has(usage)) return convertedUsage.get(usage);
-  const input = Number(usage.inputTokens) || 0;
-  const cached = Number(usage.cachedTokens) || 0;
-  const cacheWrite = Number(usage.cacheWriteTokens) || 0;
-  const inclusiveInput = input + cached + cacheWrite;
-  const converted = {
-    ...usage,
-    inputTokens: inclusiveInput,
-    promptTokens: Math.max(Number(usage.promptTokens) || 0, inclusiveInput),
-  };
-  inclusiveUsage.add(converted);
-  convertedUsage.set(usage, converted);
-  return converted;
-}
-
-function normalizeOpenCodeGoResultUsage(result, anthropicRoute) {
-  if (!anthropicRoute || !result?.usage) return result;
-  return { ...result, usage: toInclusiveOpenCodeGoUsage(result.usage) };
-}
-
-function normalizeOpenCodeGoError(error) {
-  if (error && typeof error === 'object') {
-    if (error.usage) error.usage = toInclusiveOpenCodeGoUsage(error.usage);
-    if (error.partialUsage) error.partialUsage = toInclusiveOpenCodeGoUsage(error.partialUsage);
-  }
-  return error;
-}
+// The Messages route reports usage in the provider's inclusive convention.
+export const toInclusiveOpenCodeGoUsage = toInclusiveUsage;
 
 function opencodeGoContextWindow(modelId, current = 0) {
   const native = Number(current);
@@ -118,11 +103,15 @@ export class OpenCodeGoProvider {
     const preset = OPENAI_COMPAT_PRESETS['opencode-go'];
     const bases = resolveOpenCodeGoBaseURLs(config.baseURL || preset.baseURL);
     this.openai = new OpenAICompatProvider('opencode-go', { ...config, baseURL: bases.openai });
-    this.anthropic = new AnthropicProvider({
+    this.anthropic = new OpenCodeGoMessagesEngine({
       ...config,
       name: 'opencode-go',
       baseURL: bases.anthropic,
       disableBetaHeaders: true,
+      // The preset's identifying headers (User-Agent) ride the Messages wire
+      // too; the user's own headers win.
+      extraHeaders: { ...(preset.extraHeaders || {}), ...(config.extraHeaders || {}) },
+      modelMaxOutputTokens: (model) => this.getCachedModelInfo(model)?.outputTokens,
     });
     // The Anthropic route answers for this provider: PDFs lower to text.
     this.anthropic.nativePdf = this.nativePdf;
@@ -142,29 +131,45 @@ export class OpenCodeGoProvider {
         'x-opencode-session': sessionId,
       },
     };
-    const wire = openCodeGoWireApi(model);
-    if (wire === 'responses') {
-      // OpenAI-family brands on the gateway (Muse Spark, GPT, Grok)
-      // only answer on /responses; the compat transport switches wire
-      // shape per request via this flag.
-      return this.openai.send(messages, model, tools, { ...(sendOpts || {}), compatWireApi: 'responses' });
-    }
-    if (wire === 'messages') {
-      // The Anthropic-style Go endpoint reports cached read/write usage
-      // and accepts the standard message shape. Preserve the caller's
-      // cache strategy so the shared Anthropic live-tail marker advances
-      // through tool loops instead of forcing every request fully cold.
-      // Abandoned attempts noted by the inner provider use the same conversion.
-      const identity = currentUsageContext();
-      if (identity) identity.normalizeAbandonedUsage = toInclusiveOpenCodeGoUsage;
-      try {
-        const result = await this.anthropic.send(messages, model, tools, sendOpts);
-        return normalizeOpenCodeGoResultUsage(result, true);
-      } catch (error) {
-        throw normalizeOpenCodeGoError(error);
+    // The session's pinned route, else this model's route (wire-route.mjs);
+    // the resolved route is the only wire authority (a caller's own wire
+    // switches never reach an engine), and one clear "unsupported" refusal
+    // moves the send to the next wire once.
+    return sendOnRoute(this, model, tools, sendOpts, messages, async (wire, history, opts) => {
+      if (wire === 'responses') {
+        // OpenAI-family brands on the gateway (Muse Spark, GPT, Grok)
+        // only answer on /responses; the compat transport switches wire
+        // shape per request via this flag.
+        return this.openai.send(history, model, tools, { ...opts, compatWireApi: 'responses' });
+      }
+      if (wire === 'messages') {
+        // The Anthropic-style Go endpoint reports cached read/write usage
+        // and accepts the standard message shape. Preserve the caller's
+        // cache strategy so the shared Anthropic live-tail marker advances
+        // through tool loops instead of forcing every request fully cold.
+        // Abandoned attempts noted by the inner provider use the same conversion.
+        return withInclusiveUsage(() => this.anthropic.send(history, model, tools, opts));
       }
+      if (wire === 'gemini') return (await this._geminiEngine()).send(history, model, tools, opts);
+      return this.openai.send(history, model, tools, opts);
+    });
+  }
+
+  // The Gemini generateContent route; the Google SDK loads only when a Gemini model is used.
+  async _geminiEngine() {
+    if (!this.gemini) {
+      const { OpenCodeGoGeminiEngine } = await import('./opencode-go-gemini.mjs');
+      this.gemini = new OpenCodeGoGeminiEngine({
+        ...this.config,
+        baseURL: this.openai.baseURL,
+        extraHeaders: { ...(OPENAI_COMPAT_PRESETS['opencode-go'].extraHeaders || {}), ...(this.config.extraHeaders || {}) },
+      });
     }
-    return this.openai.send(messages, model, tools, sendOpts);
+    return this.gemini;
+  }
+
+  resolveWireRoute(model, ctx = {}) {
+    return resolveOpenCodeGoWireRoute(model, { ...ctx, override: this.config?.modelWires?.[model] ?? null });
   }
 
   async listModels() {

package/src/runtime/agent/orchestrator/providers/openrouter.mjs

@@ -0,0 +1,75 @@
+/**
+ * OpenRouter: one API key, three wires. Claude (`anthropic/*`, `~anthropic/*`)
+ * goes through the Anthropic Messages engine at https://openrouter.ai/api (the
+ * SDK appends /v1/messages); OpenAI GPT / o-series (`openai/gpt-*`,
+ * `openai/o*`, `~openai/*`) through the OpenAI-compatible engine's Responses
+ * wire; openrouter/auto and every other model through Chat Completions.
+ * Account-level provider-routing preferences stay OpenRouter's: no request
+ * names a provider order.
+ */
+import { WireGatewayProvider, messagesBaseFromOpenAIBase } from './wire-gateway.mjs';
+import { OPENAI_COMPAT_PRESETS } from './openai-compat-presets.mjs';
+import { openRouterReasoning } from './openai-compat-options.mjs';
+
+/**
+ * The Claude id a routing slug stands for: an alias (`~anthropic/claude-opus-latest`)
+ * reads its catalog `alias_target`, the vendor prefix and a `:variant` suffix
+ * drop. Capability lookup only — the request still names the routing slug.
+ */
+export function openRouterCapabilityModel(model, aliasTarget = null) {
+  return String(aliasTarget || model || '')
+    .replace(/^~/, '')
+    .replace(/^anthropic\//i, '')
+    .replace(/:[^/]*$/, '');
+}
+
+// Responses requests carry the same reasoning control as Chat requests
+// (`openRouterReasoningEffort`, else the turn effort, else the configured
+// effort; `none` disables reasoning).
+function openRouterResponsesParams(config) {
+  return (params, { opts }) => {
+    const reasoning = openRouterReasoning(opts, config);
+    if (reasoning) params.reasoning = reasoning;
+    else delete params.reasoning;
+  };
+}
+
+// The Messages route takes the same control: the effort to send ('none' = no
+// thinking), or null to keep the engine's own handling.
+function openRouterMessagesEffort(config) {
+  return (opts) => {
+    const reasoning = openRouterReasoning(opts, config);
+    if (!reasoning) return null;
+    return reasoning.enabled === false ? 'none' : reasoning.effort;
+  };
+}
+
+/** A roster row carrying `top_provider.max_completion_tokens` as its output ceiling. */
+export function withTopProviderOutputCeiling(item) {
+  const ceiling = Number(item?.top_provider?.max_completion_tokens);
+  if (!(ceiling > 0) || item.max_output_tokens !== undefined) return item;
+  return { ...item, max_output_tokens: ceiling };
+}
+
+export class OpenRouterProvider extends WireGatewayProvider {
+  constructor(config = {}) {
+    const baseURL = config.baseURL || OPENAI_COMPAT_PRESETS.openrouter.baseURL;
+    super(
+      'openrouter',
+      config,
+      {
+        baseURL: messagesBaseFromOpenAIBase(baseURL),
+        authScheme: 'bearer',
+        // OpenRouter Messages takes PDFs natively as document blocks.
+        nativePdf: true,
+        messagesEffort: openRouterMessagesEffort(config),
+        capabilityModel: (model) => openRouterCapabilityModel(model, this.getCachedModelInfo(model)?.aliasTarget),
+      },
+      { responsesParamsHook: openRouterResponsesParams(config) }
+    );
+    // The roster's output ceiling is `top_provider.max_completion_tokens`.
+    const fetchItems = this.openai._fetchModelItems.bind(this.openai);
+    this.openai._fetchModelItems = async (options) =>
+      (await fetchItems(options)).map(withTopProviderOutputCeiling);
+  }
+}

package/src/runtime/agent/orchestrator/providers/provider-error-kind.mjs

@@ -37,6 +37,26 @@ export function boundedCauseChain(err) {
   return chain;
 }
 
+const TOOL_SURFACE_EXCEEDS_CONTEXT = 'TOOL_SURFACE_EXCEEDS_CONTEXT';
+const TOOL_SURFACE_MARKER = `(${TOOL_SURFACE_EXCEEDS_CONTEXT})`;
+
+/**
+ * The local fixed-overhead refusal (session/loop/context-overflow.mjs), bare,
+ * wrapped as a cause, or persisted as its text. Never a provider overflow:
+ * its diagnostic names tools, and a tool named like a provider error code
+ * must not turn it into one.
+ */
+export function isToolSurfaceExceedsContextError(err) {
+  if (!err || (typeof err !== 'string' && typeof err !== 'object' && typeof err !== 'function')) return false;
+  // Every node of the chain: an Error, or persisted failure text kept as a cause.
+  return boundedCauseChain(err).some((item) =>
+    typeof item === 'string'
+      ? item.includes(TOOL_SURFACE_MARKER)
+      : item?.code === TOOL_SURFACE_EXCEEDS_CONTEXT ||
+        (typeof item?.message === 'string' && item.message.includes(TOOL_SURFACE_MARKER))
+  );
+}
+
 export function headerValue(headers, name) {
   if (!headers) return null;
   const lower = name.toLowerCase();
@@ -78,6 +98,8 @@ export function errorHeaderValue(err, name) {
 
 export function typedErrorCode(err) {
   const detail = wireDetail(err);
+  const canonical = err && typeof err === 'object' ? codeFields(err).canonical.find(Boolean) : null;
+  if (canonical) return canonical;
   for (const field of [detail?.code, detail?.type, err?.providerErrorCode, err?.code, err?.error?.code]) {
     if (typeof field === 'string' && field.trim()) return field.trim().toLowerCase();
   }
@@ -375,9 +397,66 @@ const KIND_RANK = [
   'invalid_request',
 ];
 
+// OpenRouter's canonical `error_type` vocabulary, stable across its Chat,
+// Responses and Messages skins (the native code beside it is lossy: on
+// Responses an auth failure arrives as `server_error`, a context overflow as
+// `invalid_prompt`), mapped onto the typed codes classified here.
+const GATEWAY_ERROR_TYPE_CODES = Object.freeze({
+  authentication: 'authentication_error',
+  permission_denied: 'permission_denied',
+  payment_required: 'payment_required',
+  context_length_exceeded: 'context_length_exceeded',
+  payload_too_large: 'payload_too_large',
+  image_too_large: 'request_too_large',
+  rate_limit_exceeded: 'rate_limit_exceeded',
+  provider_overloaded: 'overloaded',
+  provider_unavailable: 'service_unavailable',
+  timeout: 'timeout',
+  server: 'server_error',
+  content_policy_violation: 'content_policy_violation',
+  refusal: 'content_policy_violation',
+  invalid_request: 'invalid_request',
+  invalid_prompt: 'invalid_request',
+  unprocessable: 'invalid_request',
+  not_found: 'not_found',
+  precondition_failed: 'failed_precondition',
+});
+
+/** The typed code a gateway `error_type` names, or null for an absent/unmapped one. */
+export function gatewayErrorTypeCode(errorType) {
+  const key = typeof errorType === 'string' ? errorType.trim().toLowerCase() : '';
+  return key && Object.hasOwn(GATEWAY_ERROR_TYPE_CODES, key) ? GATEWAY_ERROR_TYPE_CODES[key] : null;
+}
+
+/**
+ * Pre-classification normalizer for a wire error detail: when the envelope
+ * (or the detail itself) carries a gateway `error_type`, its typed code
+ * replaces the lossy native code (kept as `native_code`). Any other detail is
+ * returned unchanged.
+ */
+export function normalizeGatewayErrorDetail(detail, envelope = null) {
+  const errorType =
+    envelope?.response?.error_type ?? envelope?.error_type ?? detail?.error_type ?? detail?.metadata?.error_type;
+  const code = gatewayErrorTypeCode(errorType);
+  if (!code) return detail;
+  const nativeCode = detail?.code;
+  return {
+    ...(detail && typeof detail === 'object' ? detail : {}),
+    code,
+    error_type: errorType,
+    ...(nativeCode != null && nativeCode !== code ? { native_code: nativeCode } : {}),
+  };
+}
+
 function codeFields(item) {
   const detail = wireDetail(item);
-  return [
+  const canonical = [
+    gatewayErrorTypeCode(detail?.error_type ?? detail?.metadata?.error_type),
+    gatewayErrorTypeCode(item?.error_type),
+    gatewayErrorTypeCode(item?.error?.error_type ?? item?.error?.metadata?.error_type),
+    gatewayErrorTypeCode(item?.error?.error?.error_type),
+  ];
+  const native = [
     detail?.code,
     detail?.type,
     detail?.status,
@@ -396,19 +475,25 @@ function codeFields(item) {
     item?.geminiStatus,
     item?.status,
   ];
+  return { canonical, native };
 }
 
+// A gateway's canonical `error_type` supersedes every native code in the chain.
 function typedCodes(chain) {
-  const codes = [];
+  const canonical = [];
+  const native = [];
+  const add = (codes, field) => {
+    if (typeof field !== 'string') return;
+    const code = field.trim().toLowerCase();
+    if (code && !codes.includes(code)) codes.push(code);
+  };
   for (const item of chain) {
     if (!item || typeof item !== 'object') continue;
-    for (const field of codeFields(item)) {
-      if (typeof field !== 'string') continue;
-      const code = field.trim().toLowerCase();
-      if (code && !codes.includes(code)) codes.push(code);
-    }
+    const fields = codeFields(item);
+    for (const field of fields.canonical) add(canonical, field);
+    for (const field of fields.native) add(native, field);
   }
-  return codes;
+  return canonical.length ? canonical : native;
 }
 
 const VALID_STATUS = (n) => Number.isFinite(n) && n >= 100 && n <= 599;
@@ -421,6 +506,53 @@ function statusOf(err) {
   return 0;
 }
 
+// OpenRouter answers a 402 with this marker when concurrent in-flight spend is
+// capped; it clears as requests finish (Retry-After), unlike a spent balance.
+const IN_FLIGHT_BUDGET = 'openrouter_in_flight_budget';
+
+const IN_FLIGHT_BUDGET_MAX_WAIT_MS = 60_000;
+
+// Retry-After advice for the budget exception: a valid `0` ("retry now") is
+// advice here, although retryAfterMsFromError treats zero as none.
+function inFlightAdviceMs(err) {
+  const advised = retryAfterMsFromError(err);
+  if (advised != null) return advised;
+  for (const [name, unitMs] of [['retry-after-ms', 1], ['retry-after', 1000]]) {
+    const value = errorHeaderValue(err, name);
+    const n = Number(value);
+    if (value != null && String(value).trim() !== '' && Number.isFinite(n) && n >= 0) return n * unitMs;
+  }
+  return null;
+}
+
+// Only a 402 that names the marker AND carries Retry-After advice of 0..60s
+// inclusive is a wait; without advice (or with a long one) it stays billing.
+function isInFlightBudget402(chain, status, adviceMs) {
+  if (status !== 402 || adviceMs == null || adviceMs > IN_FLIGHT_BUDGET_MAX_WAIT_MS) return false;
+  return chain.some((item) => {
+    if (!item || typeof item !== 'object') return false;
+    const detail = wireDetail(item);
+    return [
+      detail?.code,
+      detail?.type,
+      detail?.metadata?.code,
+      detail?.metadata?.type,
+      detail?.metadata?.reason,
+      detail?.metadata?.limit_source,
+      item.code,
+      item.type,
+      item.error?.code,
+      item.error?.type,
+      item.error?.metadata?.code,
+      item.error?.metadata?.type,
+      item.error?.metadata?.reason,
+      item.error?.metadata?.limit_source,
+      item.error?.error?.code,
+      item.error?.error?.type,
+    ].some((value) => typeof value === 'string' && value.trim().toLowerCase() === IN_FLIGHT_BUDGET);
+  });
+}
+
 function kindFromStatus(status) {
   if (status === 401) return 'auth';
   if (status === 402) return 'billing';
@@ -513,10 +645,17 @@ export function providerErrorKind(err, options = {}) {
   const codes = typedCodes(chain);
   const describe = (kind, code = typedErrorCode(err)) => ({ kind, code: code || '', status, retryAfterMs, resetAt });
 
+  // A local fixed-overhead refusal is no provider kind, whatever its text names.
+  if (isToolSurfaceExceedsContextError(err)) return describe('unknown', TOOL_SURFACE_EXCEEDS_CONTEXT);
   // Validated account-pool evidence and boundary-stamped re-auth decide first.
   if (err.quotaExhausted && typeof err.quotaExhausted === 'object') return describe('quota_exhausted');
   if (chain.some((item) => item?.reauthRequired === true)) return describe('auth');
 
+  if (isInFlightBudget402(chain, status, inFlightAdviceMs(err))) return describe('transient', IN_FLIGHT_BUDGET);
+  // Every other 402 is a billing refusal, whatever generic retryable code
+  // (server_error, rate_limit_exceeded) its body also carries.
+  if (status === 402) return describe('billing');
+
   let { kind, code } = kindFromCodes(codes, scope);
   // Explicit quota flags (Anthropic unified-status rejected headers) outrank a
   // generic rate-limit code or status; they never turn an overload (or a more

package/src/runtime/agent/orchestrator/providers/registry.mjs

@@ -179,6 +179,9 @@ const PROVIDER_MODULES = {
   openai: ['./openai-ws.mjs', 'OpenAIDirectProvider'],
   'mixdog-local': ['./mixdog-local.mjs', 'MixdogLocalProvider'],
   'opencode-go': ['./opencode-go.mjs', 'OpenCodeGoProvider'],
+  // Multi-wire preset gateways (wire-route.mjs picks the wire per model).
+  openrouter: ['./openrouter.mjs', 'OpenRouterProvider'],
+  deepseek: ['./deepseek.mjs', 'DeepSeekProvider'],
 };
 
 // User-defined providers (cfg.type === 'custom') are keyed by a generated
@@ -209,7 +212,7 @@ async function instantiateProvider(name, Ctor, cfg, proxyChannel = null) {
     return wrapProviderAdmission(createModelProxyProvider(name, cfg, proxyChannel ?? getModelProxyChannel()), name);
   }
   if (isCustomProviderConfig(name, cfg)) return wrapProviderAdmission(await Ctor(name, cfg), name);
-  if (Object.hasOwn(OPENAI_COMPAT_PRESETS, name) && name !== 'opencode-go') {
+  if (Object.hasOwn(OPENAI_COMPAT_PRESETS, name) && !Object.hasOwn(PROVIDER_MODULES, name)) {
     return wrapProviderAdmission(new Ctor(name, cfg), name);
   }
   return createAccountPoolProvider(name, () => wrapProviderAdmission(new Ctor(cfg), name));

package/src/runtime/agent/orchestrator/providers/retry-classification.mjs

@@ -10,6 +10,7 @@ import {
   TOKEN_CONTEXT_OVERFLOW_PATTERNS,
   TRANSIENT_SDK_NAMES,
   boundedCauseChain,
+  isToolSurfaceExceedsContextError,
   isTransientErrorCode,
   providerErrorKind,
   typedCodeKind,
@@ -463,6 +464,10 @@ const REQUEST_TOO_LARGE_KIND = 'request_too_large';
  */
 export function isContextOverflowError(err, _depth = 0) {
   if (!err || _depth > 2) return false;
+  // A local fixed-overhead refusal (anywhere in the chain, at any recursion
+  // level) is never a provider overflow: compacting history cannot help it,
+  // whatever its text names.
+  if (isToolSurfaceExceedsContextError(err)) return false;
   const code = typedErrorCode(err);
   if (code && CONTEXT_OVERFLOW_CODES.has(code)) return true;
   // A typed byte/media-size refusal (a size code, or HTTP 413 without a

package/src/runtime/agent/orchestrator/providers/transport-scope.d.mts

@@ -0,0 +1,6 @@
+export const TRANSPORT_SCOPE_DISPOSED: 'transport_scope_disposed';
+export function forkTransportScope(sessionId: string, label?: string): string;
+export function disposeTransportScope(
+  scope: string,
+  provider?: { releaseTransportScope?(scope: string): void } | null
+): void;

package/src/runtime/agent/orchestrator/providers/transport-scope.mjs

@@ -0,0 +1,28 @@
+// transport-scope.mjs — a send's transport state scope, apart from its
+// session identity. Providers key their session-scoped transport and
+// continuation state (pooled sockets and their previous_response_id anchor,
+// Codex turn-state routing tokens, sticky HTTP fallback, Cursor runs and
+// conversations) by `opts.transportScope || opts.sessionId`, while prompt
+// cache routing (prompt_cache_key, handshake session id) stays on
+// `opts.sessionId`. A request forked from a session (/btw) runs in a scope of
+// its own: it shares the session's prompt cache but reads and writes none of
+// its transport state, and its scope is disposed once it is answered.
+import { randomUUID } from 'node:crypto';
+
+/** The reason a scope's provider connections are closed when it is disposed. */
+export const TRANSPORT_SCOPE_DISPOSED = 'transport_scope_disposed';
+
+/** A fresh transport scope for one request forked from `sessionId`. */
+export function forkTransportScope(sessionId, label = 'fork') {
+  return `${sessionId}#${label}:${randomUUID()}`;
+}
+
+/** Close every connection and drop every transport record of `scope`. */
+export function disposeTransportScope(scope, provider) {
+  if (!scope) return;
+  try {
+    globalThis.__mixdogCloseProviderConnectionsForSession?.(scope, TRANSPORT_SCOPE_DISPOSED);
+  } finally {
+    provider?.releaseTransportScope?.(scope);
+  }
+}