mixdog 0.9.1 → 0.9.3

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

@@ -29,13 +29,17 @@ import {
     traceAgentUsage,
 } from '../agent-trace.mjs';
 import {
-    PROVIDER_GENERATE_TOTAL_TIMEOUT_MS,
     PROVIDER_HTTP_RESPONSE_TIMEOUT_MS,
+    PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS,
+    PROVIDER_SSE_IDLE_WATCHDOG_ENABLED,
+    streamStalledError,
     createTimeoutSignal,
+    createPassthroughSignal,
 } from '../stall-policy.mjs';
 import { populateHttpStatusFromMessage, shouldFallbackTransport } from './retry-classifier.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 import { makeInvalidToolArgsMarker } from './openai-compat-stream.mjs';
+import { createLeakGuard, createToolCallDedupe, dedupeToolCallList } from './anthropic-leaked-toolcall.mjs';
 import {
     normalizeContentForOpenAIResponses,
     splitToolContentForOpenAIResponses,
@@ -52,14 +56,13 @@ const CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
 const CODEX_OAUTH_ORIGINATOR = 'codex_cli_rs';
 const TOKEN_URL = 'https://auth.openai.com/oauth/token';
 const CODEX_RESPONSES_URL = 'https://chatgpt.com/backend-api/codex/responses';
-// Version string baked into the models endpoint query — the OAuth backend rejects the
-// request without it. Keep close to the latest published @openai/codex CLI because
-// older versions trigger a visibility-filtered catalog (e.g. only rollout
-// models). Bump when the real CLI bumps.
-// OpenAI OAuth backend gates new model exposures (e.g. gpt-5.5 only on >= 0.130.0)
-// on the client_version header. Resolve dynamically from npm so newly-shipped
-// models surface within a day instead of waiting on a hardcoded bump here.
-// Cached 24h in-process; npm failure falls back to the floor below.
+// Version string baked into the models endpoint query — the OAuth backend
+// rejects the request without it, and gates new model exposures (e.g.
+// gpt-5.5 only on >= 0.130.0) on this client_version header; older versions
+// trigger a visibility-filtered catalog (e.g. only rollout models). Resolved
+// dynamically from npm so newly-shipped models surface within a day instead
+// of waiting on a hardcoded bump here. Cached 24h in-process; npm failure
+// falls back to the floor below.
 const CODEX_CLIENT_VERSION_FLOOR = '0.130.0';
 const CODEX_VERSION_CACHE_TTL_MS = 24 * 60 * 60_000;
 let _codexVersionCache = { value: null, fetchedAt: 0 };
@@ -160,6 +163,17 @@ function _displayCodexModel(id) {
     return id.replace(/-\d{4}-\d{2}-\d{2}$/, '');
 }
 
+function _positiveCodexContextWindow(value) {
+    const n = Number(value);
+    return Number.isFinite(n) && n > 0 ? Math.floor(n) : null;
+}
+
+function _codexContextWindowFromApi(m) {
+    return _positiveCodexContextWindow(m?.context_window)
+        || _positiveCodexContextWindow(m?.max_context_window)
+        || null;
+}
+
 function _normalizeCodexModel(m) {
     const id = m?.slug || m?.id;
     const family = _codexFamily(id);
@@ -182,8 +196,8 @@ function _normalizeCodexModel(m) {
         display: m?.display_name || id,
         family,
         provider: 'openai-oauth',
-        contextWindow: m?.context_window || m?.max_context_window || 1000000,
-        maxContextWindow: m?.max_context_window || null,
+        contextWindow: _codexContextWindowFromApi(m),
+        maxContextWindow: _positiveCodexContextWindow(m?.max_context_window),
         outputTokens: m?.max_output_tokens || m?.output_tokens || 32768,
         autoCompactTokenLimit: m?.auto_compact_token_limit || null,
         effectiveContextWindowPercent: m?.effective_context_window_percent || null,
@@ -572,7 +586,7 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
         providerState: opts.providerState,
         model,
     });
-    // Match the body shape pi-mono and the official OpenAI CLI ship so the
+    // Match the request body shape the OAuth backend expects so the
     // server-side auto-cache routes correctly. text.verbosity / include /
     // tool_choice / parallel_tool_calls are all inert without side effects
     // for most callers but their presence affects how the OAuth backend classifies the
@@ -603,8 +617,8 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
     if (opts.fast === true) {
         // 'priority' is the only fast-class value the OpenAI OAuth backend
         // accepts on the wire: 'fast' is hard-rejected ("Unsupported
-        // service_tier: fast", probed 2026-06-11). Match official CLI behavior:
-        // only send the request value when the model catalog advertises it.
+        // service_tier: fast", probed 2026-06-11). Only send the request value
+        // when the model catalog advertises it.
         if (codexModelSupportsServiceTier(model, 'priority')) {
             body.service_tier = 'priority';
         }
@@ -654,8 +668,8 @@ function _envPositiveInt(name, fallback) {
 }
 
 // Completed function_call.arguments parse for the OpenAI Responses stream.
-// Native convergence (openai-oauth / anthropic-oauth / opencode): a function_call item
-// arrives only on a completion/done signal, so a non-empty-but-malformed
+// A function_call item arrives only on a completion/done signal, so a
+// non-empty-but-malformed
 // arguments string is deterministic bad JSON — NOT mid-stream truncation.
 // Empty/whitespace input legitimately means "no arguments" → {}. A non-empty
 // string that fails JSON.parse is surfaced as an invalid-args MARKER (instead
@@ -773,11 +787,20 @@ export async function sendViaHttpSse({
     useModel,
     fetchFn = fetch,
 } = {}) {
-    const totalTimeout = createTimeoutSignal(
-        externalSignal,
-        PROVIDER_GENERATE_TOTAL_TIMEOUT_MS,
-        'OpenAI OAuth HTTP fallback total',
-    );
+    // P1 audit fix: no fixed wall-clock total cap on the HTTP/SSE fallback
+    // stream. The old createTimeoutSignal(..., PROVIDER_GENERATE_TOTAL_TIMEOUT_MS)
+    // killed a healthy, still-streaming turn purely on elapsed time, unlike
+    // every other streaming provider path (anthropic-oauth uses the same
+    // createPassthroughSignal pattern — see anthropic-oauth.mjs "Option A").
+    // The stream is bounded instead by:
+    //   (a) headerTimeout below (PROVIDER_HTTP_RESPONSE_TIMEOUT_MS) for a
+    //       socket that never sends the initial response,
+    //   (b) the SEMANTIC idle watchdog (_armSemanticIdle /
+    //       PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS), which resets on every
+    //       meaningful() chunk — a live stream stays alive, a truly silent
+    //       one still aborts, and
+    //   (c) externalSignal (client disconnect / replaced-by-newer-request).
+    const totalTimeout = createPassthroughSignal(externalSignal);
     const headerTimeout = createTimeoutSignal(
         totalTimeout.signal,
         PROVIDER_HTTP_RESPONSE_TIMEOUT_MS,
@@ -851,6 +874,33 @@ export async function sendViaHttpSse({
         if (totalTimeout.signal.aborted) _onTotalAbort();
         else totalTimeout.signal.addEventListener('abort', _onTotalAbort, { once: true });
     }
+    // SEMANTIC idle watchdog: reset ONLY on meaningful() (text/reasoning/tool
+    // deltas), never on raw bytes/keepalive frames, so a stream that emits some
+    // deltas then goes silent trips a short, named terminal failure instead of
+    // hanging until the 30-min agent watchdog. Disablable via the shared env.
+    let _semanticIdleTimer = null;
+    const _clearSemanticIdle = () => {
+        if (_semanticIdleTimer) { clearTimeout(_semanticIdleTimer); _semanticIdleTimer = null; }
+    };
+    const _armSemanticIdle = () => {
+        if (!PROVIDER_SSE_IDLE_WATCHDOG_ENABLED || !(PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS > 0)) return;
+        _clearSemanticIdle();
+        _semanticIdleTimer = setTimeout(() => {
+            _streamAbortReason = streamStalledError('OpenAI OAuth HTTP fallback', PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS, { emittedToolCall: emittedToolCallIds.size > 0 });
+            // Partial-final recovery: attach the
+            // streamed partial state so the agent loop can accept a wedged FINAL
+            // no-tool summary as a successful partial-final instead of dropping
+            // the result. pendingToolUse gates out any mid-flight tool call.
+            try {
+                _streamAbortReason.partialContent = content;
+                _streamAbortReason.partialToolCalls = toolCalls.length ? toolCalls.slice() : undefined;
+                _streamAbortReason.pendingToolUse = pendingCalls.size > 0 || emittedToolCallIds.size > 0;
+                _streamAbortReason.partialModel = model || undefined;
+            } catch { /* best-effort enrichment */ }
+            try { reader.cancel(_streamAbortReason).catch(() => {}); } catch {}
+        }, PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS);
+        try { _semanticIdleTimer.unref?.(); } catch {}
+    };
     let buffer = '';
     let content = '';
     let model = '';
@@ -885,13 +935,75 @@ export async function sendViaHttpSse({
     // first complete frame still emits; only redundant re-emits are
     // suppressed.
     const emittedToolCallIds = new Set();
+    // Fix 2: cross-path name+args dedupe. A text-leaked synthetic and an
+    // identical native function_call must fire onToolCall exactly once.
+    const _toolDedupe = createToolCallDedupe();
     const emitToolCall = (call) => {
         if (!call || !call.id) return;
         if (emittedToolCallIds.has(call.id)) return;
         emittedToolCallIds.add(call.id);
+        if (!_toolDedupe.shouldDispatch(call.name, call.arguments)) return;
         try { onToolCall?.(call); } catch {}
     };
 
+    // Leaked tool-call guard. The model sometimes emits a tool call as plain
+    // text (XML `<invoke>`/`<function_calls>` or gpt-oss harmony
+    // `<|channel|>...to=functions.NAME...<|call|>`) inside
+    // `response.output_text.delta` instead of a native function_call. Route
+    // text through the guard so leaked calls are suppressed from the visible
+    // stream, synthesized (native `call_...` id shape), and dispatched like
+    // native ones. Known tool names come from the request body so recovery
+    // only fires for tools the model was actually offered. Additive: the
+    // native function_call path is untouched.
+    const _leakKnownTools = new Set(
+        (Array.isArray(body?.tools) ? body.tools : [])
+            .map((t) => (typeof t?.name === 'string' ? t.name : null))
+            .filter(Boolean),
+    );
+    const leakGuard = createLeakGuard({ knownToolNames: _leakKnownTools, harmony: true });
+    const dispatchLeakedCall = (recovered) => {
+        let args = recovered?.arguments;
+        if (args === null || typeof args !== 'object' || Array.isArray(args)) args = {};
+        const call = {
+            id: `call_leaked_${randomBytes(8).toString('hex')}`,
+            name: recovered.name,
+            arguments: args,
+        };
+        toolCalls.push(call);
+        emitToolCall(call);
+    };
+    const relayLeakText = (delta) => {
+        if (!leakGuard.enabled) {
+            content += delta || '';
+            if (delta && onTextDelta) {
+                emittedText = true;
+                try { onTextDelta(delta); } catch {}
+            }
+            return;
+        }
+        const { text, calls } = leakGuard.push(delta);
+        if (text) {
+            content += text;
+            if (onTextDelta) {
+                emittedText = true;
+                try { onTextDelta(text); } catch {}
+            }
+        }
+        for (const c of calls) dispatchLeakedCall(c);
+    };
+    const flushLeak = () => {
+        if (!leakGuard.enabled) return;
+        const { text, calls } = leakGuard.flush();
+        if (text) {
+            content += text;
+            if (onTextDelta) {
+                emittedText = true;
+                try { onTextDelta(text); } catch {}
+            }
+        }
+        for (const c of calls) dispatchLeakedCall(c);
+    };
+
     const pushWebSearchCall = (item) => {
         if (!item || item.type !== 'web_search_call') return;
         const key = item.id || JSON.stringify(item.action || item);
@@ -939,6 +1051,7 @@ export async function sendViaHttpSse({
     };
     const meaningful = () => {
         if (ttftMs == null) ttftMs = Date.now() - sseStartedAt;
+        _armSemanticIdle();
         try { onStreamDelta?.(); } catch {}
     };
     const handleEvent = (event) => {
@@ -949,12 +1062,8 @@ export async function sendViaHttpSse({
                 if (event.response?.id) responseId = event.response.id;
                 break;
             case 'response.output_text.delta':
-                content += event.delta || '';
                 meaningful();
-                if (event.delta && onTextDelta) {
-                    emittedText = true;
-                    try { onTextDelta(event.delta); } catch {}
-                }
+                relayLeakText(event.delta || '');
                 break;
             case 'response.reasoning_text.delta':
             case 'response.reasoning_summary_text.delta':
@@ -966,6 +1075,22 @@ export async function sendViaHttpSse({
                         name: event.item.name || '',
                         callId: event.item.call_id || '',
                     });
+                } else if (event.item?.type === 'tool_search_call') {
+                    // Mark tool_search as in-flight the moment the item is
+                    // added, mirroring function_call above, so the semantic
+                    // idle watchdog's pendingToolUse gate (pendingCalls.size)
+                    // sees a mid-flight tool_search and never lets stall
+                    // recovery drop it before response.output_item.done.
+                    // kind:'tool_search' tags the entry so the shared
+                    // function_call_arguments.done handler (below) never
+                    // mistakes it for a function call by id collision/empty id.
+                    if (event.item.id) {
+                        pendingCalls.set(event.item.id, {
+                            name: 'tool_search',
+                            callId: event.item.call_id || '',
+                            kind: 'tool_search',
+                        });
+                    }
                 }
                 break;
             case 'response.function_call_arguments.delta':
@@ -974,6 +1099,7 @@ export async function sendViaHttpSse({
             case 'response.function_call_arguments.done': {
                 const itemId = event.item_id || '';
                 const pending = pendingCalls.get(itemId);
+                if (pending?.kind === 'tool_search') { meaningful(); break; }
                 const call = {
                     id: pending?.callId || event.call_id || '',
                     name: pending?.name || event.name || '',
@@ -1006,6 +1132,7 @@ export async function sendViaHttpSse({
                         }
                     }
                 } else if (item.type === 'tool_search_call') {
+                    pendingCalls.delete(item.id || '');
                     pushToolSearchCall(item);
                 } else if (item.type === 'custom_tool_call') {
                     pushCustomToolCall(item);
@@ -1030,7 +1157,20 @@ export async function sendViaHttpSse({
                 for (const item of resp.output || []) {
                     if (item.type === 'message') {
                         for (const part of item.content || []) {
-                            if (!content && part.type === 'output_text') content += part.text || '';
+                            if (!content && part.type === 'output_text') {
+                                // Completed-output fallback (no streamed text).
+                                // Route through the leak guard so a tool call
+                                // leaked only in the final bundle is recovered
+                                // rather than surfaced as visible content. push
+                                // with final=true flushes fully (no held tail).
+                                if (leakGuard.enabled) {
+                                    const { text, calls } = leakGuard.push(part.text || '', true);
+                                    content += text;
+                                    for (const c of calls) dispatchLeakedCall(c);
+                                } else {
+                                    content += part.text || '';
+                                }
+                            }
                             if (part.type === 'output_text') _pushOutputTextAnnotations(part, citations, citationKeys);
                         }
                     } else if (item.type === 'reasoning') {
@@ -1116,10 +1256,12 @@ export async function sendViaHttpSse({
 
     try {
         while (true) {
-            if (totalTimeout.signal.aborted) {
+            if (totalTimeout.signal?.aborted) {
+                _clearSemanticIdle();
                 const reason = totalTimeout.signal.reason;
                 throw reason instanceof Error ? reason : new Error('OpenAI OAuth HTTP fallback aborted');
             }
+            if (_streamAbortReason) throw _streamAbortReason;
             const { value, done } = await reader.read();
             if (done) break;
             buffer += decoder.decode(value, { stream: true });
@@ -1140,12 +1282,16 @@ export async function sendViaHttpSse({
             const event = _parseSseFrame(frame);
             if (event) handleEvent(event);
         }
+        // Flush any partial-sentinel tail held back mid-stream so legitimate
+        // trailing text is never lost (streamed-text path).
+        flushLeak();
     } catch (err) {
         // Live-text invariant: once a non-empty chunk has been relayed it
         // cannot be withdrawn — flag the error so no upstream layer retries.
         if (emittedText && err) { try { err.liveTextEmitted = true; err.unsafeToRetry = true; } catch {} }
         throw err;
     } finally {
+        _clearSemanticIdle();
         try { reader.releaseLock?.(); } catch {}
         if (_onTotalAbort && totalTimeout.signal) {
             try { totalTimeout.signal.removeEventListener('abort', _onTotalAbort); } catch {}
@@ -1186,15 +1332,27 @@ export async function sendViaHttpSse({
             serviceTier,
         });
     }
+    // Dedupe the returned array by name+args (Fix 2, array side): a synthetic
+    // leaked call and an identical native function_call must not both survive,
+    // else the agent loop executes the side-effecting tool twice.
+    const _returnedToolCalls = toolCalls.length
+        ? dedupeToolCallList(toolCalls.map(({ _pendingItemId, ...t }) => t))
+        : undefined;
     return {
         content,
         model: liveModel,
         reasoningItems: reasoningItems.length ? reasoningItems : undefined,
-        toolCalls: toolCalls.length ? toolCalls.map(({ _pendingItemId, ...t }) => t) : undefined,
+        toolCalls: _returnedToolCalls,
         citations: citations.length ? citations : undefined,
         webSearchCalls: webSearchCalls.length ? webSearchCalls : undefined,
         usage: usage || undefined,
         stopReason: stopReason || undefined,
+        // P1 audit fix: text-only max-output cutoff (openai-oauth HTTP/SSE
+        // fallback maps status:'incomplete'/reason=max_output_tokens to
+        // stopReason='length' above and treats it as success). Flag it so
+        // loop.mjs can surface a truncation warning instead of accepting
+        // silently-cut content as a clean final answer.
+        ...(stopReason === 'length' && content.length > 0 ? { truncated: true } : {}),
         responseId: responseId || undefined,
         serviceTier: serviceTier || undefined,
     };
@@ -1328,8 +1486,8 @@ export class OpenAIOAuthProvider {
         const onTextDelta = typeof opts.onTextDelta === 'function' ? opts.onTextDelta : null;
         const externalSignal = opts.signal || null;
         const _sendSessionId = opts.sessionId || '(none)';
-        const _sendRole = opts.role || '(none)';
-        if (process.env.MIXDOG_DEBUG_AGENT) { process.stderr.write(`[agent-trace] auth-start sessionHash=${createHash('sha256').update(String(_sendSessionId)).digest('hex').slice(0, 8)} role=${_sendRole} expiringInMs=${this.tokens?.expires_at ? this.tokens.expires_at - Date.now() : 'unknown'}\n`); }
+        const _sendAgent = opts.agent || '(none)';
+        if (process.env.MIXDOG_DEBUG_AGENT) { process.stderr.write(`[agent-trace] auth-start sessionHash=${createHash('sha256').update(String(_sendSessionId)).digest('hex').slice(0, 8)} agent=${_sendAgent} expiringInMs=${this.tokens?.expires_at ? this.tokens.expires_at - Date.now() : 'unknown'}\n`); }
         // Build request body in parallel with auth resolution. ensureAuth is
         // a no-op fast-path on cached tokens, but a refresh round-trip can
         // take 300ms+; the body build (message serialisation) overlaps cleanly.
@@ -1389,6 +1547,26 @@ export class OpenAIOAuthProvider {
             this._forceHttpFallback = true;
             this._forceHttpFallbackUntil = Date.now() + ttlMs;
         };
+        const traceWsError = (err, stage = 'primary') => {
+            try {
+                appendAgentTrace({
+                    sessionId: poolKey,
+                    iteration,
+                    kind: 'transport_error',
+                    provider: 'openai-oauth',
+                    model: useModel,
+                    transport: 'websocket',
+                    payload: {
+                        stage,
+                        error_code: err?.code || null,
+                        error_http_status: Number(err?.httpStatus || 0) || null,
+                        error_classifier: err?.retryClassifier || err?.midstreamClassifier || null,
+                        live_text_emitted: err?.liveTextEmitted === true || err?.unsafeToRetry === true,
+                        message: String(err?.message || err || '').slice(0, 500),
+                    },
+                });
+            } catch {}
+        };
         const dispatchHttp = async (reason, originalErr = null, { sticky = false } = {}) => {
             appendAgentTrace({
                 sessionId: poolKey,
@@ -1411,7 +1589,7 @@ export class OpenAIOAuthProvider {
                     process.stderr.write('[openai-oauth] WebSocket bypassed (forced); using HTTP/SSE\n');
                 }
             } else {
-                process.stderr.write(`[openai-oauth] WebSocket unhealthy (${reason}); falling back to HTTP/SSE\n`);
+                if (!process.env.MIXDOG_QUIET_PROVIDER_LOG) process.stderr.write(`[openai-oauth] WebSocket unhealthy (${reason}); falling back to HTTP/SSE\n`);
             }
             const result = await sendHttp({
                 auth,
@@ -1459,11 +1637,12 @@ export class OpenAIOAuthProvider {
         // Prefer WebSocket for hot cache/delta transport; fall back to HTTP/SSE
         // after retry-exhausted handshake/acquire/no-first-event failures.
         try {
-            if (process.env.MIXDOG_DEBUG_AGENT) { process.stderr.write(`[agent-trace] provider-send-start model=${useModel} role=${_sendRole} sessionHash=${createHash('sha256').update(String(_sendSessionId)).digest('hex').slice(0, 8)} iteration=${iteration ?? '(none)'}\n`); }
+            if (process.env.MIXDOG_DEBUG_AGENT) { process.stderr.write(`[agent-trace] provider-send-start model=${useModel} agent=${_sendAgent} sessionHash=${createHash('sha256').update(String(_sendSessionId)).digest('hex').slice(0, 8)} iteration=${iteration ?? '(none)'}\n`); }
             const result = await dispatchWs(false);
             if (process.env.MIXDOG_DEBUG_AGENT) { process.stderr.write(`[agent-trace] provider-send-end elapsed=${Date.now() - _t1}ms result=ok\n`); }
             return recordLiveModel(result);
         } catch (err) {
+            traceWsError(err, 'primary');
             const status = err?.httpStatus;
             // Live-text invariant: if the WS attempt already relayed a
             // non-empty text chunk to the client, NO recovery path may reissue
@@ -1482,6 +1661,7 @@ export class OpenAIOAuthProvider {
                     if (process.env.MIXDOG_DEBUG_AGENT) { process.stderr.write(`[agent-trace] provider-send-end elapsed=${Date.now() - _t1}ms result=ok\n`); }
                     return recordLiveModel(result);
                 } catch (retryErr) {
+                    traceWsError(retryErr, 'auth_retry');
                     if (_shouldUseOpenAIHttpFallback(retryErr, externalSignal)) {
                         try {
                             return await dispatchHttp(

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

@@ -71,6 +71,24 @@ export class OpenAIDirectProvider {
         // so gpt-5.4-mini can opt into Priority even when the OAuth catalog does
         // not advertise a Fast tier for its OAuth endpoint.
         applyOpenAIDirectFastTier(body, useModel, opts);
+        // P0 audit fix: buildRequestBody (openai-oauth.mjs) defaults
+        // store:false (env-gated, MIXDOG_OAI_STORE), which is correct for
+        // the openai-oauth ChatGPT-subscription backend — that backend keeps
+        // its own conversation state via the WS handshake session_id
+        // (see openai-oauth-ws.mjs "conversation slot ... in-memory prefix
+        // state"), independent of the public Responses API `store` field.
+        // The public OpenAI direct WS path below, however, talks to the real
+        // api.openai.com Responses API, where `previous_response_id`
+        // continuation is only valid when the anchored response was actually
+        // stored — store:false + previous_response_id is a broken
+        // combination there (the server has nothing to look up). This
+        // provider's WS transport always injects previous_response_id via
+        // openai-oauth-ws.mjs's delta path once a response id is cached, so
+        // force store:true here — same override xAI's Responses path takes
+        // (see openai-compat.mjs _doSendXaiResponses/_doSendXaiResponsesWebSocket:
+        // "the public endpoint currently returns previous_response_not_found
+        // ... unless the chain is stored").
+        body.store = true;
         // Public Responses API supports prompt_cache_retention='24h' at no
         // extra cost (same cached_input_tokens billing as the default 5–10
         // min in-memory cache). openai-oauth rejects the parameter, so it's

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

@@ -1,8 +1,9 @@
-import { existsSync, readFileSync, mkdirSync } from 'node:fs';
-import * as fsp from 'node:fs/promises';
+import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { updateJsonAtomicSync } from '../../../shared/atomic-file.mjs';
 import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
 import { getOpenCodeGoAuthCookie } from '../../../shared/config.mjs';
+import { round, cleanString as clean } from './lib/usage-primitives.mjs';
 
 const CACHE_FILE = 'opencode-go-usage-cache.json';
 const LIVE_TTL_MS = 5 * 60_000;
@@ -18,23 +19,14 @@ const LIMITS_USD = Object.freeze({
 const DISK_JSON_MEMORY_TTL_MS = 1000;
 let diskJsonCache = { at: 0, file: '', value: null };
 
+// Local unguarded `num`: this module intentionally coerces '' to 0 via
+// Number(''), unlike the guarded shared num() in lib/usage-primitives.mjs.
+// Behavior differs on empty-string input, so it stays local.
 function num(value, fallback = null) {
   const n = Number(value);
   return Number.isFinite(n) ? n : fallback;
 }
 
-function round(value, digits = 4) {
-  const n = Number(value);
-  if (!Number.isFinite(n)) return null;
-  const scale = 10 ** digits;
-  return Math.round(n * scale) / scale;
-}
-
-function clean(value) {
-  const text = typeof value === 'string' ? value.trim() : '';
-  return text || null;
-}
-
 function cachePath() {
   return join(resolvePluginData(), CACHE_FILE);
 }
@@ -53,12 +45,18 @@ function readJson(file) {
   }
 }
 
+// Synchronous atomic+lock write (updateJsonAtomicSync) instead of the prior
+// fire-and-forget fsp.writeFile: this cache is single-entry (one snapshot
+// per file, no cross-process merge), so the lock protects against a torn
+// write racing readers, not a lost-update merge. Only one write happens
+// per successful fetch (TTL-gated, at most once per LIVE_TTL_MS), so the
+// switch off async has no meaningful latency impact on the request path.
 function writeJson(file, value) {
-  diskJsonCache = { at: Date.now(), file, value };
+  let next = null;
   try {
-    mkdirSync(resolvePluginData(), { recursive: true });
-    void fsp.writeFile(file, JSON.stringify(value, null, 2), 'utf8').catch(() => {});
+    next = updateJsonAtomicSync(file, () => value, { lock: true, fsyncDir: true, timeoutMs: 1000 }); // best-effort cache write: short lock timeout, don't block on contention
   } catch {}
+  if (next) diskJsonCache = { at: Date.now(), file, value: next }; // only mirror on confirmed write, avoid phantom cache on lock timeout
 }
 
 function freshSnapshot(snapshot, ttlMs) {
@@ -243,7 +241,41 @@ export function openCodeGoUsageConfigStatus(config = {}) {
   };
 }
 
+// Primary discovery: GET /auth with the auth cookie, follow-manual. The
+// console redirects authenticated sessions straight to /workspace/{id};
+// unauthenticated/invalid cookies redirect to /auth/authorize instead.
+// This avoids depending on the hashed server-fn id used by the /_server
+// probe (WORKSPACES_SERVER_ID), which can change across console deploys.
+async function fetchWorkspaceIdFromAuthRedirect(authCookie, { signal } = {}) {
+  let res;
+  try {
+    res = await fetch(`${BASE_URL}/auth`, {
+      signal,
+      redirect: 'manual',
+      headers: requestHeaders(authCookie),
+    });
+  } catch {
+    return null; // network/redirect-mode quirk: let the _server fallback decide
+  }
+  if (res.status === 401 || res.status === 403) {
+    const err = new Error('OpenCode Go console auth failed');
+    err.code = 'OPENCODE_GO_USAGE_AUTH_FAILED';
+    throw err;
+  }
+  const location = res.headers.get('location') || '';
+  if (!location) return null;
+  if (/(?:^|\/|\.\/)auth\/authorize\b/.test(location)) {
+    const err = new Error('OpenCode Go console auth failed');
+    err.code = 'OPENCODE_GO_USAGE_AUTH_FAILED';
+    throw err;
+  }
+  const workspaceMatch = location.match(/\/workspace\/(wrk_[a-zA-Z0-9]+)/);
+  return normalizeWorkspaceId(workspaceMatch ? workspaceMatch[1] : location);
+}
+
 async function fetchWorkspaceId(authCookie, { signal } = {}) {
+  const fromRedirect = await fetchWorkspaceIdFromAuthRedirect(authCookie, { signal });
+  if (fromRedirect) return fromRedirect;
   const url = new URL(`${BASE_URL}/_server`);
   url.searchParams.set('id', WORKSPACES_SERVER_ID);
   const res = await fetch(url, {

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

@@ -201,7 +201,8 @@ export function getProvider(name) {
 // unregistered providers default to false (the openai/gemini majority).
 export function providerInputExcludesCache(name) {
     const p = getProvider(name);
-    return p?.constructor?.inputExcludesCache === true;
+    if (p?.constructor?.inputExcludesCache === true) return true;
+    return String(name || '').toLowerCase().includes('anthropic');
 }
 export function getAllProviders() {
     // Defensive copy — callers must not mutate the live registry or retain