mixdog 0.9.50 → 0.9.52

package/src/runtime/agent/orchestrator/providers/model-catalog.mjs

@@ -201,9 +201,10 @@ function cachePath() {
     return join(getPluginData(), CATALOG_CACHE_FILE);
 }
 
-async function _loadCatalogImpl() {
+async function _loadCatalogImpl(fetchFn = fetch, force = false) {
     // Disk cache first
     try {
+        if (force) throw new Error('forced refresh');
         if (existsSync(cachePath())) {
             const raw = JSON.parse(readFileSync(cachePath(), 'utf-8'));
             if (raw?.fetchedAt && (Date.now() - raw.fetchedAt) < CATALOG_TTL_MS && raw.data) {
@@ -215,7 +216,7 @@ async function _loadCatalogImpl() {
     } catch { /* fall through */ }
     // Remote fetch
     try {
-        const res = await fetch(CATALOG_URL, { signal: AbortSignal.timeout(10_000) });
+        const res = await fetchFn(CATALOG_URL, { signal: AbortSignal.timeout(10_000) });
         if (!res.ok) throw new Error('HTTP ' + res.status);
         const data = await res.json();
         try {
@@ -226,14 +227,32 @@ async function _loadCatalogImpl() {
         return data;
     } catch (err) {
         process.stderr.write(`[model-catalog] fetch failed: ${err.message}\n`);
+        if (fetchFn !== fetch) {
+            _memCache = _memCache || {};
+            _memCacheAt = Date.now();
+        }
         return {};
     }
 }
 
-async function loadCatalog() {
-    if (_memCache && (Date.now() - _memCacheAt) < CATALOG_TTL_MS) return _memCache;
+async function _loadCatalogInjected(fetchFn) {
+    try {
+        const res = await fetchFn(CATALOG_URL, { signal: AbortSignal.timeout(10_000) });
+        if (!res.ok) throw new Error('HTTP ' + res.status);
+        return await res.json();
+    } catch (err) {
+        process.stderr.write(`[model-catalog] injected fetch failed: ${err.message}\n`);
+        return {};
+    }
+}
+
+export async function loadCatalog({ fetchFn, force = false } = {}) {
+    if (typeof fetchFn === 'function' && fetchFn !== fetch) {
+        return _loadCatalogInjected(fetchFn);
+    }
+    if (!force && _memCache && (Date.now() - _memCacheAt) < CATALOG_TTL_MS) return _memCache;
     if (_loadPromise) return _loadPromise;
-    _loadPromise = _loadCatalogImpl().finally(() => { _loadPromise = null; });
+    _loadPromise = _loadCatalogImpl(fetchFn, force).finally(() => { _loadPromise = null; });
     return _loadPromise;
 }
 
@@ -255,8 +274,9 @@ let _mdLoadPromise = null;
 function mdCachePath() {
     return join(getPluginData(), MODELSDEV_CACHE_FILE);
 }
-async function _loadModelsDevImpl() {
+async function _loadModelsDevImpl(fetchFn = fetch, force = false) {
     try {
+        if (force) throw new Error('forced refresh');
         if (existsSync(mdCachePath())) {
             const raw = JSON.parse(readFileSync(mdCachePath(), 'utf-8'));
             if (raw?.fetchedAt && (Date.now() - raw.fetchedAt) < CATALOG_TTL_MS && raw.data) {
@@ -267,7 +287,7 @@ async function _loadModelsDevImpl() {
         }
     } catch { /* fall through to remote */ }
     try {
-        const res = await fetch(MODELSDEV_URL, { signal: AbortSignal.timeout(10_000) });
+        const res = await fetchFn(MODELSDEV_URL, { signal: AbortSignal.timeout(10_000) });
         if (!res.ok) throw new Error('HTTP ' + res.status);
         const data = await res.json();
         try {
@@ -278,13 +298,30 @@ async function _loadModelsDevImpl() {
         return data;
     } catch (err) {
         process.stderr.write(`[model-catalog] models.dev fetch failed: ${err.message}\n`);
+        if (fetchFn !== fetch) {
+            _mdCache = _mdCache || {};
+            _mdCacheAt = Date.now();
+        }
         return _mdCache || {};
     }
 }
-export async function loadModelsDevCatalog() {
-    if (_mdCache && (Date.now() - _mdCacheAt) < CATALOG_TTL_MS) return _mdCache;
+async function _loadModelsDevInjected(fetchFn) {
+    try {
+        const res = await fetchFn(MODELSDEV_URL, { signal: AbortSignal.timeout(10_000) });
+        if (!res.ok) throw new Error('HTTP ' + res.status);
+        return await res.json();
+    } catch (err) {
+        process.stderr.write(`[model-catalog] models.dev injected fetch failed: ${err.message}\n`);
+        return {};
+    }
+}
+export async function loadModelsDevCatalog({ fetchFn, force = false } = {}) {
+    if (typeof fetchFn === 'function' && fetchFn !== fetch) {
+        return _loadModelsDevInjected(fetchFn);
+    }
+    if (!force && _mdCache && (Date.now() - _mdCacheAt) < CATALOG_TTL_MS) return _mdCache;
     if (_mdLoadPromise) return _mdLoadPromise;
-    _mdLoadPromise = _loadModelsDevImpl().finally(() => { _mdLoadPromise = null; });
+    _mdLoadPromise = _loadModelsDevImpl(fetchFn, force).finally(() => { _mdLoadPromise = null; });
     return _mdLoadPromise;
 }
 function warmModelsDevFromDiskSync() {
@@ -488,11 +525,14 @@ function mergeModelMetadata(base, overlay, opts = {}) {
  * entries keep their original shape (no metadata) so callers can distinguish
  * "known in catalog" from "no metadata available".
  */
-export async function enrichModels(models) {
+export async function enrichModels(models, { fetchFn, force = false } = {}) {
     if (!Array.isArray(models)) return models;
-    const catalog = await loadCatalog();
+    const catalog = await loadCatalog({ fetchFn, force });
+    let modelsDevCatalog = _mdCache;
     if (models.some((m) => _modelsDevProviderId(m?.provider))) {
-        try { await loadModelsDevCatalog(); } catch { /* optional gap filler */ }
+        try {
+            modelsDevCatalog = await loadModelsDevCatalog({ fetchFn, force });
+        } catch { /* optional gap filler */ }
     }
     return models.map(m => {
         const id = m.id || m.name;
@@ -520,7 +560,7 @@ export async function enrichModels(models) {
         let meta = entry ? _normalize(entry) : null;
         const metaFromPricingOverride = entry != null && entry === ov;
         if (m.provider) {
-            const row = mappedProvider ? _mdCache?.[mappedProvider]?.models?.[id] : null;
+            const row = mappedProvider ? modelsDevCatalog?.[mappedProvider]?.models?.[id] : null;
             const providerMeta = row ? _normalize(_modelsDevRowToOverride(row)) : null;
             if (providerMeta) meta = mergeModelMetadata(meta, providerMeta, { preserveBaseCosts: metaFromPricingOverride });
             const providerNative = providerCachedModelMetadataSync(m.provider, id);

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

@@ -7,7 +7,7 @@ export const OPENAI_COMPAT_PRESETS = {
     },
     xai: {
         baseURL: 'https://api.x.ai/v1',
-        defaultModel: 'grok-4.3',
+        defaultModel: 'grok-4.5',
     },
     // OpenCode Go - low-cost coding-model subscription gateway.
     'opencode-go': {

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

@@ -450,9 +450,20 @@ export async function consumeCompatChatCompletionStream(stream, {
                     }
                 }
             }
-            if (typeof choice?.delta?.reasoning_content === 'string') {
-                reasoningContent += choice.delta.reasoning_content;
-                if (choice.delta.reasoning_content) {
+            // DeepSeek/OpenCode use reasoning_content; newer LM Studio builds
+            // use reasoning, and some local compatibility shims expose
+            // thinking. They are aliases, never concatenate multiple aliases
+            // from the same chunk.
+            const reasoningDelta = typeof choice?.delta?.reasoning_content === 'string'
+                ? choice.delta.reasoning_content
+                : typeof choice?.delta?.reasoning === 'string'
+                    ? choice.delta.reasoning
+                    : typeof choice?.delta?.thinking === 'string'
+                        ? choice.delta.thinking
+                        : null;
+            if (reasoningDelta !== null) {
+                reasoningContent += reasoningDelta;
+                if (reasoningDelta) {
                     reportProgress('reasoning');
                 }
             }

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

@@ -106,7 +106,10 @@ export function xaiResponsesCacheRouting(opts, params, rawTools, model) {
 
 export function normalizeXaiReasoningEffort(value) {
     const effort = String(value || '').trim().toLowerCase();
-    return ['none', 'low', 'medium', 'high'].includes(effort) ? effort : null;
+    // Grok 4.5 accepts low/medium/high. Omit unsupported values (notably
+    // `none`) to retain xAI's authoritative model default rather than sending
+    // a value the API rejects.
+    return ['low', 'medium', 'high'].includes(effort) ? effort : null;
 }
 
 export function opencodeGoReasoningEffortValues(modelInfo) {
@@ -420,85 +423,12 @@ function traceXaiCacheLane(opts, payload) {
 }
 
 export async function withXaiResponsesCacheLane({ opts, config, cacheRouting, model, transport, previousResponseId, inputCount, signal }, fn) {
-    const maxInFlight = xaiResponsesCacheLaneMaxInFlight(opts, config);
-    if (maxInFlight <= 0) {
-        const laneMeta = { enabled: false, maxInFlight: 0 };
-        return { value: await fn(laneMeta), laneMeta };
-    }
-    const { key: laneKey, shard, lane } = xaiResponsesCacheLaneKey({ model, cacheRouting, opts, config });
-    const timeoutMs = xaiResponsesCacheLaneQueueTimeoutMs(opts, config);
-    const state = getXaiResponsesCacheLaneState(laneKey, maxInFlight);
-    const queued = state.active >= state.maxInFlight;
-    if (queued) {
-        traceXaiCacheLane(opts, {
-            provider: 'xai',
-            api: 'responses',
-            transport,
-            event: 'queued',
-            lane_key_hash: traceHash(laneKey),
-            lane_shard: shard,
-            lane_shards: Number.isFinite(Number(lane?.shards)) ? Number(lane.shards) : null,
-            lane_auto: lane?.auto === true,
-            lane_seed_hash: lane?.seedHash || null,
-            max_in_flight: maxInFlight,
-            active: state.active,
-            queue_depth: state.queue.length,
-            previous_response_used: !!previousResponseId,
-            input_count: inputCount,
-        });
-    }
-    const handle = await acquireXaiResponsesCacheLane({ key: laneKey, maxInFlight, signal, timeoutMs });
-    const laneMeta = {
-        enabled: true,
-        laneKeyHash: traceHash(laneKey),
-        shard,
-        shards: Number.isFinite(Number(lane?.shards)) ? Number(lane.shards) : null,
-        auto: lane?.auto === true,
-        seedHash: lane?.seedHash || null,
-        maxInFlight,
-        queued,
-        waitMs: handle.waitedMs,
-        activeAfterAcquire: handle.activeCount,
-        queueDepthAfterAcquire: handle.queueDepth,
-    };
-    traceXaiCacheLane(opts, {
-        provider: 'xai',
-        api: 'responses',
-        transport,
-        event: 'acquired',
-        lane_key_hash: laneMeta.laneKeyHash,
-        lane_shard: shard,
-        lane_shards: laneMeta.shards,
-        lane_auto: laneMeta.auto,
-        lane_seed_hash: laneMeta.seedHash,
-        max_in_flight: maxInFlight,
-        wait_ms: laneMeta.waitMs,
-        active: laneMeta.activeAfterAcquire,
-        queue_depth: laneMeta.queueDepthAfterAcquire,
-        previous_response_used: !!previousResponseId,
-        input_count: inputCount,
-    });
-    const startedAt = Date.now();
-    try {
-        return { value: await fn(laneMeta), laneMeta };
-    } finally {
-        handle.release();
-        traceXaiCacheLane(opts, {
-            provider: 'xai',
-            api: 'responses',
-            transport,
-            event: 'released',
-            lane_key_hash: laneMeta.laneKeyHash,
-            lane_shard: shard,
-            lane_shards: laneMeta.shards,
-            lane_auto: laneMeta.auto,
-            lane_seed_hash: laneMeta.seedHash,
-            max_in_flight: maxInFlight,
-            held_ms: Date.now() - startedAt,
-            previous_response_used: !!previousResponseId,
-            input_count: inputCount,
-        });
-    }
+    // Historical prompt-cache lanes formed a second admission queue and could
+    // time out while waiting. xAI is now governed exclusively by the common
+    // fixed-64 provider/account scheduler, regardless of legacy env/option
+    // knobs. Keep this wrapper only as a call-shape compatibility boundary.
+    const laneMeta = { enabled: false, maxInFlight: 0 };
+    return { value: await fn(laneMeta), laneMeta };
 }
 
 export function deterministicUuidFromKey(key) {

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

@@ -107,6 +107,72 @@ function assertSafeBaseURL(rawURL, providerName) {
 // parsers → openai-compat-wire.mjs. Re-exported below for existing importers.
 export { summarizeTraceMessages, extractCompatCachedTokens } from './openai-compat-trace.mjs';
 export { parseToolCalls, parseResponsesToolCalls } from './openai-compat-wire.mjs';
+
+function normalizeReasoningEffort(value, allowed) {
+    const effort = String(value ?? '').trim().toLowerCase();
+    return allowed.includes(effort) ? effort : null;
+}
+
+// Keep provider extensions isolated: fields accepted by one OpenAI-compatible
+// backend are frequently rejected by another even when the core Chat schema is
+// shared.
+export function applyCompatProviderChatOptions(params, providerName, opts = {}, config = {}, modelInfo = null) {
+    if (providerName === 'xai') {
+        const reasoningEffort = normalizeXaiReasoningEffort(opts.xaiReasoningEffort
+            ?? opts.effort
+            ?? config?.reasoningEffort
+            ?? process.env.MIXDOG_XAI_REASONING_EFFORT);
+        if (reasoningEffort) params.reasoning_effort = reasoningEffort;
+        return params;
+    }
+    if (providerName === 'deepseek') {
+        const rawThinking = opts.deepseekThinking
+            ?? opts.thinking
+            ?? config?.thinking;
+        const rawEffort = opts.deepseekReasoningEffort
+            ?? opts.effort
+            ?? config?.reasoningEffort;
+        if (rawThinking !== undefined || rawEffort !== undefined) {
+            const disabled = rawThinking === false
+                || String(rawThinking?.type ?? rawThinking ?? rawEffort).trim().toLowerCase() === 'disabled'
+                || String(rawThinking?.type ?? rawThinking ?? rawEffort).trim().toLowerCase() === 'none';
+            params.thinking = { type: disabled ? 'disabled' : 'enabled' };
+            if (!disabled) {
+                const effort = String(rawEffort ?? '').trim().toLowerCase();
+                if (effort === 'max' || effort === 'xhigh') params.reasoning_effort = 'max';
+                else if (['low', 'medium', 'high'].includes(effort)) params.reasoning_effort = 'high';
+            }
+        }
+        return params;
+    }
+    if (providerName === 'ollama') {
+        const effort = normalizeReasoningEffort(
+            opts.ollamaReasoningEffort ?? opts.effort ?? config?.reasoningEffort,
+            ['none', 'low', 'medium', 'high', 'max'],
+        );
+        if (effort) params.reasoning_effort = effort;
+        return params;
+    }
+    if (providerName === 'lmstudio') {
+        const effort = normalizeReasoningEffort(
+            opts.lmStudioReasoningEffort ?? opts.effort ?? config?.reasoningEffort,
+            ['none', 'low', 'medium', 'high', 'max'],
+        );
+        if (effort) params.reasoning_effort = effort;
+        return params;
+    }
+    if (providerName === 'opencode-go') {
+        const reasoningEffort = normalizeOpencodeGoReasoningEffort(
+            opts.effort ?? config?.reasoningEffort,
+            modelInfo,
+        );
+        // OpenCode Go's OpenAI-compatible contract exposes reasoning_effort,
+        // not DeepSeek's provider-specific `thinking` extension.
+        if (reasoningEffort) params.reasoning_effort = reasoningEffort;
+    }
+    return params;
+}
+
 export class OpenAICompatProvider {
     // Chat Completions prompt_tokens is already the total (includes cached).
     // Covers grok-oauth and all OPENAI_COMPAT_PRESETS. See registry.mjs.
@@ -150,6 +216,11 @@ export class OpenAICompatProvider {
             fetchOptions: { dispatcher: getLlmDispatcher() },
         });
     }
+    get _preconnectFn() {
+        return typeof this.config?.preconnectFn === 'function'
+            ? this.config.preconnectFn
+            : preconnect;
+    }
     reloadApiKey() {
         try {
             const preset = PRESETS[this.name];
@@ -174,7 +245,13 @@ export class OpenAICompatProvider {
         try {
             return await this._doSend(messages, model, tools, sendOpts);
         } catch (err) {
-            if (err.message && (err.message.includes('401') || err.message.includes('403'))) {
+            const structuredStatus = [err?.status, err?.httpStatus, err?.response?.status]
+                .map(value => Number(value))
+                .find(value => Number.isFinite(value) && value > 0) || 0;
+            const status = structuredStatus > 0
+                ? structuredStatus
+                : (/\b401\b/.test(String(err?.message || '')) ? 401 : 0);
+            if (status === 401) {
                 if (err.liveTextEmitted === true || err.emittedToolCall === true || err.unsafeToRetry === true) {
                     throw err;
                 }
@@ -191,7 +268,11 @@ export class OpenAICompatProvider {
         // Re-warm a kept-alive socket to the provider origin before the turn so
         // the request hot path lands on a live socket instead of paying a cold
         // TLS handshake after an idle gap. Fire-and-forget; never awaited.
-        preconnect(this.baseURL);
+        // Tests/local callers can disable this or inject a fail-closed seam;
+        // production retains the shared preconnect by default.
+        if (this.config?.preconnect !== false) {
+            this._preconnectFn(this.baseURL);
+        }
         if (this.name === 'xai' && useXaiResponsesApi(opts, this.config)) {
             // Shared Responses transport switch (MIXDOG_OAI_TRANSPORT), capability-
             // gated for xAI/Grok. Provider-local HTTP pins still win: Grok
@@ -259,20 +340,7 @@ export class OpenAICompatProvider {
         if (tools?.length) {
             params.tools = toOpenAITools(tools);
         }
-        if (this.name === 'xai') {
-            const reasoningEffort = normalizeXaiReasoningEffort(opts.xaiReasoningEffort
-                ?? opts.effort
-                ?? this.config?.reasoningEffort
-                ?? process.env.MIXDOG_XAI_REASONING_EFFORT);
-            if (reasoningEffort) params.reasoning_effort = reasoningEffort;
-        }
-        if (this.name === 'opencode-go') {
-            const reasoningEffort = normalizeOpencodeGoReasoningEffort(opts.effort ?? this.config?.reasoningEffort, modelInfo);
-            if (reasoningEffort) {
-                params.reasoning_effort = reasoningEffort;
-                params.thinking = { type: 'enabled' };
-            }
-        }
+        applyCompatProviderChatOptions(params, this.name, opts, this.config, modelInfo);
         // Streaming (params.stream = true is always set below): no absolute
         // wall-clock cap on a healthy stream. A fixed total-lifetime timer
         // false-aborts live long-reasoning turns that are still emitting SSE
@@ -401,7 +469,11 @@ export class OpenAICompatProvider {
         // Capture provider reasoning_content so loop.mjs can attach it to the
         // assistant message and echo it back next turn for providers that
         // require or benefit from that official multi-turn shape.
-        const capturesReasoningContent = this.name === 'deepseek' || this.name === 'xai' || replaysReasoningContent;
+        const capturesReasoningContent = this.name === 'deepseek'
+            || this.name === 'xai'
+            || this.name === 'ollama'
+            || this.name === 'lmstudio'
+            || replaysReasoningContent;
         const reasoningContent = (capturesReasoningContent && typeof assembled.reasoningContent === 'string')
             ? assembled.reasoningContent
             : null;

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

@@ -13,6 +13,7 @@ import {
     traceAgentUsage,
 } from '../agent-trace.mjs';
 import {
+    PROVIDER_FIRST_BYTE_TIMEOUT_MS,
     PROVIDER_HTTP_RESPONSE_TIMEOUT_MS,
     PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS,
     PROVIDER_SSE_IDLE_WATCHDOG_ENABLED,
@@ -20,7 +21,12 @@ import {
     createTimeoutSignal,
     createPassthroughSignal,
 } from '../stall-policy.mjs';
-import { populateHttpStatusFromMessage, shouldFallbackTransport } from './retry-classifier.mjs';
+import {
+    jitterDelayMs,
+    populateHttpStatusFromMessage,
+    shouldFallbackTransport,
+    sleepWithAbort,
+} from './retry-classifier.mjs';
 import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
 import { makeInvalidToolArgsMarker } from './openai-compat-stream.mjs';
 import { createLeakGuard, createToolCallDedupe, dedupeToolCallList } from './anthropic-leaked-toolcall.mjs';
@@ -34,6 +40,9 @@ import { createActiveToolItemTracker } from './tool-stream-state.mjs';
 // mirrors it so OpenAIDirectProvider can fall back off WebSocket like
 // openai-oauth. Same Responses SSE wire format, only endpoint + auth differ.
 const OPENAI_DIRECT_RESPONSES_URL = 'https://api.openai.com/v1/responses';
+const CODEX_REQUEST_MAX_RETRIES = 4;
+const CODEX_REQUEST_BACKOFF_MS = Object.freeze([200, 400, 800, 1600]);
+const CODEX_RETRY_JITTER_RATIO = 0.1;
 
 export function _envFlag(name, fallback = true) {
     const raw = process.env[name];
@@ -187,6 +196,7 @@ export async function sendViaHttpSse({
     iteration,
     useModel,
     fetchFn = fetch,
+    _sleepFn,
 } = {}) {
     // P1 audit fix: no fixed wall-clock total cap on the HTTP/SSE fallback
     // stream. The old createTimeoutSignal(..., PROVIDER_GENERATE_TOTAL_TIMEOUT_MS)
@@ -202,31 +212,60 @@ export async function sendViaHttpSse({
     //       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,
-        'OpenAI OAuth HTTP fallback initial response',
-    );
     const headers = _buildOpenAIHttpFallbackHeaders({ auth, cacheKey });
     const fetchStartedAt = Date.now();
     const responsesUrl = auth?.type === 'openai-direct'
         ? OPENAI_DIRECT_RESPONSES_URL
         : CODEX_RESPONSES_URL;
     let response;
-    try {
-        try { onStageChange?.('requesting'); } catch {}
-        response = await fetchFn(responsesUrl, {
-            method: 'POST',
-            headers,
-            body: JSON.stringify(body),
-            signal: headerTimeout.signal,
-            dispatcher: getLlmDispatcher(),
-        });
-    } catch (err) {
-        if (headerTimeout.signal?.aborted && headerTimeout.signal.reason instanceof Error) throw headerTimeout.signal.reason;
-        throw err;
-    } finally {
-        headerTimeout.cleanup();
+    for (let attempt = 0; attempt <= CODEX_REQUEST_MAX_RETRIES; attempt++) {
+        const headerTimeout = createTimeoutSignal(
+            totalTimeout.signal,
+            PROVIDER_HTTP_RESPONSE_TIMEOUT_MS,
+            'OpenAI OAuth HTTP fallback initial response',
+        );
+        let requestError = null;
+        try {
+            try { onStageChange?.('requesting'); } catch {}
+            response = await fetchFn(responsesUrl, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(body),
+                signal: headerTimeout.signal,
+                dispatcher: getLlmDispatcher(),
+            });
+        } catch (err) {
+            requestError = headerTimeout.signal?.aborted
+                && headerTimeout.signal.reason instanceof Error
+                ? headerTimeout.signal.reason
+                : err;
+        } finally {
+            headerTimeout.cleanup();
+        }
+
+        const retryableStatus = response && response.status >= 500 && response.status <= 599;
+        const retryableTransport = !response && requestError
+            && !externalSignal?.aborted
+            && !totalTimeout.signal?.aborted;
+        if (attempt < CODEX_REQUEST_MAX_RETRIES && (retryableStatus || retryableTransport)) {
+            // A non-success response has not exposed any streamed output. Drain
+            // its body before reissuing so the dispatcher can reuse the socket.
+            if (response) await response.arrayBuffer().catch(() => {});
+            const raw = CODEX_REQUEST_BACKOFF_MS[attempt];
+            await sleepWithAbort(
+                jitterDelayMs(raw, CODEX_RETRY_JITTER_RATIO),
+                externalSignal,
+                _sleepFn,
+                'OpenAI OAuth HTTP request retry backoff aborted',
+            );
+            response = undefined;
+            continue;
+        }
+        if (requestError) {
+            totalTimeout.cleanup();
+            throw requestError;
+        }
+        break;
     }
 
     traceAgentFetch({
@@ -292,6 +331,30 @@ export async function sendViaHttpSse({
     // 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;
+    let _firstServerEventTimer = null;
+    const firstServerEventOverrideMs = Number(opts?._firstServerEventTimeoutMs);
+    const firstServerEventMs = Number.isFinite(firstServerEventOverrideMs) && firstServerEventOverrideMs > 0
+        ? firstServerEventOverrideMs
+        : PROVIDER_FIRST_BYTE_TIMEOUT_MS;
+    const _clearFirstServerEvent = () => {
+        if (_firstServerEventTimer) {
+            clearTimeout(_firstServerEventTimer);
+            _firstServerEventTimer = null;
+        }
+    };
+    const _armFirstServerEvent = () => {
+        if (!(firstServerEventMs > 0)) return;
+        _clearFirstServerEvent();
+        _firstServerEventTimer = setTimeout(() => {
+            const err = new Error(`OpenAI OAuth HTTP fallback first server event timed out after ${firstServerEventMs}ms`);
+            err.code = 'EPROVIDERTIMEOUT';
+            err.firstByteTimeout = true;
+            _streamAbortReason = err;
+            try { reader.cancel(err).catch(() => {}); } catch {}
+            _rejectPendingRead(err);
+        }, firstServerEventMs);
+        try { _firstServerEventTimer.unref?.(); } catch {}
+    };
     const _clearSemanticIdle = () => {
         if (_semanticIdleTimer) { clearTimeout(_semanticIdleTimer); _semanticIdleTimer = null; }
     };
@@ -508,6 +571,11 @@ export async function sendViaHttpSse({
     };
     const handleEvent = (event) => {
         if (!event || typeof event.type !== 'string') return;
+        _clearFirstServerEvent();
+        // Once any real SSE server event arrives, the fixed initial deadline is
+        // satisfied and semantic-idle ownership begins. meaningful() below may
+        // immediately re-arm it for a semantic event.
+        _armSemanticIdle();
         switch (event.type) {
             case 'response.created':
                 if (event.response?.model) model = event.response.model;
@@ -783,12 +851,10 @@ export async function sendViaHttpSse({
     };
 
     try {
-        // Arm the idle watchdog BEFORE the first read: a 200 response with an
-        // open-but-silent body (no SSE events at all) previously hung on bare
-        // reader.read() until the outer agent watchdog (CC/codex/opencode all
-        // bound the first read). meaningful() re-arms it per delta thereafter;
-        // an empty-partial stall classifies stream_stalled → retry/fallback.
-        _armSemanticIdle();
+        // Initial wait is governed only by the fixed first-server-event policy.
+        // Semantic idle begins in meaningful() after a parsed server event, so
+        // a lower semantic-idle override cannot shorten this first-event wait.
+        _armFirstServerEvent();
         while (true) {
             if (totalTimeout.signal?.aborted) {
                 _clearSemanticIdle();
@@ -834,6 +900,7 @@ export async function sendViaHttpSse({
         throw err;
     } finally {
         _pendingReadReject = null;
+        _clearFirstServerEvent();
         _clearSemanticIdle();
         try { reader.releaseLock?.(); } catch {}
         if (_onTotalAbort && totalTimeout.signal) {