mixdog 0.9.148 → 0.9.149

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

@@ -19,7 +19,12 @@ import { makeModelCache } from './model-cache.mjs';
 
 import { sendViaWebSocket } from './openai-oauth-ws.mjs';
 import { _combineUsageWithWarmup } from './openai-ws-events.mjs';
-import { acquireWebSocket, releaseWebSocket, hasPooledWebSocket } from './openai-ws-pool.mjs';
+import {
+    acquireWebSocket,
+    releaseWebSocket,
+    hasPooledWebSocket,
+    WS_IDLE_MS,
+} from './openai-ws-pool.mjs';
 import { _codexWsCompatibilityHeaders } from './openai-codex-metadata.mjs';
 import { resolveOpenAiTransportPolicy } from './openai-transport-policy.mjs';
 import {
@@ -78,8 +83,17 @@ export { _displayCodexModel };
 // Public test/integration entry retained alongside the transport module export.
 export { sendViaHttpSse };
 // --- Constants ---
-import { buildRequestBody } from './openai-responses-payload.mjs';
-export { buildRequestBody, convertMessagesToResponsesInput, toOpenAIResponsesTool, _convertMessagesToResponsesInputForTest } from './openai-responses-payload.mjs';
+import {
+    buildCodexStartupPrewarmBody,
+    buildRequestBody,
+} from './openai-responses-payload.mjs';
+export {
+    buildCodexStartupPrewarmBody,
+    buildRequestBody,
+    convertMessagesToResponsesInput,
+    toOpenAIResponsesTool,
+    _convertMessagesToResponsesInputForTest,
+} from './openai-responses-payload.mjs';
 const CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
 // Exported for openai-oauth-http-sse.mjs (fallback transport headers/URL).
 export const CODEX_OAUTH_ORIGINATOR = 'codex_cli_rs';
@@ -358,6 +372,22 @@ async function refreshTokens(refreshToken) {
         clearTimeout(timeout);
     }
 }
+// Identity of the STABLE prefix a startup prewarm actually warmed (model +
+// instructions/tools, never the live transcript). A reservation may only be
+// consumed by a request whose own prefix hashes the same: the first turn
+// refreshes environment/tool surface after the prewarm was fired, and adopting
+// a socket anchored on the older prefix costs the whole prewarm and forces the
+// real request back to a full frame.
+function _codexStartupPrefixHash(body) {
+    const prewarm = buildCodexStartupPrewarmBody(body);
+    return createHash('sha256').update(JSON.stringify({
+        model: prewarm?.model ?? null,
+        instructions: prewarm?.instructions ?? null,
+        tools: prewarm?.tools ?? null,
+        input: prewarm?.input ?? [],
+    })).digest('hex').slice(0, 24);
+}
+
 // --- Build Responses API request ---
 export class OpenAIOAuthProvider {
     // OpenAI input_tokens already INCLUDES cached_tokens (cached is a subset),
@@ -371,6 +401,8 @@ export class OpenAIOAuthProvider {
     // booleans here would let one unhealthy session force every other session
     // onto HTTP.
     _httpFallbackUntilByPoolKey = new Map();
+    _startupPrewarmByPoolKey = new Map();
+    _startupPrewarmReadyByPoolKey = new Map();
     config;
     constructor(config) {
         this.config = config || {};
@@ -531,14 +563,32 @@ export class OpenAIOAuthProvider {
         let auth = await _authP;
         await _verP;
         const body = await _bodyP;
-        // poolKey != cacheKey by design (see openai-oauth-ws.mjs header note).
-        // poolKey is per-session so parallel reviewer/worker callers each get
-        // their own socket bucket. cacheKey is the Codex-style prompt_cache_key:
-        // by default it is the session/thread identity (clamped to 64 chars) and
-        // feeds both `body.prompt_cache_key` and the OAuth WS handshake
-        // `session_id`, so each long-lived thread keeps a stable cache shard.
+        // poolKey != cacheKey by design. poolKey isolates socket/delta state per
+        // session. cacheKey is body.prompt_cache_key and affects prompt-cache
+        // routing only; Codex handshake identity comes from sendOpts and remains
+        // independent so a future cache-lane policy cannot merge conversations.
         const poolKey  = opts.sessionId || null;
         const cacheKey = body.prompt_cache_key || resolveProviderCacheKey(opts, 'openai-oauth');
+        const startupPrefixHash = _codexStartupPrefixHash(body);
+        let startupPrewarmHandle = null;
+        if (poolKey && opts._startupPrewarmOnly !== true) {
+            const candidate = this._startupPrewarmReadyByPoolKey.get(poolKey) || null;
+            if (candidate) {
+                this._startupPrewarmReadyByPoolKey.delete(poolKey);
+                if (candidate._reservationTimer) {
+                    clearTimeout(candidate._reservationTimer);
+                    candidate._reservationTimer = null;
+                }
+                if (candidate.poolKey === poolKey
+                    && candidate.cacheKey === cacheKey
+                    && candidate.prefixHash === startupPrefixHash
+                    && candidate.entry) {
+                    startupPrewarmHandle = candidate;
+                } else if (candidate.entry) {
+                    releaseWebSocket({ entry: candidate.entry, poolKey, keep: false });
+                }
+            }
+        }
         const iteration = Number.isFinite(Number(opts.iteration)) ? Number(opts.iteration) : null;
         const sendWs = typeof opts._sendViaWebSocketFn === 'function' ? opts._sendViaWebSocketFn : sendViaWebSocket;
         const sendHttp = typeof opts._sendViaHttpSseFn === 'function' ? opts._sendViaHttpSseFn : sendViaHttpSse;
@@ -644,21 +694,24 @@ export class OpenAIOAuthProvider {
             }
             return recordLiveModel(result);
         };
-        const dispatchWs = (forceFresh = false, carriedWarmup = null) => sendWs({
-            auth,
-            body,
-            sendOpts: opts,
-            onStreamDelta,
-            onToolCall,
-            onTextDelta,
-            onStageChange,
-            externalSignal,
-            poolKey,
-            cacheKey,
-            iteration,
-            useModel,
-            displayModel: _displayCodexModel,
-            forceFresh,
+        const dispatchWs = (forceFresh = false, carriedWarmup = null) => {
+            const prewarmedHandle = forceFresh ? null : startupPrewarmHandle;
+            startupPrewarmHandle = null;
+            return sendWs({
+                auth,
+                body,
+                sendOpts: opts,
+                onStreamDelta,
+                onToolCall,
+                onTextDelta,
+                onStageChange,
+                externalSignal,
+                poolKey,
+                cacheKey,
+                iteration,
+                useModel,
+                displayModel: _displayCodexModel,
+                forceFresh,
             // Default refs-style recovery: keep using WS first. A transient
             // first-byte / mid-stream stall closes the bad socket and retries on
             // a fresh WS entry; only after the bounded WS retry budget is
@@ -678,10 +731,12 @@ export class OpenAIOAuthProvider {
             // exactly that. Every prewarmed call on record (72/72) kept its
             // chain continuous. MIXDOG_OPENAI_OAUTH_WS_WARMUP=0 disables it.
             warmupBody: _envFlag('MIXDOG_OPENAI_OAUTH_WS_WARMUP', true)
-                ? { ...body, input: [], generate: false }
+                ? buildCodexStartupPrewarmBody(body)
                 : null,
-            _carriedWarmup: carriedWarmup,
-        });
+                _carriedWarmup: carriedWarmup,
+                _prewarmedHandle: prewarmedHandle,
+            });
+        };
         const mustSurfaceFallbackError = (fallbackErr) => externalSignal?.aborted
             || fallbackErr?.name === 'AbortError'
             || fallbackErr?.code === 'ABORT_ERR'
@@ -695,6 +750,13 @@ export class OpenAIOAuthProvider {
                 || httpFallbackActive()
                 || _envFlag('MIXDOG_OPENAI_OAUTH_FORCE_HTTP_FALLBACK', false)
             ))) {
+            if (startupPrewarmHandle?.entry) {
+                releaseWebSocket({ entry: startupPrewarmHandle.entry, poolKey, keep: false });
+                startupPrewarmHandle = null;
+            }
+            if (opts._startupPrewarmOnly === true) {
+                return { startupPrewarm: false };
+            }
             return dispatchHttp('forced');
         }
 
@@ -704,9 +766,16 @@ export class OpenAIOAuthProvider {
             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`); }
+            // Stamp the reservation with the prefix it warmed so the first real
+            // request can tell a matching anchor from a stale one.
+            if (opts._startupPrewarmOnly === true && result?.startupPrewarmHandle) {
+                result.startupPrewarmHandle.prefixHash = startupPrefixHash;
+                result.startupPrewarmHandle.promptWarmup = true;
+            }
             return recordLiveModel(result);
         } catch (err) {
             traceWsError(err, 'primary');
+            if (opts._startupPrewarmOnly === true) throw err;
             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
@@ -782,35 +851,128 @@ export class OpenAIOAuthProvider {
         }
     }
     /**
-     * Spawn-time transport prewarm (codex prewarm_websocket parity): open the
-     * session's WS socket while the caller is still assembling the session /
-     * first prompt, so the first real request reuses an already-open pooled
-     * socket instead of paying TLS + upgrade on its critical path.
+     * Session-startup Responses prewarm. With a materialized session this sends
+     * Codex's generate:false request (stable instructions/tools, empty input)
+     * and leaves the response/socket state pooled for the first real turn.
+     * Legacy callers without a materialized prompt retain the connection-only
+     * prewarm path.
      *
      * Best-effort by contract: every failure returns false and leaves the
-     * lazy per-send handshake untouched. Only runs when the thread-scoped
-     * prompt_cache_key derivation is active — with it disabled the real
-     * cacheKey depends on the built request body (instructions/tools hash),
-     * which does not exist yet at spawn prep, and a mismatched socket would
-     * just be evicted as incompatible on first acquire.
+     * lazy per-send warmup untouched.
      */
     async prewarmWsTransportForSession(opts = {}, seams = {}) {
-        const _acquire = seams._acquire || acquireWebSocket;
-        const _release = seams._release || releaseWebSocket;
-        const _hasPooled = seams._hasPooled || hasPooledWebSocket;
-        const _warmVersion = seams._warmVersion || warmCodexClientVersion;
         const poolKey = opts.sessionId || null;
         if (!poolKey) return false;
-        try {
+        const session = opts.session && typeof opts.session === 'object' ? opts.session : null;
+        const messages = Array.isArray(opts.messages)
+            ? opts.messages
+            : (Array.isArray(session?.messages) ? session.messages : null);
+        const tools = Array.isArray(opts.tools)
+            ? opts.tools
+            : (Array.isArray(session?.tools) ? session.tools : []);
+        const model = opts.model || session?.model || null;
+        const promptWarmup = !!(messages
+            && model
+            && _envFlag('MIXDOG_OPENAI_OAUTH_WS_WARMUP', true));
+        // A connection-only reservation (session create, before the prompt is
+        // materialized) must not satisfy the first turn's prompt prewarm.
+        const readyHandle = this._startupPrewarmReadyByPoolKey.get(poolKey) || null;
+        if (readyHandle && (!promptWarmup || readyHandle.promptWarmup === true)) return true;
+        const existing = this._startupPrewarmByPoolKey.get(poolKey);
+        if (existing) {
+            if (!promptWarmup || existing.promptWarmup) return existing.task;
+            try { await existing.task; } catch {}
+            if (this._startupPrewarmByPoolKey.get(poolKey) === existing) {
+                this._startupPrewarmByPoolKey.delete(poolKey);
+            }
+            return this.prewarmWsTransportForSession(opts, seams);
+        }
+        const record = { promptWarmup, task: null };
+        const task = (async () => {
+            const _acquire = seams._acquire || acquireWebSocket;
+            const _release = seams._release || releaseWebSocket;
+            const _hasPooled = seams._hasPooled || hasPooledWebSocket;
+            const _warmVersion = seams._warmVersion || warmCodexClientVersion;
+            const _send = seams._send || ((messages, model, tools, sendOpts) =>
+                this.send(messages, model, tools, sendOpts));
             const transportPolicy = resolveOpenAiTransportPolicy();
             if (transportPolicy.transport === 'http'
                 || _envFlag('MIXDOG_OPENAI_OAUTH_FORCE_HTTP_FALLBACK', false)) return false;
+            if (promptWarmup) {
+                const {
+                    messages: _messages,
+                    tools: _tools,
+                    model: _model,
+                    ...baseSendOpts
+                } = opts;
+                const codexSessionId = baseSendOpts.codexSessionId
+                    || session?.codexWireSessionId
+                    || null;
+                const sendOpts = {
+                    ...baseSendOpts,
+                    sessionId: poolKey,
+                    session,
+                    effort: baseSendOpts.effort ?? session?.effort ?? null,
+                    fast: baseSendOpts.fast === true || session?.fast === true,
+                    modelParameters: baseSendOpts.modelParameters || session?.modelParameters || {},
+                    promptCacheKey: baseSendOpts.promptCacheKey || session?.promptCacheKey || null,
+                    ...(codexSessionId ? {
+                        codexSessionId,
+                        codexThreadId: baseSendOpts.codexThreadId || codexSessionId,
+                        threadId: baseSendOpts.threadId || codexSessionId,
+                    } : {}),
+                    requestKind: 'prewarm',
+                    codexRequestKind: 'prewarm',
+                    _startupPrewarmOnly: true,
+                };
+                const _t0 = Date.now();
+                const result = await _send(messages, model, tools, sendOpts);
+                const handle = result?.startupPrewarmHandle || null;
+                const ready = result?.startupPrewarm === true && !!handle?.entry;
+                if (ready) {
+                    const previous = this._startupPrewarmReadyByPoolKey.get(poolKey);
+                    if (previous?.entry && previous !== handle) {
+                        if (previous._reservationTimer) clearTimeout(previous._reservationTimer);
+                        releaseWebSocket({ entry: previous.entry, poolKey, keep: false });
+                    }
+                    this._startupPrewarmReadyByPoolKey.set(poolKey, handle);
+                    handle._reservationTimer = setTimeout(() => {
+                        if (this._startupPrewarmReadyByPoolKey.get(poolKey) !== handle) return;
+                        this._startupPrewarmReadyByPoolKey.delete(poolKey);
+                        handle._reservationTimer = null;
+                        releaseWebSocket({ entry: handle.entry, poolKey, keep: false });
+                    }, WS_IDLE_MS);
+                    try { handle._reservationTimer.unref?.(); } catch {}
+                    try {
+                        handle.entry.socket?.once?.('close', () => {
+                            if (handle._reservationTimer) {
+                                clearTimeout(handle._reservationTimer);
+                                handle._reservationTimer = null;
+                            }
+                            if (this._startupPrewarmReadyByPoolKey.get(poolKey) === handle) {
+                                this._startupPrewarmReadyByPoolKey.delete(poolKey);
+                            }
+                        });
+                    } catch {}
+                }
+                try {
+                    appendAgentTrace({
+                        sessionId: poolKey,
+                        kind: 'spawn_ws_prewarm',
+                        provider: 'openai-oauth',
+                        transport: 'websocket',
+                        payload: {
+                            elapsed_ms: Date.now() - _t0,
+                            prompt_warmup: true,
+                            ready,
+                        },
+                    });
+                } catch {}
+                return ready;
+            }
             const threadKeyGate = String(process.env.MIXDOG_OAI_CODEX_THREAD_CACHE_KEY || '').toLowerCase();
             if (threadKeyGate === '0' || threadKeyGate === 'false') return false;
             if (_hasPooled(poolKey)) return true;
-            // Identical derivation to buildRequestBody's prompt_cache_key
-            // (thread-scoped branch), so the prewarmed socket's handshake
-            // session_id and pool-compatibility key match the first real send.
             const cacheKey = buildStableProviderPromptCacheKey('openai-oauth', opts);
             const [auth] = await Promise.all([this.ensureAuth(), _warmVersion()]);
             const codexHeaders = _codexWsCompatibilityHeaders({
@@ -818,8 +980,6 @@ export class OpenAIOAuthProvider {
                 cacheKey,
                 sendOpts: opts,
                 model: opts.model,
-                // Same tier the request body will carry, so the prewarm
-                // handshake routes to the node the first real send wants.
                 serviceTier: opts.fast === true && codexModelSupportsServiceTier(opts.model, 'priority')
                     ? 'priority'
                     : '',
@@ -840,18 +1000,28 @@ export class OpenAIOAuthProvider {
                     kind: 'spawn_ws_prewarm',
                     provider: 'openai-oauth',
                     transport: 'websocket',
-                    payload: { elapsed_ms: Date.now() - _t0, reused: acquired.reused === true },
+                    payload: {
+                        elapsed_ms: Date.now() - _t0,
+                        reused: acquired.reused === true,
+                        prompt_warmup: false,
+                    },
                 });
             } catch {}
-            if (process.env.MIXDOG_DEBUG_AGENT) {
-                process.stderr.write(`[agent-trace] spawn-ws-prewarm ok poolKey=${createHash('sha256').update(String(poolKey)).digest('hex').slice(0, 8)} elapsed=${Date.now() - _t0}ms\n`);
-            }
             return true;
+        })();
+        record.task = task;
+        this._startupPrewarmByPoolKey.set(poolKey, record);
+        try {
+            return await task;
         } catch (err) {
             if (process.env.MIXDOG_DEBUG_AGENT) {
                 process.stderr.write(`[agent-trace] spawn-ws-prewarm failed err=${String(err?.message || err).slice(0, 160)}\n`);
             }
             return false;
+        } finally {
+            if (this._startupPrewarmByPoolKey.get(poolKey) === record) {
+                this._startupPrewarmByPoolKey.delete(poolKey);
+            }
         }
     }
     async listModels() {

package/src/runtime/agent/orchestrator/providers/openai-responses-payload.mjs

@@ -71,6 +71,7 @@ import {
     _compareVersion,
     _isMainCodexFamily,
     _markLatestCodex,
+    _codexUsesResponsesLite,
 } from './openai-codex-model.mjs';
 
 // Public test/integration entry retained alongside the transport module export.
@@ -104,9 +105,18 @@ export function convertMessagesToResponsesInput(messages, opts = {}) {
     const pendingToolMedia = [];
     const customToolCallNameById = new Map();
     const replayEncryptedReasoning = opts.replayEncryptedReasoning === true;
-    const wireParity = process.env.MIXDOG_OAI_CODEX_WIRE_PARITY === '1';
+    const wireParity = opts.codexWireParity === true;
+    const wireMessageMetadata = opts.codexMessageMetadata
+        && typeof opts.codexMessageMetadata === 'object'
+        ? opts.codexMessageMetadata
+        : {};
     const wireMessage = (role, content) => (wireParity
-        ? { type: 'message', role, content, internal_chat_message_metadata_passthrough: {} }
+        ? {
+            type: 'message',
+            role,
+            content,
+            internal_chat_message_metadata_passthrough: wireMessageMetadata,
+        }
         : { role, content });
     // `phase` replays each retained item on the side of the assistant text it
     // was emitted on, so the rebuilt turn keeps the response's own item order.
@@ -243,6 +253,55 @@ function _codexModelSupportsReasoningSummaries(id) {
     return true;
 }
 
+function _codexModelUsesResponsesLite(id, opts = {}) {
+    if (typeof opts.useResponsesLite === 'boolean') return opts.useResponsesLite;
+    const override = String(process.env.MIXDOG_OAI_RESPONSES_LITE || '').trim().toLowerCase();
+    if (['1', 'true', 'yes', 'on'].includes(override)) return true;
+    if (['0', 'false', 'no', 'off'].includes(override)) return false;
+    const info = _findCachedCodexModel(id);
+    return _codexUsesResponsesLite(id, info);
+}
+
+function _responsesLiteTools(tools) {
+    const out = [];
+    const functions = [];
+    let functionsIndex = null;
+    for (const tool of Array.isArray(tools) ? tools : []) {
+        if (tool?.type === 'function' || tool?.type === 'custom') {
+            if (functionsIndex == null) functionsIndex = out.length;
+            functions.push(tool);
+            continue;
+        }
+        if (tool?.type === 'namespace' && tool?.name === 'functions') {
+            if (functionsIndex == null) functionsIndex = out.length;
+            if (Array.isArray(tool.tools)) functions.push(...tool.tools);
+            continue;
+        }
+        out.push(tool);
+    }
+    if (functions.length) {
+        out.splice(functionsIndex, 0, {
+            type: 'namespace',
+            name: 'functions',
+            description: '',
+            tools: functions,
+        });
+    }
+    return out;
+}
+
+export function buildCodexStartupPrewarmBody(body) {
+    const input = Array.isArray(body?.input) ? body.input : [];
+    const stableInput = [];
+    if (input[0]?.type === 'additional_tools' && input[0]?.role === 'developer') {
+        stableInput.push(input[0]);
+        if (input[1]?.type === 'message' && input[1]?.role === 'developer') {
+            stableInput.push(input[1]);
+        }
+    }
+    return { ...body, input: stableInput, generate: false };
+}
+
 // Effort normalization: `ultra` collapses to
 // `max` on the wire — the openai-oauth backend does not accept `ultra`. Every
 // other effort passes through unchanged; empty/unknown falls back to medium.
@@ -281,6 +340,8 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
         .join('\n\n---\n\n');
     const opts = sendOpts || {};
     const promptCacheProvider = opts.promptCacheProvider || 'openai-oauth';
+    const useResponsesLite = promptCacheProvider === 'openai-oauth'
+        && _codexModelUsesResponsesLite(model, opts);
     // Recovery-only encrypted-reasoning replay is DEFAULT ON for the OAuth
     // backend (validated 2026-08-11: smoke wire parity on normal chains +
     // live full-frame acceptance + full-run A/B). The per-socket policy in
@@ -297,6 +358,10 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
         model,
         nativeToolSearchProvider: promptCacheProvider,
         replayEncryptedReasoning,
+        codexWireParity: promptCacheProvider === 'openai-oauth',
+        codexMessageMetadata: (opts.turnId || opts.turn_id)
+            ? { turn_id: opts.turnId || opts.turn_id }
+            : {},
     });
     if (environmentText) {
         // Leading input item, after the cached prefix instead of inside it.
@@ -310,6 +375,13 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
                 type: 'input_text',
                 text: `<environment_context>\n${environmentText}\n</environment_context>`,
             }],
+            ...(promptCacheProvider === 'openai-oauth'
+                ? {
+                    internal_chat_message_metadata_passthrough: (opts.turnId || opts.turn_id)
+                        ? { turn_id: opts.turnId || opts.turn_id }
+                        : {},
+                }
+                : {}),
         });
     }
     // Match the request body shape the OAuth backend expects so the
@@ -322,9 +394,11 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
         const value = String(item || '').trim();
         if (value && !include.includes(value)) include.push(value);
     }
+    const supportsReasoningSummary = _codexModelSupportsReasoningSummaries(model);
     // Field order MIRRORS the reference request struct:
     // model, instructions, input, tools, tool_choice, parallel_tool_calls,
-    // reasoning, store, stream, include, service_tier, prompt_cache_key, text.
+    // reasoning, store, stream, stream_options, include, service_tier,
+    // prompt_cache_key, text.
     // JSON serialization order is load-bearing for the server prompt cache
     // (exact-prefix match): matching that byte layout keeps our requests on
     // the same cache-routing shape the backend warms. tools/service_tier/
@@ -346,10 +420,18 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
         // gpt-5.5. Match the observed bytes.
         reasoning: {
             effort: _normalizeReasoningEffort(opts.effort),
-            ...(replayEncryptedReasoning ? { context: 'all_turns' } : {}),
+            ...(supportsReasoningSummary ? { summary: 'auto' } : {}),
+            ...(useResponsesLite ? { context: 'all_turns' } : {}),
         },
         store: process.env.MIXDOG_OAI_STORE === 'true' ? true : false,
         stream: true,
+        ...(promptCacheProvider === 'openai-oauth' && supportsReasoningSummary
+            ? {
+                stream_options: {
+                    reasoning_summary_delivery: 'sequential_cutoff',
+                },
+            }
+            : {}),
         include,
     };
     const maxOutputTokens = Number(opts.maxOutputTokens ?? opts.outputTokens ?? opts.max_output_tokens);
@@ -379,6 +461,25 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
     const toolsList = (functionTools.length || nativeTools.length)
         ? [...nativeTools, ...functionTools]
         : null;
+    const liteTools = useResponsesLite ? _responsesLiteTools(toolsList || []) : null;
+    const wireInput = useResponsesLite
+        ? [
+            {
+                type: 'additional_tools',
+                role: 'developer',
+                tools: liteTools,
+            },
+            ...(instructions
+                ? [{
+                    type: 'message',
+                    role: 'developer',
+                    content: [{ type: 'input_text', text: instructions }],
+                }]
+                : []),
+            ...input,
+        ]
+        : input;
+    if (useResponsesLite) body.parallel_tool_calls = false;
     const promptCacheLane = opts.promptCacheLane || resolveProviderPromptCacheLane(promptCacheProvider, opts);
     const promptCacheKey = buildStableProviderPromptCacheKey(promptCacheProvider, opts, {
         model,
@@ -400,18 +501,20 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
         : null) || 'low';
     // Rebuild the body in codex struct order so JSON serialization is
     // byte-compatible with codex: ... input, tools, tool_choice,
-    // parallel_tool_calls, reasoning, store, stream, include, service_tier,
-    // prompt_cache_key, text. service_tier is only present when fast set it.
+    // parallel_tool_calls, reasoning, store, stream, stream_options, include,
+    // service_tier, prompt_cache_key, text. service_tier is only present when
+    // fast set it.
     const ordered = {
         model: body.model,
-        instructions: body.instructions,
-        input: body.input,
-        ...(toolsList ? { tools: toolsList } : {}),
+        ...(!useResponsesLite ? { instructions: body.instructions } : {}),
+        input: wireInput,
+        ...(!useResponsesLite && toolsList ? { tools: toolsList } : {}),
         tool_choice: body.tool_choice,
         parallel_tool_calls: body.parallel_tool_calls,
         reasoning: body.reasoning,
         store: body.store,
         stream: body.stream,
+        ...(body.stream_options ? { stream_options: body.stream_options } : {}),
         include: body.include,
         ...(body.service_tier ? { service_tier: body.service_tier } : {}),
         prompt_cache_key: promptCacheKey,

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

@@ -25,7 +25,7 @@ import {
 
 // Human-readable transport label for handshake/acquire error messages. Shared
 // with openai-oauth-ws.mjs (stream-side errors use the same labels).
-import { _envOn, _codexDashedId, _codexDashedIdV7, _codexBetaFeatures, _dumpHandshakeHeaders, _dumpFrame, _formatRedactedHeaders, _cfCookieHeader, _cfCookieCapture } from './openai-ws-headers.mjs';
+import { _envOn, _codexBetaFeatures, _dumpHandshakeHeaders, _dumpFrame, _formatRedactedHeaders, _cfCookieHeader, _cfCookieCapture } from './openai-ws-headers.mjs';
 export function _wsErrLabel(p) {
     if (p === 'xai') return 'xAI WS';
     if (p === 'openai-direct' || p === 'openai') return 'OpenAI WS';
@@ -410,24 +410,15 @@ function _buildHandshakeHeaders({ auth, sessionToken, turnState, cacheKey: _cach
             'x-codex-beta-features': _codexBetaFeatures(),
         };
     const isOpenAiOauth = auth.type !== 'xai' && auth.type !== 'openai-direct';
-    // Default mode preserves the measured Mixdog underscore session_id cache
-    // key. Strict wire parity instead follows Codex exactly: dashed
-    // session-id/thread-id only, UUIDv7-shaped ids, and x-client-request-id.
-    const wireParity = process.env.MIXDOG_OAI_CODEX_WIRE_PARITY === '1';
-    if (sessionToken && !wireParity) {
-        headers['session_id'] = String(sessionToken);
-    }
     if (isOpenAiOauth && (sessionToken || _cacheKey)) {
-        const uuidIds = wireParity;
-        const shapeId = wireParity ? _codexDashedIdV7 : _codexDashedId;
-        // Underscore `session_id` above is left as-is (backend prefix-dedupe
-        // key); only the dashed codex pair is reshaped under the opt-in.
-        const threadId = uuidIds ? shapeId(String(_cacheKey || sessionToken)) : String(_cacheKey || sessionToken);
-        const sessionId = uuidIds ? shapeId(String(sessionToken || _cacheKey)) : String(sessionToken || _cacheKey);
+        // Codex uses one caller-owned UUIDv7 identity everywhere. Prefer the
+        // metadata projection from the session; prompt_cache_key/sessionToken
+        // is the exact same UUID and remains a defensive fallback.
+        const sessionId = String(codexHeaders?.['session-id'] || sessionToken || _cacheKey);
+        const threadId = String(codexHeaders?.['thread-id'] || _cacheKey || sessionId);
         headers['session-id'] = sessionId;
         headers['thread-id'] = threadId;
-        // The reference client sets x-client-request-id to the dashed thread id.
-        headers['x-client-request-id'] = threadId;
+        headers['x-client-request-id'] = String(codexHeaders?.['x-client-request-id'] || threadId);
         if (codexHeaders && typeof codexHeaders === 'object') {
             for (const [key, value] of Object.entries(codexHeaders)) {
                 if (typeof key === 'string' && typeof value === 'string' && value) {
@@ -435,17 +426,6 @@ function _buildHandshakeHeaders({ auth, sessionToken, turnState, cacheKey: _cach
                 }
             }
         }
-        // Reshaped-id realignment: under wire parity the thread-id above becomes
-        // a Codex UUIDv7 (shapeId), while _codexWsCompatibilityHeaders derives
-        // x-codex-parent-thread-id from the RAW dashed thread_id — the merged
-        // codexHeaders would then carry a parent-thread id that no longer
-        // matches the thread-id on the same handshake. Realign it to the
-        // reshaped value (single source of truth: the pool owns the wire id
-        // shape). With no reshaping there is no mismatch, so codex's raw value
-        // stays untouched.
-        if (uuidIds && headers['x-codex-parent-thread-id']) {
-            headers['x-codex-parent-thread-id'] = threadId;
-        }
     } else {
         // xAI/direct keep a per-request value so their server-side traces stay
         // distinguishable across reconnects.

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

@@ -698,6 +698,17 @@ function _classifyMidstreamWs(err, state, attemptIndex, policy) {
   if (err?.wsSendFailed || state.wsSendFailed) {
     return _allowMidstream('ws_send_failed', attemptIndex, policy)
   }
+  // The Responses WebSocket emits its hard 60-minute retirement as a top-level
+  // `event.error`, not `response.failed`. openai-ws-stream preserves that typed
+  // object on err.payload; recognize only the documented code here so unknown
+  // pre-response error events remain terminal rather than becoming text-based
+  // retry guesses.
+  for (const field of [err?.payload?.code, err?.payload?.type]) {
+    const key = typeof field === 'string' ? field.trim().toLowerCase() : ''
+    if (key === WEBSOCKET_CONNECTION_LIMIT) {
+      return _allowMidstream('websocket_connection_limit', attemptIndex, policy)
+    }
+  }
   // Stall / local-close-4000 must be classified as RETRYABLE before the
   // pre-`response.created` deny gate below. A first-meaningful-frame timeout
   // fires with sawResponseCreated=false + close 4000 + StreamStalledError, so