mixdog 0.9.50 → 0.9.52

package/src/runtime/agent/orchestrator/providers/openai-ws-pool.mjs

@@ -36,7 +36,9 @@ const OPENAI_WS_URL = 'wss://api.openai.com/v1/responses';
 const XAI_WS_URL = 'wss://api.x.ai/v1/responses';
 export const WS_IDLE_MS = resolveTimeoutMs(
     'MIXDOG_PROVIDER_WS_IDLE_MS',
-    20 * 60_000,
+    // Codex keeps its cached connection until the backend's documented
+    // 60-minute Responses WebSocket connection limit.
+    60 * 60_000,
     { minMs: 60_000, maxMs: 60 * 60_000 },
 );
 const WS_HANDSHAKE_TIMEOUT_MS = PROVIDER_WS_HANDSHAKE_TIMEOUT_MS;
@@ -67,6 +69,44 @@ const MAX_POOLED_SOCKETS_PER_KEY = 8;
 //          lastRequestInput, lastResponseItems, lastInputLen, turnState,
 //          closing, ephemeral }
 const _wsPool = new Map();
+let _releaseSequence = 0;
+
+function _poolCompatibility(auth, cacheKey) {
+    const type = String(auth?.type || 'openai-oauth');
+    // Prefer the stable OAuth account id so an access-token refresh can keep
+    // using the same connection. If it is unavailable, fail closed to the
+    // credential itself; a refresh then opens a new socket rather than risking
+    // cross-account continuation.
+    const credentialIdentity = auth?.account_id || auth?.apiKey || auth?.access_token || '';
+    return {
+        authIdentity: createHash('sha256')
+            .update(`${type}\0${String(credentialIdentity)}`)
+            .digest('hex'),
+        cacheKeyIdentity: String(cacheKey || ''),
+    };
+}
+
+function _entryCompatible(entry, compatibility) {
+    return entry?.authIdentity === compatibility.authIdentity
+        && entry?.cacheKeyIdentity === compatibility.cacheKeyIdentity;
+}
+
+// A previous_response_id is valid on the connection that produced it. When
+// concurrency temporarily creates sibling sockets for one pool key, continue
+// on the most recently completed sibling instead of whichever socket happened
+// to be inserted first. This is the closest representation of Codex's
+// turn-local single-connection ownership without weakening the existing
+// full-frame fallback checks.
+function _selectIdleEntry(entries, compatibility) {
+    let selected;
+    for (const entry of entries || []) {
+        if (entry?.busy || !_entryCompatible(entry, compatibility)) continue;
+        if (!selected || (entry.releaseSequence || 0) > (selected.releaseSequence || 0)) {
+            selected = entry;
+        }
+    }
+    return selected;
+}
 
 // --- Cache-route probe state (2026-07-04 hunt) -----------------------------
 // CF cookie stickiness (codex chatgpt_cloudflare_cookies.rs:22-55 persists
@@ -696,6 +736,8 @@ function _openSocket({ auth, sessionToken, turnState, externalSignal, cacheKey,
     });
 }
 
+let _openSocketImpl = _openSocket;
+
 export async function acquireWebSocket({ auth, poolKey, cacheKey, codexHeaders, forceFresh, externalSignal }) {
     const _acqStart = Date.now();
     if (process.env.MIXDOG_DEBUG_AGENT) {
@@ -707,9 +749,16 @@ export async function acquireWebSocket({ auth, poolKey, cacheKey, codexHeaders,
     }
     if (poolKey && !forceFresh) {
         const arr = _wsPool.get(poolKey) || [];
-        // Prune dead entries first.
+        const compatibility = _poolCompatibility(auth, cacheKey);
+        // Prune dead entries and idle sockets from an obsolete auth/cache
+        // boundary. Busy incompatible entries are left alone until their owner
+        // releases them, but can never be selected by this acquire.
         for (let i = arr.length - 1; i >= 0; i--) {
-            if (!_isOpen(arr[i]) || arr[i].closing) {
+            const incompatibleIdle = !arr[i].busy && !_entryCompatible(arr[i], compatibility);
+            if (!_isOpen(arr[i]) || arr[i].closing || incompatibleIdle) {
+                if (incompatibleIdle) {
+                    try { arr[i].socket.close(1000, 'pool_boundary_changed'); } catch {}
+                }
                 _clearIdle(arr[i]);
                 _clearLiveness(arr[i]);
                 arr.splice(i, 1);
@@ -721,7 +770,7 @@ export async function acquireWebSocket({ auth, poolKey, cacheKey, codexHeaders,
         // bound before hand-out; a dead one is evicted and the scan retries the
         // next idle entry so a busy caller is never handed a wedged socket.
         let idle;
-        while ((idle = arr.find(e => !e.busy))) {
+        while ((idle = _selectIdleEntry(arr, compatibility))) {
             _clearIdle(idle);
             _clearLiveness(idle);
             // Reserve the entry BEFORE awaiting the probe: _pingProbe yields the
@@ -760,7 +809,7 @@ export async function acquireWebSocket({ auth, poolKey, cacheKey, codexHeaders,
                 process.stderr.write(`[agent-trace] acquire-ephemeral cacheKey=${cacheKey} reason=cap elapsed=${Date.now() - _acqStart}ms\n`);
             }
             const ephSessionToken = _mintSessionToken(cacheKey, auth);
-            const { socket, turnState } = await _openSocket({ auth, sessionToken: ephSessionToken, turnState: null, externalSignal, cacheKey, codexHeaders });
+            const { socket, turnState } = await _openSocketImpl({ auth, sessionToken: ephSessionToken, turnState: null, externalSignal, cacheKey, codexHeaders });
             // Drain-complete fence: same invariant as the normal acquire path —
             // if drain fired during the await, do NOT push an ephemeral entry
             // back into the pool.
@@ -778,6 +827,8 @@ export async function acquireWebSocket({ auth, poolKey, cacheKey, codexHeaders,
                 lastResponseItems: null,
                 lastInputLen: 0,
                 lastInputPrefixHash: null,
+                releaseSequence: 0,
+                ...compatibility,
                 turnState: turnState || null,
                 closing: false,
                 ephemeral: true,
@@ -797,10 +848,17 @@ export async function acquireWebSocket({ auth, poolKey, cacheKey, codexHeaders,
     // returns "No tool output found for function call …". turnState only
     // propagates within a single entry across its own iterations.
     const sessionToken = _mintSessionToken(cacheKey, auth);
+    const compatibility = _poolCompatibility(auth, cacheKey);
     if (process.env.MIXDOG_DEBUG_AGENT) {
         process.stderr.write(`[agent-trace] acquire-new tokenHash=${createHash('sha256').update(String(sessionToken)).digest('hex').slice(0, 8)} elapsed=${Date.now() - _acqStart}ms\n`);
     }
-    const { socket, turnState } = await _openSocket({ auth, sessionToken, turnState: null, externalSignal, cacheKey, codexHeaders });
+    const { socket, turnState } = await _openSocketImpl({ auth, sessionToken, turnState: null, externalSignal, cacheKey, codexHeaders });
+    // Drain may complete while the normal handshake is awaiting 'open'. Never
+    // return or insert that late socket into the already-drained process pool.
+    if (_drainComplete) {
+        try { socket.close(1000, 'drain-complete'); } catch {}
+        throw new Error('WS pool drained — process exiting');
+    }
     const entry = {
         socket,
         busy: true,
@@ -811,6 +869,8 @@ export async function acquireWebSocket({ auth, poolKey, cacheKey, codexHeaders,
         lastResponseItems: null,
         lastInputLen: 0,
         lastInputPrefixHash: null,
+        releaseSequence: 0,
+        ...compatibility,
         turnState: turnState || null,
         closing: false,
         ephemeral: false,
@@ -840,6 +900,7 @@ export function releaseWebSocket({ entry, poolKey, keep }) {
     // Mark activity at release, then arm both the idle-close timer and the
     // periodic liveness ping so a socket that dies while pooled is evicted
     // before the next acquire can hand it out.
+    entry.releaseSequence = ++_releaseSequence;
     entry.lastAliveAt = Date.now();
     _scheduleIdleClose(poolKey, entry);
     if (WS_PING_ENABLED) _armLiveness(poolKey, entry);
@@ -848,6 +909,48 @@ export function releaseWebSocket({ entry, poolKey, keep }) {
     _setTransportReferenced(entry, false);
 }
 
+export function closeOpenaiWsPoolForSession(poolKey, reason = 'session_closed') {
+    if (!poolKey) return;
+    const entries = _wsPool.get(poolKey);
+    if (!entries) return;
+    _wsPool.delete(poolKey);
+    for (const entry of entries) {
+        _clearIdle(entry);
+        _clearLiveness(entry);
+        try { entry.socket.close(1000, reason); } catch {}
+    }
+}
+
+// Focused pool lifecycle test seam. Entries still pass through the production
+// release/acquire code; this only avoids a live provider handshake.
+export function _seedWebSocketEntryForTest({ poolKey, auth, cacheKey, entry }) {
+    Object.assign(entry, _poolCompatibility(auth, cacheKey));
+    if (entry.releaseSequence === undefined) entry.releaseSequence = 0;
+    _getPoolArr(poolKey).push(entry);
+    return entry;
+}
+
+export function _clearWebSocketPoolForTest() {
+    for (const arr of _wsPool.values()) {
+        for (const entry of arr) {
+            _clearIdle(entry);
+            _clearLiveness(entry);
+            try { entry.socket.close(1000, 'test_cleanup'); } catch {}
+        }
+    }
+    _wsPool.clear();
+    _releaseSequence = 0;
+}
+
+export function _setOpenSocketForTest(fn) {
+    _openSocketImpl = typeof fn === 'function' ? fn : _openSocket;
+}
+
+export function _resetOpenSocketDrainForTest() {
+    _openSocketImpl = _openSocket;
+    _drainComplete = false;
+}
+
 // Drain-complete fence — set true once _closeAllPooledSockets runs so any
 // in-flight acquire that resumes after drain throws instead of pushing a
 // fresh socket into the cleared pool. Single-set, process-lifetime invariant.
@@ -871,4 +974,6 @@ export function _closeAllPooledSockets(reason = 'shutdown') {
     _wsPool.clear();
 }
 export const drainOpenaiWsPool = _closeAllPooledSockets;
+globalThis.__mixdogCloseProviderConnectionsForSession = closeOpenaiWsPoolForSession;
+globalThis.__mixdogDrainProviderConnections = drainOpenaiWsPool;
 process.on('exit', drainOpenaiWsPool);

package/src/runtime/agent/orchestrator/providers/openai-ws-stream.mjs

@@ -23,6 +23,7 @@ import { populateHttpStatusFromMessage } from './retry-classifier.mjs';
 import { makeInvalidToolArgsMarker } from './openai-compat-stream.mjs';
 import { createLeakGuard, createToolCallDedupe, dedupeToolCallList } from './anthropic-leaked-toolcall.mjs';
 import {
+    PROVIDER_FIRST_BYTE_TIMEOUT_MS,
     PROVIDER_WS_INTER_CHUNK_TIMEOUT_MS,
     PROVIDER_SSE_IDLE_WATCHDOG_ENABLED,
     PROVIDER_WS_FIRST_MEANINGFUL_TIMEOUT_MS,
@@ -91,8 +92,8 @@ export function _positiveInt(value, fallback = 0) {
 export const WS_PRE_RESPONSE_CREATED_MS = (() => {
     const raw = process.env.MIXDOG_PROVIDER_WS_PRE_RESPONSE_CREATED_TIMEOUT_MS;
     const n = Number(raw);
-    if (Number.isFinite(n) && n > 0) return Math.min(Math.max(n, 1_000), 120_000);
-    return 10_000;
+    if (Number.isFinite(n) && n > 0) return Math.min(Math.max(n, 1_000), PROVIDER_FIRST_BYTE_TIMEOUT_MS);
+    return PROVIDER_FIRST_BYTE_TIMEOUT_MS;
 })();
 // Single inter-chunk idle timer. Resets on EVERY received frame — any frame,
 // including metadata/keepalive, proves the socket is live.
@@ -866,12 +867,14 @@ export async function _streamResponse({
                     // Only non-empty reasoning text is model progress. Empty
                     // deltas remain transport activity via resetIdle() above.
                     if (event.delta) {
+                        midState.emittedReasoning = true;
                         try { onStreamDelta?.('reasoning'); } catch {}
                         bumpSemanticIdle();
                     }
                     break;
                 case 'response.output_item.added':
                     if (event.item?.type === 'function_call') {
+                        midState.startedToolCall = true;
                         markActiveToolItem(event.item);
                         pendingCalls.set(event.item.id || '', {
                             name: event.item.name || '',
@@ -879,9 +882,11 @@ export async function _streamResponse({
                         });
                         _toolInFlight = true;
                     } else if (event.item?.type === 'custom_tool_call') {
+                        midState.startedToolCall = true;
                         markActiveToolItem(event.item);
                         _toolInFlight = true;
                     } else if (event.item?.type === 'tool_search_call') {
+                        midState.startedToolCall = true;
                         markActiveToolItem(event.item);
                         // Mark tool_search in-flight at item-added time, same
                         // as function_call/custom_tool_call above, so the
@@ -897,12 +902,14 @@ export async function _streamResponse({
                     try { onStreamDelta?.(_toolInFlight ? 'tool' : 'semantic'); } catch {}
                     break;
                 case 'response.function_call_arguments.delta':
+                    if (event.delta) midState.startedToolCall = true;
                     markActiveToolItem(null, event.item_id);
                     _toolInFlight = true;
                     try { onStreamDelta?.('tool'); } catch {}
                     bumpSemanticIdle();
                     break;
                 case 'response.custom_tool_call_input.delta':
+                    if (event.delta) midState.startedToolCall = true;
                     markActiveToolItem(null, event.item_id);
                     _toolInFlight = true;
                     try { onStreamDelta?.('tool'); } catch {}
@@ -1271,6 +1278,7 @@ export async function _streamResponse({
                         // Only non-empty reasoning deltas are model progress;
                         // empty variants remain transport activity only.
                         if (event.delta) {
+                            midState.emittedReasoning = true;
                             try { onStreamDelta?.('reasoning'); } catch {}
                             bumpSemanticIdle();
                         }
@@ -1369,21 +1377,9 @@ export async function _streamResponse({
         }
         armPreStreamWatchdog();
         armFirstMeaningfulWatchdog();
-        // Periodic client-side WS ping while the stream is active. The server's
-        // server closes with 1011 "keepalive ping timeout" when it thinks the
-        // peer is silent during long reasoning windows where no data frames
-        // flow. Sending a ping every 10s from our side keeps the socket warm.
-        // The interval is unref'd so it never holds the event loop open, and
-        // cleanup() clears it on every terminal path (completed / close /
-        // error / abort / mid-stream retry teardown).
-        keepaliveTimer = setInterval(() => {
-            try {
-                if (socket.readyState !== WebSocket.OPEN) return;
-                if (WS_TRACE_ENABLED) _writeWsLifecycleTrace('ping');
-                socket.ping();
-            } catch {}
-        }, 10_000);
-        try { keepaliveTimer.unref?.(); } catch {}
+        // No proactive client ping: Codex's Responses WebSocket uses the
+        // library default (automatic pong replies, no periodic client ping).
+        // Incoming frames remain bounded by the 300s stream idle timeout.
     });
 }
 

package/src/runtime/agent/orchestrator/providers/openai-ws.mjs

@@ -43,6 +43,53 @@ export function applyOpenAIDirectFastTier(body, model, opts) {
     return body;
 }
 
+function shouldFallbackDirectTransport(err, options) {
+    const status = Number(err?.httpStatus || err?.status || 0);
+    const unsafeToRetry = err?.liveTextEmitted === true
+        || err?.emittedToolCall === true
+        || err?.unsafeToRetry === true;
+    if (unsafeToRetry || options?.signal?.aborted || options?.enabled === false) return false;
+    // Public OpenAI can reject the WebSocket upgrade while still supporting
+    // the same request over HTTP/SSE. Only the shared transport's explicit
+    // handshake marker may turn these application-looking statuses into a
+    // one-shot transport fallback.
+    if (err?.wsFailurePhase === 'handshake'
+        && err?.wsHttpFallbackEligible === true
+        && [403, 404, 429].includes(status)) {
+        return true;
+    }
+    // These are application/auth/quota outcomes from the public Responses API,
+    // not evidence that WebSocket transport is unhealthy. Reissuing them over
+    // HTTP cannot recover and can duplicate an accepted throttled request.
+    if (status >= 400 && status < 500) return false;
+    return shouldFallbackTransport(err, options);
+}
+
+function directOpenAiHandshakeErrorPolicy({ status }) {
+    if ([403, 404, 429].includes(Number(status))) {
+        return { retry: false, httpFallback: true };
+    }
+    return null;
+}
+
+const DIRECT_WS_TEST_SEAM_KEYS = Object.freeze([
+    '_acquireWithRetryFn',
+    '_streamFn',
+    '_sendFrameFn',
+    '_sleepFn',
+    '_sendSpanTraceFn',
+    '_agentTraceFn',
+]);
+
+function directWebSocketTestSeams(value) {
+    if (!value || typeof value !== 'object') return {};
+    const out = {};
+    for (const key of DIRECT_WS_TEST_SEAM_KEYS) {
+        if (typeof value[key] === 'function') out[key] = value[key];
+    }
+    return out;
+}
+
 export class OpenAIDirectProvider {
     // input_tokens INCLUDES cached tokens (OpenAI convention). See registry.mjs.
     static inputExcludesCache = false;
@@ -56,7 +103,7 @@ export class OpenAIDirectProvider {
         if (!k) throw new Error('OPENAI_API_KEY not configured (providers.openai.apiKey)');
         return k;
     }
-    // Auth-recovery mirror of openai-compat.reloadApiKey: on a 401/403 the key
+    // Auth-recovery mirror of openai-compat.reloadApiKey: on a 401 the key
     // was likely rotated after this provider instance was built, so re-read
     // only OpenAI's environment/keychain sources before the single retry.
     // Returns the fresh key (or null if none) — no client to rebuild here since
@@ -140,7 +187,18 @@ export class OpenAIDirectProvider {
             iteration,
             useModel,
         };
-        const dispatchWs = (a) => sendViaWebSocket({
+        // Keep the same deterministic transport seams as openai-oauth. Besides
+        // making the direct path regression-testable without a live request,
+        // this lets embedded callers supply their already-instrumented
+        // Responses transports without changing the public request envelope.
+        const sendWs = typeof opts._sendViaWebSocketFn === 'function'
+            ? opts._sendViaWebSocketFn
+            : sendViaWebSocket;
+        const sendHttp = typeof opts._sendViaHttpSseFn === 'function'
+            ? opts._sendViaHttpSseFn
+            : sendViaHttpSse;
+        const wsTestSeams = directWebSocketTestSeams(opts._webSocketTestSeams);
+        const dispatchWs = (a) => sendWs({
             ...common,
             auth: a,
             sendOpts: opts,
@@ -151,12 +209,18 @@ export class OpenAIDirectProvider {
             // the OAuth/Codex handshake headers. Direct API-key auth pins its own
             // provider so it stays on the public (non-Codex) envelope.
             traceProvider: 'openai-direct',
+            // Narrow deterministic seams for transport-policy regression tests.
+            // Production callers never set this object.
+            ...wsTestSeams,
+            // Mandatory and deliberately applied AFTER sanitized test seams:
+            // no caller can disable or invert direct handshake provenance.
+            handshakeErrorPolicy: directOpenAiHandshakeErrorPolicy,
         });
         // WS→HTTP/SSE fallback mirrors the openai-oauth wrapper: the shared
         // HTTP transport now accepts auth.type==='openai-direct' (public
         // Responses endpoint + Bearer <apiKey>), so the api-key provider gets
-        // the same envelope. Gate via shouldFallbackTransport (denies
-        // 401/403/404/429 + liveTextEmitted/emittedToolCall/unsafeToRetry).
+        // the same envelope. The direct gate denies every application 4xx and
+        // any liveTextEmitted/emittedToolCall/unsafeToRetry outcome.
         const transportPolicy = resolveOpenAiTransportPolicy();
         const httpFallbackEnabled = transportPolicy.allowHttpFallback
             && _envFlag('MIXDOG_OPENAI_HTTP_FALLBACK', true);
@@ -164,7 +228,7 @@ export class OpenAIDirectProvider {
             if (!process.env.MIXDOG_QUIET_PROVIDER_LOG) {
                 process.stderr.write('[openai-ws] WebSocket unhealthy; falling back to HTTP/SSE\n');
             }
-            return sendViaHttpSse({ ...common, auth: a, opts, fetchFn: opts._fetchFn });
+            return sendHttp({ ...common, auth: a, opts, fetchFn: opts._fetchFn });
         };
         // Transport-policy switch (MIXDOG_OAI_TRANSPORT). 'http-sse' forces the
         // HTTP/SSE transport directly — no WS attempt, so skip the fallback log
@@ -172,7 +236,7 @@ export class OpenAIDirectProvider {
         // ('auto'/'ws-full'/'ws-delta') keep the WS-first path below; ws-full vs
         // ws-delta only affects the delta gate inside openai-ws-delta.mjs.
         if (transportPolicy.transport === 'http') {
-            return await sendViaHttpSse({ ...common, auth, opts, fetchFn: opts._fetchFn });
+            return await sendHttp({ ...common, auth, opts, fetchFn: opts._fetchFn });
         }
         try {
             return await dispatchWs(auth);
@@ -183,10 +247,12 @@ export class OpenAIDirectProvider {
             const unsafeToRetry = err?.liveTextEmitted === true
                 || err?.emittedToolCall === true
                 || err?.unsafeToRetry === true;
-            // (1) 401/403 → reload only OpenAI auth and retry once over WS.
-            //     shouldFallbackTransport denies 401/403, so this branch owns
-            //     its own guard.
-            if ((status === 401 || status === 403) && !unsafeToRetry) {
+            // (1) 401 → reload only OpenAI auth and retry once over WS.
+            // Ordinary 403 is a permission/policy decision, not evidence that
+            // an API key rotated. Match the OAuth path and keep it terminal.
+            // The direct fallback guard denies auth statuses, so this branch
+            // owns the single credential-reload replay.
+            if (status === 401 && err?.wsFailurePhase !== 'stream' && !unsafeToRetry) {
                 process.stderr.write(`[openai-ws] ${status} — reloading apiKey and retrying once\n`);
                 const freshKey = this.reloadApiKey();
                 if (freshKey) {
@@ -194,7 +260,7 @@ export class OpenAIDirectProvider {
                     try {
                         return await dispatchWs(retryAuth);
                     } catch (retryErr) {
-                        if (shouldFallbackTransport(retryErr, { signal: externalSignal, enabled: httpFallbackEnabled })) {
+                        if (shouldFallbackDirectTransport(retryErr, { signal: externalSignal, enabled: httpFallbackEnabled })) {
                             return await dispatchHttp(retryAuth);
                         }
                         throw retryErr;
@@ -204,7 +270,7 @@ export class OpenAIDirectProvider {
             }
             // (2) WS transport failure → HTTP/SSE fallback (predicate handles
             //     the safety denies).
-            if (shouldFallbackTransport(err, { signal: externalSignal, enabled: httpFallbackEnabled })) {
+            if (shouldFallbackDirectTransport(err, { signal: externalSignal, enabled: httpFallbackEnabled })) {
                 return await dispatchHttp(auth);
             }
             throw err;

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

@@ -20,11 +20,44 @@ const OPENCODE_GO_CONTEXT_WINDOWS = Object.freeze({
     'glm-5': 202752,
 });
 
-function isAnthropicGoModel(model) {
+export function isAnthropicGoModel(model) {
     const id = String(model || '').toLowerCase();
     return ANTHROPIC_MODEL_PREFIXES.some(prefix => id.startsWith(prefix));
 }
 
+export function resolveOpenCodeGoBaseURLs(configuredBaseURL) {
+    const presetBase = OPENAI_COMPAT_PRESETS['opencode-go'].baseURL;
+    const openai = String(configuredBaseURL || presetBase).replace(/\/+$/, '');
+    // Anthropic's SDK appends `/v1/messages` itself. Supplying the OpenAI base
+    // (`.../v1`) would therefore produce the invalid `.../v1/v1/messages`.
+    const anthropic = openai.replace(/\/v1$/i, '');
+    return { openai, anthropic };
+}
+
+export function openCodeGoEndpointForModel(model, configuredBaseURL) {
+    const bases = resolveOpenCodeGoBaseURLs(configuredBaseURL);
+    return isAnthropicGoModel(model)
+        ? `${bases.anthropic}/v1/messages`
+        : `${bases.openai}/chat/completions`;
+}
+
+export function normalizeOpenCodeGoResultUsage(result, anthropicRoute) {
+    if (!anthropicRoute || !result?.usage) return result;
+    const usage = result.usage;
+    const input = Number(usage.inputTokens) || 0;
+    const cached = Number(usage.cachedTokens) || 0;
+    const cacheWrite = Number(usage.cacheWriteTokens) || 0;
+    const inclusiveInput = input + cached + cacheWrite;
+    return {
+        ...result,
+        usage: {
+            ...usage,
+            inputTokens: inclusiveInput,
+            promptTokens: Math.max(Number(usage.promptTokens) || 0, inclusiveInput),
+        },
+    };
+}
+
 function opencodeGoContextWindow(_modelId, current = 0) {
     const native = Number(current);
     if (Number.isFinite(native) && native > 0) return native;
@@ -46,24 +79,29 @@ function opencodeGoReasoningLevels(model, current = null) {
 export class OpenCodeGoProvider {
     static inputExcludesCache = false;
     name = 'opencode-go';
+    config;
     openai;
     anthropic;
 
     constructor(config = {}) {
+        // Retain the outer account config for the common provider-admission
+        // lane. The delegated transports are intentionally not independently
+        // wrapped, so all model-family routes share this one 64-wide account.
+        this.config = config;
         const preset = OPENAI_COMPAT_PRESETS['opencode-go'];
-        const baseURL = config.baseURL || preset.baseURL;
-        this.openai = new OpenAICompatProvider('opencode-go', { ...config, baseURL });
+        const bases = resolveOpenCodeGoBaseURLs(config.baseURL || preset.baseURL);
+        this.openai = new OpenAICompatProvider('opencode-go', { ...config, baseURL: bases.openai });
         this.anthropic = new AnthropicProvider({
             ...config,
             name: 'opencode-go',
-            baseURL,
+            baseURL: bases.anthropic,
             disableBetaHeaders: true,
         });
     }
 
     async send(messages, model, tools, sendOpts) {
         if (isAnthropicGoModel(model)) {
-            return this.anthropic.send(messages, model, tools, {
+            const result = await this.anthropic.send(messages, model, tools, {
                 ...(sendOpts || {}),
                 cacheStrategy: {
                     tools: 'none',
@@ -72,6 +110,7 @@ export class OpenCodeGoProvider {
                     messages: 'none',
                 },
             });
+            return normalizeOpenCodeGoResultUsage(result, true);
         }
         return this.openai.send(messages, model, tools, sendOpts);
     }

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

@@ -5,6 +5,7 @@ import {
     hasGrokOAuthCredentials,
 } from './oauth-credential-probes.mjs';
 import { refreshCatalog as refreshMetadataCatalog, warmModelMetadataCatalogs } from './model-catalog.mjs';
+import { wrapProviderAdmission } from './admission-scheduler.mjs';
 // OpenAI-compat provider names are self-declared by openai-compat-presets.mjs via
 // OPENAI_COMPAT_PRESETS. No parallel list maintained here.
 const providers = new Map();
@@ -15,6 +16,7 @@ const providerModulePromises = new Map();
 // byte identical to the live one, so lazy-init misses that re-run initProviders
 // don't churn (tear down + rebuild) every live provider instance on every call.
 const signatures = new Map();
+const KNOWN_INPUT_EXCLUDES_CACHE = new Set(['anthropic', 'anthropic-oauth']);
 
 // Module-level init serialization. agent-tool.mjs's ensureProvider() already
 // serializes inits per provider on a chain promise, but its gateOnPrior() lets
@@ -108,9 +110,9 @@ async function loadProviderCtor(name, signal = null) {
 
 function instantiateProvider(name, Ctor, cfg) {
     if (Object.prototype.hasOwnProperty.call(OPENAI_COMPAT_PRESETS, name) && name !== 'opencode-go') {
-        return new Ctor(name, cfg);
+        return wrapProviderAdmission(new Ctor(name, cfg), name);
     }
-    return new Ctor(cfg);
+    return wrapProviderAdmission(new Ctor(cfg), name);
 }
 
 export async function initProviders(config, { signal = null } = {}) {
@@ -232,21 +234,21 @@ export function getProvider(name) {
     if (name === 'anthropic-oauth' && hasAnthropicOAuthCredentials()) {
         const Ctor = providerCtors.get('anthropic-oauth');
         if (!Ctor) return undefined;
-        const inst = new Ctor({});
+        const inst = wrapProviderAdmission(new Ctor({}), name);
         providers.set(name, inst);
         return inst;
     }
     if (name === 'openai-oauth' && hasOpenAIOAuthCredentials()) {
         const Ctor = providerCtors.get('openai-oauth');
         if (!Ctor) return undefined;
-        const inst = new Ctor({});
+        const inst = wrapProviderAdmission(new Ctor({}), name);
         providers.set(name, inst);
         return inst;
     }
     if (name === 'grok-oauth' && hasGrokOAuthCredentials()) {
         const Ctor = providerCtors.get('grok-oauth');
         if (!Ctor) return undefined;
-        const inst = new Ctor({});
+        const inst = wrapProviderAdmission(new Ctor({}), name);
         providers.set(name, inst);
         return inst;
     }
@@ -261,15 +263,54 @@ export function getProvider(name) {
 // provider states its own answer — no central regex to keep in sync. Unknown /
 // unregistered providers default to false (the openai/gemini majority).
 export function providerInputExcludesCache(name) {
-    const p = getProvider(name);
-    if (p?.constructor?.inputExcludesCache === true) return true;
-    return String(name || '').toLowerCase().includes('anthropic');
+    const normalized = String(name || '').toLowerCase();
+    // Usage accounting is a pure lookup. In particular, never call
+    // getProvider() here: its OAuth miss path probes credentials and may lazily
+    // instantiate/register a provider.
+    const p = providers.get(normalized);
+    if (p?.constructor && typeof p.constructor.inputExcludesCache === 'boolean') {
+        return p.constructor.inputExcludesCache;
+    }
+    // A constructor may already be loaded even when the provider is currently
+    // absent during a route/config transition. Preserve its declaration, but
+    // never infer usage semantics from an arbitrary provider-name substring.
+    const Ctor = providerCtors.get(normalized);
+    if (Ctor && typeof Ctor.inputExcludesCache === 'boolean') {
+        return Ctor.inputExcludesCache;
+    }
+    // Built-in usage semantics must also be correct before lazy construction
+    // (including disabled providers in a fresh process).
+    return KNOWN_INPUT_EXCLUDES_CACHE.has(normalized);
 }
 export function getAllProviders() {
     // Defensive copy — callers must not mutate the live registry or retain
     // stale entries across re-init (initProviders rebuilds the map in place).
     return new Map(providers);
 }
+// Narrow synchronous test seam for the lazy-OAuth boundary. It models a
+// constructor whose module is already loaded while guaranteeing every touched
+// registry entry is restored, even when the assertion callback throws.
+export function _withLoadedProviderCtorForTest(name, Ctor, fn) {
+    const hadProvider = providers.has(name);
+    const priorProvider = providers.get(name);
+    const hadCtor = providerCtors.has(name);
+    const priorCtor = providerCtors.get(name);
+    const hadSignature = signatures.has(name);
+    const priorSignature = signatures.get(name);
+    providers.delete(name);
+    signatures.delete(name);
+    providerCtors.set(name, Ctor);
+    try {
+        return fn();
+    } finally {
+        if (hadProvider) providers.set(name, priorProvider);
+        else providers.delete(name);
+        if (hadCtor) providerCtors.set(name, priorCtor);
+        else providerCtors.delete(name);
+        if (hadSignature) signatures.set(name, priorSignature);
+        else signatures.delete(name);
+    }
+}
 // Background catalog warm-up. Each provider's listModels() either hits its
 // own cached model list (no-op) or fires a single HTTP refresh. Called from
 // agent.init() after providers are registered so the first agent dispatch call