mixdog 0.9.3 → 0.9.4

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

@@ -7,12 +7,12 @@
  * openai-oauth-ws.mjs; this file owns auth, model catalog, request-body
  * shape, and HTTP/SSE fallback when WebSocket transport is unhealthy.
  */
-import { createServer } from 'http';
-import { randomBytes, createHash } from 'crypto';
+import { createHash } from 'crypto';
 import { readFileSync, existsSync, mkdirSync, statSync, unlinkSync } from 'fs';
 import { join } from 'path';
 import { getPluginData } from '../config.mjs';
 import { enrichModels } from './model-catalog.mjs';
+import { sanitizeModelList } from './model-list-sanitize.mjs';
 import { writeJsonAtomicSync } from '../../../shared/atomic-file.mjs';
 import { makeModelCache } from './model-cache.mjs';
 
@@ -51,11 +51,31 @@ import {
     isResponsesFreeformTool,
     toResponsesCustomTool,
 } from './custom-tool-wire.mjs';
+import {
+    sendViaHttpSse,
+    _envFlag,
+    _envPositiveInt,
+    _shouldUseOpenAIHttpFallback,
+} from './openai-oauth-http-sse.mjs';
+import { createOpenAIOAuthLogin } from './openai-oauth-login.mjs';
+import {
+    _displayCodexModel,
+    _codexFamily,
+    _normalizeCodexModel,
+    _compareVersion,
+    _isMainCodexFamily,
+    _markLatestCodex,
+} from './openai-codex-model.mjs';
+export { _displayCodexModel };
+
+// Legacy import path for scripts/tool-smoke.mjs (single-emit SSE smoke).
+export { sendViaHttpSse };
 // --- Constants ---
 const CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
-const CODEX_OAUTH_ORIGINATOR = 'codex_cli_rs';
+// Exported for openai-oauth-http-sse.mjs (fallback transport headers/URL).
+export 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';
+export 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, and gates new model exposures (e.g.
 // gpt-5.5 only on >= 0.130.0) on this client_version header; older versions
@@ -63,7 +83,11 @@ const CODEX_RESPONSES_URL = 'https://chatgpt.com/backend-api/codex/responses';
 // 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';
+// Offline fallback only — _resolveCodexClientVersion() fetches the live
+// @openai/codex latest from npm first. Bumped to the current release
+// (0.142.5, verified 2026-07-03) so the offline path stays close to what the
+// backend expects for client-version gating.
+const CODEX_CLIENT_VERSION_FLOOR = '0.142.5';
 const CODEX_VERSION_CACHE_TTL_MS = 24 * 60 * 60_000;
 let _codexVersionCache = { value: null, fetchedAt: 0 };
 
@@ -118,10 +142,6 @@ let _codexRefreshInFlight = null;
 let _oauthRefreshInFlight = null;
 let _lastCodexListModelsError = '';
 
-export function getOpenAIOAuthModelCatalogError() {
-    return _lastCodexListModelsError;
-}
-
 function _codexCatalogHas(id) {
     if (!id || !Array.isArray(_inMemoryCodexCatalog)) return false;
     return _inMemoryCodexCatalog.some(m => m.id === id);
@@ -155,106 +175,6 @@ export function codexModelSupportsServiceTier(id, serviceTier) {
     return tiers.some(t => t?.id === serviceTier);
 }
 
-// OAuth catalog returns dated ids (gpt-5.4-mini-2026-03-17). Strip the trailing
-// -YYYY-MM-DD to get the version alias (gpt-5.4-mini). Unknown shapes pass
-// through unchanged.
-function _displayCodexModel(id) {
-    if (!id || typeof id !== 'string') return 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);
-    const serviceTiers = Array.isArray(m?.service_tiers)
-        ? m.service_tiers
-            .map(t => ({
-                id: String(t?.id || '').trim(),
-                name: String(t?.name || '').trim(),
-                description: String(t?.description || '').trim(),
-            }))
-            .filter(t => t.id)
-        : [];
-    const additionalSpeedTiers = Array.isArray(m?.additional_speed_tiers)
-        ? m.additional_speed_tiers.map(t => String(t || '').trim()).filter(Boolean)
-        : [];
-    // Catalog ids are version aliases without separate display dating.
-    return {
-        id,
-        name: m?.display_name || id,
-        display: m?.display_name || id,
-        family,
-        provider: 'openai-oauth',
-        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,
-        tier: 'version',
-        latest: false,
-        description: m?.description || '',
-        reasoningLevels: (m?.supported_reasoning_levels || []).map(r => r.effort),
-        serviceTiers,
-        defaultServiceTier: m?.default_service_tier || null,
-        additionalSpeedTiers,
-    };
-}
-
-function _codexFamily(id) {
-    const s = String(id || '').toLowerCase();
-    if (s.includes('nano')) return 'gpt-nano';
-    if (s.includes('mini')) return 'gpt-mini';
-    if (s.includes('codex')) return 'gpt-codex';
-    if (s.startsWith('gpt-5.5')) return 'gpt-5.5';
-    if (s.startsWith('gpt-5.4')) return 'gpt-5.4';
-    if (s.startsWith('gpt-5.2')) return 'gpt-5.2';
-    if (s.startsWith('gpt-5')) return 'gpt-5';
-    return 'gpt';
-}
-
-// Compare two model ids by the X.Y version embedded in `gpt-X.Y`. Mirrors
-// anthropic-oauth's _compareVersion; these ids have no trailing date so
-// the version lives in the dotted number, not a -YYYY-MM-DD suffix.
-function _compareVersion(a, b) {
-    const na = (String(a).match(/gpt-(\d+)\.(\d+)/) || []).slice(1).map(Number);
-    const nb = (String(b).match(/gpt-(\d+)\.(\d+)/) || []).slice(1).map(Number);
-    for (let i = 0; i < Math.max(na.length, nb.length); i++) {
-        if ((na[i] || 0) !== (nb[i] || 0)) return (na[i] || 0) - (nb[i] || 0);
-    }
-    return String(a).localeCompare(String(b));
-}
-
-// Main gpt-5 chat family only: exclude the mini/nano/codex variants so "latest"
-// resolves to the flagship, not a smaller sibling.
-function _isMainCodexFamily(family) {
-    return typeof family === 'string' && family.startsWith('gpt-5');
-}
-
-// Mark the highest-version model per family as `latest: true`. VERSION-based
-// (ids carry no `created`), mirroring anthropic-oauth's per-family pass.
-function _markLatestCodex(models) {
-    const byFamily = new Map();
-    for (const m of models) {
-        if (!m?.id) continue;
-        const cur = byFamily.get(m.family);
-        if (!cur || _compareVersion(m.id, cur.id) > 0) {
-            byFamily.set(m.family, m);
-        }
-    }
-    for (const m of byFamily.values()) m.latest = true;
-}
-
 // Newest MAIN gpt-5 chat model by version, read from the SYNC in-memory
 // catalog mirror. Returns null until populated; callers warm via
 // ensureLatestCodexModel when null.
@@ -577,7 +497,35 @@ function toOpenAIResponsesTool(t) {
     };
 }
 
+// codex build_reasoning() (core/src/client.rs:785-805) only attaches the
+// reasoning object when model_info.supports_reasoning_summaries; models
+// without summary support get NO reasoning field at all. Mirror that via the
+// cached codex catalog; unknown models default to true (gpt-5 family all
+// support summaries) so a cold catalog cannot strip reasoning from the wire.
+function _codexModelSupportsReasoningSummaries(id) {
+    const info = _findCachedCodexModel(id);
+    if (!info) return true;
+    const flags = [info.supportsReasoningSummaries, info.supports_reasoning_summaries, info.supportsReasoning, info.supports_reasoning];
+    for (const flag of flags) {
+        if (typeof flag === 'boolean') return flag;
+    }
+    return true;
+}
+
+// codex reasoning_effort_for_request (core/src/client.rs): `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.
+function _normalizeReasoningEffort(effort) {
+    const e = String(effort || '').trim().toLowerCase();
+    if (!e) return 'medium';
+    if (e === 'ultra') return 'max';
+    return e;
+}
+
 export function buildRequestBody(messages, model, tools, sendOpts) {
+    // codex reasoning_effort_for_request: `ultra` collapses to `max` on the
+    // wire (the only remap; every other effort passes through). Default medium.
+    // Kept inline (not a module const) so buildRequestBody stays self-contained.
     // Extract system/instructions
     const systemMsgs = messages.filter(m => m.role === 'system');
     const instructions = systemMsgs.map(m => m.content).join('\n\n') || 'You are a helpful assistant.';
@@ -596,17 +544,32 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
         const value = String(item || '').trim();
         if (value && !include.includes(value)) include.push(value);
     }
+    // Field order MIRRORS codex-rs ResponsesApiRequest (common.rs struct order):
+    // model, instructions, input, tools, tool_choice, parallel_tool_calls,
+    // reasoning, store, stream, include, service_tier, prompt_cache_key, text.
+    // JSON serialization order is load-bearing for the server prompt cache
+    // (exact-prefix match): matching codex's byte layout keeps our requests on
+    // the same cache-routing shape codex warms. tools/service_tier/
+    // prompt_cache_key are appended below in the same relative order.
     const body = {
         model,
         instructions,
         input,
+        tool_choice: opts.toolChoice || 'auto',
+        parallel_tool_calls: true,
+        // codex build_reasoning() sends { effort, summary } — summary defaults to
+        // ReasoningSummary::Auto (protocol config_types.rs), serialized lowercase
+        // as "auto". Matching this keeps our reasoning object byte-identical to
+        // codex so the server prompt-cache prefix hash lines up. codex also
+        // normalizes `ultra` -> `max` on the wire (reasoning_effort_for_request
+        // in core/src/client.rs); the openai-oauth backend does not accept
+        // `ultra` as a wire value, so mirror that mapping here.
+        ...(_codexModelSupportsReasoningSummaries(model)
+            ? { reasoning: { effort: _normalizeReasoningEffort(opts.effort), summary: 'auto' } }
+            : {}),
         store: process.env.MIXDOG_OAI_STORE === 'true' ? true : false,
         stream: true,
-        reasoning: { effort: opts.effort || 'medium' },
-        text: { verbosity: 'medium' },
         include,
-        tool_choice: opts.toolChoice || 'auto',
-        parallel_tool_calls: true,
     };
     const maxOutputTokens = Number(opts.maxOutputTokens ?? opts.outputTokens ?? opts.max_output_tokens);
     if (_envFlag('MIXDOG_OPENAI_OAUTH_SEND_MAX_OUTPUT_TOKENS', false)
@@ -625,20 +588,22 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
     }
     // Add tools. `nativeTools` are server-hosted Responses tools (for
     // example web_search) and must be passed through without wrapping them as
-    // function tools.
+    // function tools. codex places `tools` right after `input` (before
+    // tool_choice); we insert it there via a rebuilt object so serialization
+    // order matches, rather than appending it last.
     const functionTools = tools?.length ? tools.map(toOpenAIResponsesTool) : [];
     const nativeTools = Array.isArray(opts.nativeTools)
         ? opts.nativeTools.filter(t => t && typeof t === 'object')
         : [];
-    if (functionTools.length || nativeTools.length) {
-        body.tools = [...nativeTools, ...functionTools];
-    }
+    const toolsList = (functionTools.length || nativeTools.length)
+        ? [...nativeTools, ...functionTools]
+        : null;
     const promptCacheProvider = opts.promptCacheProvider || 'openai-oauth';
     const promptCacheLane = opts.promptCacheLane || resolveProviderPromptCacheLane(promptCacheProvider, opts);
-    body.prompt_cache_key = buildStableProviderPromptCacheKey(promptCacheProvider, opts, {
+    const promptCacheKey = buildStableProviderPromptCacheKey(promptCacheProvider, opts, {
         model,
         instructions,
-        tools: body.tools || [],
+        tools: toolsList || [],
         effort: body.reasoning?.effort,
         fast: opts.fast === true,
         serviceTier: body.service_tier || '',
@@ -647,716 +612,41 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
         cacheLaneSlot: promptCacheLane.slot,
         cacheLaneShards: promptCacheLane.shards,
     });
+    // codex only serializes `text` when a verbosity/schema is configured
+    // (common.rs create_text_param_for_request returns None otherwise); it has
+    // no unconditional { verbosity: 'medium' }. Sending an extra text object
+    // shifts every following byte vs codex's prefix layout.
+    const verbosity = typeof opts.verbosity === 'string' && opts.verbosity.trim()
+        ? opts.verbosity.trim().toLowerCase()
+        : null;
+    // 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.
+    const ordered = {
+        model: body.model,
+        instructions: body.instructions,
+        input: body.input,
+        ...(toolsList ? { tools: toolsList } : {}),
+        tool_choice: body.tool_choice,
+        parallel_tool_calls: body.parallel_tool_calls,
+        reasoning: body.reasoning,
+        store: body.store,
+        stream: body.stream,
+        include: body.include,
+        ...(body.service_tier ? { service_tier: body.service_tier } : {}),
+        prompt_cache_key: promptCacheKey,
+        ...(verbosity ? { text: { verbosity } } : {}),
+        ...(body.max_output_tokens ? { max_output_tokens: body.max_output_tokens } : {}),
+    };
     // NOTE: prompt_cache_retention is a public OpenAI Responses API parameter,
     // but the openai-oauth endpoint still rejects it ("Unsupported parameter:
     // prompt_cache_retention", re-probed 2026-06-22). Leave retention on the
     // openai-oauth server default; public OpenAI direct injects 24h separately.
-    return body;
-}
-
-function _envFlag(name, fallback = true) {
-    const raw = process.env[name];
-    if (raw == null || raw === '') return fallback;
-    return !['0', 'false', 'off', 'no'].includes(String(raw).toLowerCase());
-}
-
-function _envPositiveInt(name, fallback) {
-    const raw = process.env[name];
-    if (raw == null || raw === '') return fallback;
-    const n = Number(raw);
-    return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
-}
-
-// Completed function_call.arguments parse for the OpenAI Responses stream.
-// 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
-// of being silently swallowed to {}) so the dispatch loop turns it into an
-// is_error tool_result and the model self-corrects in the same turn.
-function _parseJsonObject(value) {
-    const text = typeof value === 'string' ? value : (value == null ? '' : String(value));
-    if (text.trim() === '') return {};
-    try {
-        const parsed = JSON.parse(text);
-        return parsed && typeof parsed === 'object' ? parsed : {};
-    } catch (err) {
-        return makeInvalidToolArgsMarker(text, err instanceof Error ? err.message : String(err));
-    }
+    return ordered;
 }
 
-function _extractCachedTokens(usage) {
-    const details = usage?.input_tokens_details || usage?.prompt_tokens_details || {};
-    return Number(details.cached_tokens ?? details.cached ?? usage?.cached_tokens ?? 0) || 0;
-}
-
-function _sseEventsFromBuffer(buffer) {
-    const frames = [];
-    let rest = buffer.replace(/\r\n/g, '\n');
-    let idx;
-    while ((idx = rest.indexOf('\n\n')) >= 0) {
-        frames.push(rest.slice(0, idx));
-        rest = rest.slice(idx + 2);
-    }
-    return { frames, rest };
-}
-
-function _parseSseFrame(frame) {
-    const lines = String(frame || '').split('\n');
-    const data = [];
-    for (const line of lines) {
-        if (!line || line.startsWith(':')) continue;
-        if (line.startsWith('data:')) data.push(line.slice(5).trimStart());
-    }
-    if (!data.length) return null;
-    const raw = data.join('\n').trim();
-    if (!raw || raw === '[DONE]') return null;
-    try { return JSON.parse(raw); } catch { return null; }
-}
-
-function _incompleteReasonFromEvent(event) {
-    const reasonObj = event?.response?.incomplete_details
-        || event?.incomplete_details
-        || event?.response?.status_details
-        || null;
-    return String(reasonObj?.reason || event?.response?.status || 'incomplete');
-}
-
-function _isMaxOutputIncompleteReason(reason) {
-    return /^(?:max_output_tokens|max_tokens|length|output_token_limit)$/i.test(String(reason || '').trim());
-}
-
-function _pushOutputTextAnnotations(part, citations, citationKeys) {
-    const annotations = Array.isArray(part?.annotations) ? part.annotations : [];
-    for (const raw of annotations) {
-        const url = raw?.url || raw?.uri || raw?.href || '';
-        if (!url || citationKeys.has(url)) continue;
-        citationKeys.add(url);
-        citations.push({
-            title: raw?.title || '',
-            url,
-            snippet: raw?.snippet || raw?.text || raw?.description || '',
-            source: 'openai-oauth',
-        });
-    }
-}
-
-function _buildOpenAIHttpFallbackHeaders({ auth, cacheKey }) {
-    const headers = {
-        Authorization: `Bearer ${auth.access_token}`,
-        'Content-Type': 'application/json',
-        Accept: 'text/event-stream',
-        'OpenAI-Beta': 'responses=experimental',
-        originator: CODEX_OAUTH_ORIGINATOR,
-        'chatgpt-account-id': auth.account_id || '',
-        'x-client-request-id': randomBytes(16).toString('hex'),
-    };
-    if (cacheKey) headers.session_id = String(cacheKey);
-    return headers;
-}
-
-// WS→HTTP/SSE fallback predicate → shared shouldFallbackTransport
-// (retry-classifier.mjs). The per-provider env flag is computed here and passed
-// as `enabled`; the deny-order + allow-list are identical to the former copy.
-function _shouldUseOpenAIHttpFallback(err, externalSignal) {
-    return shouldFallbackTransport(err, {
-        signal: externalSignal,
-        enabled: _envFlag('MIXDOG_OPENAI_OAUTH_HTTP_FALLBACK', true),
-    });
-}
-
-// Exported for the single-emit regression smoke (scripts/openai-oauth-
-// http-sse-toolcall-smoke.mjs): the SSE stream can surface the same
-// function_call across response.function_call_arguments.done +
-// response.output_item.done + response.completed, and onToolCall must fire
-// exactly once per call id. No production caller imports this name; the
-// provider invokes it internally.
-export async function sendViaHttpSse({
-    auth,
-    body,
-    opts,
-    onStreamDelta,
-    onToolCall,
-    onTextDelta,
-    onStageChange,
-    externalSignal,
-    poolKey,
-    cacheKey,
-    iteration,
-    useModel,
-    fetchFn = fetch,
-} = {}) {
-    // 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,
-        'OpenAI OAuth HTTP fallback initial response',
-    );
-    const headers = _buildOpenAIHttpFallbackHeaders({ auth, cacheKey });
-    const fetchStartedAt = Date.now();
-    let response;
-    try {
-        try { onStageChange?.('requesting'); } catch {}
-        response = await fetchFn(CODEX_RESPONSES_URL, {
-            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();
-    }
-
-    traceAgentFetch({
-        sessionId: poolKey,
-        headersMs: Date.now() - fetchStartedAt,
-        httpStatus: response.status,
-        provider: 'openai-oauth',
-        model: useModel,
-        transport: 'http',
-    });
-
-    if (!response.ok) {
-        const text = await response.text().catch(() => '');
-        const err = new Error(`OpenAI OAuth HTTP fallback ${response.status}: ${text.slice(0, 200)}`);
-        err.httpStatus = response.status;
-        err.headers = response.headers;
-        populateHttpStatusFromMessage(err, text);
-        totalTimeout.cleanup();
-        throw err;
-    }
-    if (!response.body) {
-        totalTimeout.cleanup();
-        throw new Error('OpenAI OAuth HTTP fallback returned no response body');
-    }
-
-    try { onStageChange?.('streaming'); } catch {}
-    const sseStartedAt = Date.now();
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    // After headerTimeout.cleanup() the in-flight fetch no longer carries a live
-    // signal, so a totalTimeout / external abort that fires during a pending
-    // reader.read() would otherwise leave the pooled request hanging. Keep the
-    // reader tied to totalTimeout for the whole stream: on abort, cancel the
-    // reader so the awaited read() unblocks and the socket is released back to
-    // the shared pool instead of leaking. reader.cancel() may resolve the
-    // pending read() as {done:true} rather than rejecting, which would let a
-    // partial response surface as success — so record the abort reason and
-    // re-throw it after the loop unblocks (see below).
-    let _streamAbortReason = null;
-    let _onTotalAbort = null;
-    if (totalTimeout.signal) {
-        _onTotalAbort = () => {
-            const reason = totalTimeout.signal.reason;
-            _streamAbortReason = reason instanceof Error
-                ? reason
-                : new Error('OpenAI OAuth HTTP fallback aborted');
-            try { reader.cancel(_streamAbortReason).catch(() => {}); } catch {}
-        };
-        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 = '';
-    let responseId = '';
-    let serviceTier = '';
-    let usage = null;
-    let ttftMs = null;
-    const toolCalls = [];
-    const pendingCalls = new Map();
-    const reasoningItems = [];
-    const citations = [];
-    const citationKeys = new Set();
-    const webSearchCalls = [];
-    const webSearchCallKeys = new Set();
-    let completed = false;
-    let stopReason = null;
-    // Gateway live-text relay invariant: set once a non-empty text chunk has
-    // been forwarded to the client. A failure afterwards is non-retryable —
-    // the rendered text cannot be withdrawn and a re-request would concatenate
-    // a second attempt.
-    let emittedText = false;
-
-    // Single-emit guard for tool calls (matches the WS path's
-    // emittedToolCall intent). The HTTP/SSE event stream can surface the
-    // same function_call across multiple frames — response.function_call_arguments.done,
-    // response.output_item.done, and the final response.completed.output
-    // bundle. Each frame independently completes the call (id + name) and
-    // would re-invoke onToolCall, double-executing a side-effecting tool.
-    // Route every emit through emitToolCall: it fires the callback exactly
-    // once per unique call id, the first time the call is complete. A call
-    // whose id/name only arrives in a later frame is NOT dropped — its
-    // 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);
-        if (webSearchCallKeys.has(key)) return;
-        webSearchCallKeys.add(key);
-        webSearchCalls.push({ id: item.id || '', status: item.status || '', action: item.action || null });
-    };
-    const pushReasoningItem = (item) => {
-        if (item?.type === 'reasoning' && item.encrypted_content && !reasoningItems.some(r => r.id === item.id)) {
-            reasoningItems.push({
-                id: item.id || '',
-                encrypted_content: item.encrypted_content,
-                summary: Array.isArray(item.summary) ? item.summary : [],
-            });
-        }
-    };
-    const pushToolSearchCall = (item) => {
-        if (!item || item.type !== 'tool_search_call') return;
-        const callId = item.call_id || item.id || '';
-        if (!callId || toolCalls.some(t => t.id === callId)) return;
-        let args = {};
-        if (item.arguments && typeof item.arguments === 'object') {
-            args = item.arguments;
-        } else if (typeof item.arguments === 'string' && item.arguments.trim()) {
-            // Non-empty but malformed tool_search arguments are deterministic
-            // bad JSON (the item is only emitted on completion). Surface an
-            // invalid-args marker instead of swallowing to {} so the model can
-            // self-correct in the same turn.
-            args = _parseJsonObject(item.arguments);
-        }
-        const call = {
-            id: callId,
-            name: 'tool_search',
-            arguments: args,
-            nativeType: 'tool_search_call',
-        };
-        toolCalls.push(call);
-        emitToolCall(call);
-    };
-    const pushCustomToolCall = (item) => {
-        const call = customToolCallFromResponseItem(item);
-        if (!call || toolCalls.some(t => t.id === call.id)) return;
-        toolCalls.push(call);
-        emitToolCall(call);
-    };
-    const meaningful = () => {
-        if (ttftMs == null) ttftMs = Date.now() - sseStartedAt;
-        _armSemanticIdle();
-        try { onStreamDelta?.(); } catch {}
-    };
-    const handleEvent = (event) => {
-        if (!event || typeof event.type !== 'string') return;
-        switch (event.type) {
-            case 'response.created':
-                if (event.response?.model) model = event.response.model;
-                if (event.response?.id) responseId = event.response.id;
-                break;
-            case 'response.output_text.delta':
-                meaningful();
-                relayLeakText(event.delta || '');
-                break;
-            case 'response.reasoning_text.delta':
-            case 'response.reasoning_summary_text.delta':
-                meaningful();
-                break;
-            case 'response.output_item.added':
-                if (event.item?.type === 'function_call') {
-                    pendingCalls.set(event.item.id || '', {
-                        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':
-                meaningful();
-                break;
-            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 || '',
-                    arguments: _parseJsonObject(event.arguments),
-                    _pendingItemId: itemId,
-                };
-                toolCalls.push(call);
-                if (call.id && call.name) {
-                    delete call._pendingItemId;
-                    emitToolCall(call);
-                }
-                meaningful();
-                break;
-            }
-            case 'response.custom_tool_call_input.delta':
-                meaningful();
-                break;
-            case 'response.output_item.done': {
-                const item = event.item || {};
-                pushReasoningItem(item);
-                pushWebSearchCall(item);
-                if (item.type === 'function_call') {
-                    const tc = toolCalls.find(t => t._pendingItemId === (item.id || ''));
-                    if (tc) {
-                        if (!tc.id && item.call_id) tc.id = item.call_id;
-                        if (!tc.name && item.name) tc.name = item.name;
-                        if (tc.id && tc.name) {
-                            delete tc._pendingItemId;
-                            emitToolCall(tc);
-                        }
-                    }
-                } else if (item.type === 'tool_search_call') {
-                    pendingCalls.delete(item.id || '');
-                    pushToolSearchCall(item);
-                } else if (item.type === 'custom_tool_call') {
-                    pushCustomToolCall(item);
-                    meaningful();
-                }
-                break;
-            }
-            case 'response.completed': {
-                const resp = event.response || {};
-                serviceTier = resp.service_tier || resp.serviceTier || serviceTier;
-                if (!model && resp.model) model = resp.model;
-                if (!responseId && resp.id) responseId = resp.id;
-                if (resp.usage) {
-                    usage = {
-                        inputTokens: resp.usage.input_tokens || 0,
-                        outputTokens: resp.usage.output_tokens || 0,
-                        cachedTokens: _extractCachedTokens(resp.usage),
-                        promptTokens: resp.usage.input_tokens || 0,
-                        raw: serviceTier ? { ...resp.usage, service_tier: serviceTier } : resp.usage,
-                    };
-                }
-                for (const item of resp.output || []) {
-                    if (item.type === 'message') {
-                        for (const part of item.content || []) {
-                            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') {
-                        pushReasoningItem(item);
-                    } else if (item.type === 'web_search_call') {
-                        pushWebSearchCall(item);
-                    } else if (item.type === 'tool_search_call') {
-                        pushToolSearchCall(item);
-                    } else if (item.type === 'custom_tool_call') {
-                        pushCustomToolCall(item);
-                        meaningful();
-                    } else if (item.type === 'function_call') {
-                        // Match the still-pending placeholder by item id, or
-                        // an already-recorded call by its canonical call_id —
-                        // so a call completed at args.done / output_item.done
-                        // is reused here rather than re-pushed as a duplicate.
-                        const tc = toolCalls.find(t =>
-                            t._pendingItemId === (item.id || '')
-                            || (item.call_id && t.id === item.call_id));
-                        if (tc) {
-                            if (!tc.id && item.call_id) tc.id = item.call_id;
-                            if (!tc.name && item.name) tc.name = item.name;
-                            if (tc.id && tc.name) {
-                                delete tc._pendingItemId;
-                                emitToolCall(tc);
-                            }
-                        } else if (item.call_id && item.name) {
-                            const call = {
-                                id: item.call_id,
-                                name: item.name,
-                                arguments: _parseJsonObject(item.arguments),
-                            };
-                            toolCalls.push(call);
-                            emitToolCall(call);
-                        }
-                    }
-                }
-                completed = true;
-                break;
-            }
-            case 'response.done':
-                if (!event.response || event.response.status === 'completed') completed = true;
-                else if (event.response.status === 'failed') {
-                    const msg = event.response?.error?.message || 'response.done failed';
-                    const err = new Error(`OpenAI OAuth HTTP fallback response.done failed: ${msg}`);
-                    populateHttpStatusFromMessage(err, msg);
-                    throw err;
-                } else if (event.response.status === 'incomplete') {
-                    const reason = _incompleteReasonFromEvent(event);
-                    if (_isMaxOutputIncompleteReason(reason)) {
-                        completed = true;
-                        stopReason = 'length';
-                        break;
-                    }
-                    throw new Error(`OpenAI OAuth HTTP fallback response.done incomplete: ${reason}`);
-                }
-                break;
-            case 'response.failed': {
-                const msg = event.response?.error?.message || event.error?.message || event.message || 'response.failed';
-                const err = new Error(`OpenAI OAuth HTTP fallback response.failed: ${msg}`);
-                populateHttpStatusFromMessage(err, msg);
-                throw err;
-            }
-            case 'response.incomplete': {
-                const reason = _incompleteReasonFromEvent(event);
-                if (_isMaxOutputIncompleteReason(reason)) {
-                    completed = true;
-                    stopReason = 'length';
-                    break;
-                }
-                throw new Error(`OpenAI OAuth HTTP fallback response.incomplete: ${reason}`);
-            }
-            case 'error': {
-                const msg = event.message || event.error?.message || 'unknown';
-                const err = new Error(`OpenAI OAuth HTTP fallback error: ${msg}`);
-                populateHttpStatusFromMessage(err, msg);
-                throw err;
-            }
-            default:
-                break;
-        }
-    };
-
-    try {
-        while (true) {
-            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 });
-            const parsed = _sseEventsFromBuffer(buffer);
-            buffer = parsed.rest;
-            for (const frame of parsed.frames) {
-                const event = _parseSseFrame(frame);
-                if (event) handleEvent(event);
-            }
-        }
-        // The read() above can unblock via reader.cancel() as {done:true} on an
-        // external/total-timeout abort. Surface that as the abort/timeout error
-        // instead of treating the partial stream as a successful response.
-        if (_streamAbortReason) throw _streamAbortReason;
-        buffer += decoder.decode();
-        const parsed = _sseEventsFromBuffer(buffer + '\n\n');
-        for (const frame of parsed.frames) {
-            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 {}
-        }
-        totalTimeout.cleanup();
-    }
-
-    const unresolved = toolCalls.find(t => t._pendingItemId);
-    if (unresolved) {
-        throw new Error(`OpenAI OAuth HTTP fallback function_call salvage failed: missing call_id/name for item_id=${unresolved._pendingItemId || '?'}`);
-    }
-    if (!completed && !content && !toolCalls.length) {
-        throw new Error('OpenAI OAuth HTTP fallback ended before response.completed');
-    }
-
-    const liveModel = model || useModel;
-    traceAgentSse({
-        sessionId: poolKey,
-        sseParseMs: Date.now() - sseStartedAt,
-        ttftMs,
-        provider: 'openai-oauth',
-        model: liveModel,
-        transport: 'sse',
-    });
-    if (usage) {
-        traceAgentUsage({
-            sessionId: poolKey,
-            iteration,
-            inputTokens: usage.inputTokens || 0,
-            outputTokens: usage.outputTokens || 0,
-            cachedTokens: usage.cachedTokens || 0,
-            promptTokens: usage.promptTokens || 0,
-            model: liveModel,
-            modelDisplay: _displayCodexModel(liveModel),
-            responseId: responseId || null,
-            rawUsage: usage.raw || null,
-            provider: 'openai-oauth',
-            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: _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,
-    };
-}
+// --- HTTP/SSE fallback transport: extracted to openai-oauth-http-sse.mjs ---
 
 // --- Provider ---
 export class OpenAIOAuthProvider {
@@ -1507,18 +797,12 @@ export class OpenAIOAuthProvider {
         const _authP = this.ensureAuth();
         let auth = await _authP;
         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 — a sibling cannot grab a mid-turn
-        // entry and trip the backend's "No tool call found for function call
-        // output with call_id …" rejection. cacheKey is prefix-scoped
-        // (base namespace + model/system/tools hash) and feeds both
-        // `body.prompt_cache_key` and the handshake `session_id` header, so
-        // compatible prefixes share cache without main/worker lanes evicting
-        // each other.
-        // poolKey defaults to sessionId (per-session socket isolation); cacheKey
-        // never falls back to sessionId, so a fresh session still reuses the
-        // warm prefix cache for the same route/prefix.
+        // 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.
         const poolKey  = opts.sessionId || null;
         const cacheKey = body.prompt_cache_key || resolveProviderCacheKey(opts, 'openai-oauth');
         const iteration = Number.isFinite(Number(opts.iteration)) ? Number(opts.iteration) : null;
@@ -1734,7 +1018,7 @@ export class OpenAIOAuthProvider {
             const items = Array.isArray(data?.models) ? data.models : [];
             const normalized = items.map(m => _normalizeCodexModel(m));
             _markLatestCodex(normalized);
-            const enriched = await enrichModels(normalized);
+            const enriched = sanitizeModelList((await enrichModels(normalized)).filter(Boolean), { provider: 'openai-oauth' });
             await _saveCodexModelCache(enriched);
             _lastCodexListModelsError = '';
             return enriched;
@@ -1772,7 +1056,7 @@ export class OpenAIOAuthProvider {
                 const items = Array.isArray(data?.models) ? data.models : [];
                 const normalized = items.map(m => _normalizeCodexModel(m));
                 _markLatestCodex(normalized);
-                const enriched = await enrichModels(normalized);
+                const enriched = sanitizeModelList((await enrichModels(normalized)).filter(Boolean), { provider: 'openai-oauth' });
                 await _saveCodexModelCache(enriched);
                 if (!process.env.MIXDOG_QUIET_PROVIDER_LOG) process.stderr.write(`[openai-oauth] catalog refreshed (${enriched.length} models)\n`);
                 return enriched;
@@ -1791,168 +1075,12 @@ export class OpenAIOAuthProvider {
     }
 }
 
-const AUTHORIZE_URL = 'https://auth.openai.com/oauth/authorize';
-const CODEX_OAUTH_SCOPE = 'openid profile email offline_access api.connectors.read api.connectors.invoke';
-const CALLBACK_HOST = '127.0.0.1';
-const CALLBACK_PORT = 1455;
-const CALLBACK_PATH = '/auth/callback';
-const REDIRECT_URI = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
-const LOGIN_TIMEOUT_MS = 5 * 60_000;
-const TOKEN_TIMEOUT_MS = 30_000;
-
-function generatePKCE() {
-    const verifier = randomBytes(64).toString('base64url');
-    const challenge = createHash('sha256').update(verifier).digest('base64url');
-    return { verifier, challenge };
-}
-
-function _scrubOAuthLoginBody(text) {
-    return String(text || '')
-        .replace(/"access_token"\s*:\s*"[^"]+"/g, '"access_token":"[REDACTED]"')
-        .replace(/"refresh_token"\s*:\s*"[^"]+"/g, '"refresh_token":"[REDACTED]"')
-        .replace(/"id_token"\s*:\s*"[^"]+"/g, '"id_token":"[REDACTED]"')
-        .replace(/[A-Za-z0-9_-]{32,}\.[A-Za-z0-9._-]+/g, '[REDACTED]');
-}
-
-function _parseOAuthCodeInput(input) {
-    const value = String(input || '').trim();
-    if (!value) return { code: '', state: '' };
-    try {
-        const url = new URL(value);
-        const code = url.searchParams.get('code') || '';
-        const state = url.searchParams.get('state') || '';
-        if (code || state) return { code, state };
-    } catch { /* not a URL */ }
-    if (value.includes('#')) {
-        const [code, state] = value.split('#', 2);
-        return { code: String(code || '').trim(), state: String(state || '').trim() };
-    }
-    if (value.includes('code=')) {
-        const params = new URLSearchParams(value.startsWith('?') ? value.slice(1) : value);
-        return { code: params.get('code') || '', state: params.get('state') || '' };
-    }
-    return { code: value, state: '' };
-}
-
-async function exchangeAuthorizationCode({ pkce, code }) {
-    const cleanCode = String(code || '').trim();
-    if (!cleanCode) throw new Error('[openai-oauth] authorization code is required');
-    const tokenRes = await fetch(TOKEN_URL, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-        body: new URLSearchParams({
-            grant_type: 'authorization_code',
-            code: cleanCode,
-            redirect_uri: REDIRECT_URI,
-            client_id: CLIENT_ID,
-            code_verifier: pkce.verifier,
-        }),
-        redirect: 'error',
-        signal: AbortSignal.timeout(TOKEN_TIMEOUT_MS),
-    });
-    if (!tokenRes.ok) {
-        const text = await tokenRes.text().catch(() => '');
-        throw new Error(`[openai-oauth] token exchange ${tokenRes.status}: ${_scrubOAuthLoginBody(text).slice(0, 500)}`);
-    }
-    const json = await tokenRes.json();
-    if (!json.access_token || !json.refresh_token) {
-        throw new Error('[openai-oauth] token exchange response missing access_token or refresh_token');
-    }
-    const expiresAt = (typeof json.expires_in === 'number'
-        ? Date.now() + json.expires_in * 1000
-        : 0) || _expiryFromAccessToken(json.access_token);
-    const tokens = {
-        access_token: json.access_token,
-        refresh_token: json.refresh_token,
-        expires_at: expiresAt,
-        account_id: extractAccountId(json.access_token),
-    };
-    saveTokens(tokens);
-    return tokens;
-}
-
-export async function beginOAuthLogin() {
-    const pkce = generatePKCE();
-    const state = randomBytes(16).toString('hex');
-    const url = new URL(AUTHORIZE_URL);
-    url.searchParams.set('response_type', 'code');
-    url.searchParams.set('client_id', CLIENT_ID);
-    url.searchParams.set('redirect_uri', REDIRECT_URI);
-    url.searchParams.set('scope', CODEX_OAUTH_SCOPE);
-    url.searchParams.set('code_challenge', pkce.challenge);
-    url.searchParams.set('code_challenge_method', 'S256');
-    url.searchParams.set('id_token_add_organizations', 'true');
-    url.searchParams.set('codex_cli_simplified_flow', 'true');
-    url.searchParams.set('state', state);
-    url.searchParams.set('originator', CODEX_OAUTH_ORIGINATOR);
-
-    let server = null;
-    let timeout = null;
-    let finish = null;
-    const waitForCallback = new Promise((resolve, reject) => {
-        let settled = false;
-        finish = (value, error = null) => {
-            if (settled) return;
-            settled = true;
-            if (timeout) clearTimeout(timeout);
-            try { server?.close(); } catch { /* already closed */ }
-            if (error) reject(error);
-            else resolve(value);
-        };
-        server = createServer(async (req, res) => {
-            const u = new URL(req.url || '/', `http://${CALLBACK_HOST}:${CALLBACK_PORT}`);
-            if (u.pathname !== CALLBACK_PATH) {
-                res.writeHead(404);
-                res.end();
-                return;
-            }
-            const code = u.searchParams.get('code');
-            if (!code || u.searchParams.get('state') !== state) {
-                res.writeHead(400);
-                res.end('Invalid');
-                finish(null);
-                return;
-            }
-            res.writeHead(200, { 'Content-Type': 'text/html' });
-            res.end('<html><body><h2>OpenAI OAuth login successful! You can close this tab.</h2></body></html>');
-            try {
-                const tokens = await exchangeAuthorizationCode({ pkce, code });
-                finish(tokens);
-            } catch (err) {
-                finish(null, err instanceof Error ? err : new Error(String(err)));
-            }
-        });
-        timeout = setTimeout(() => finish(null), LOGIN_TIMEOUT_MS);
-        server.listen(CALLBACK_PORT, CALLBACK_HOST, async () => {
-            process.stderr.write(`\n[openai-oauth] Open this URL to log in to ChatGPT (OpenAI OAuth):\n${url.toString()}\n\n`);
-            try {
-                const { openInBrowser } = await import('../../../shared/open-url.mjs');
-                openInBrowser(url.toString());
-            } catch (err) {
-                process.stderr.write(`[openai-oauth] browser open failed: ${String(err?.message || err).slice(0, 200)}\n`);
-            }
-        });
-        server.on('error', (err) => finish(null, new Error(`[openai-oauth] callback server failed on ${CALLBACK_HOST}:${CALLBACK_PORT}: ${err?.message || err}`)));
-    });
-
-    return {
-        provider: 'openai-oauth',
-        url: url.toString(),
-        waitForCallback,
-        completeCode: async (input) => {
-            const parsed = _parseOAuthCodeInput(input);
-            if (parsed.state && parsed.state !== state) throw new Error('[openai-oauth] OAuth state mismatch');
-            const tokens = await exchangeAuthorizationCode({ pkce, code: parsed.code });
-            finish?.(tokens);
-            return tokens;
-        },
-        cancel: () => {
-            finish?.(null);
-        },
-    };
-}
-
-export async function loginOAuth() {
-    const login = await beginOAuthLogin();
-    return await login.waitForCallback;
-}
+// --- OAuth PKCE login flow: extracted to openai-oauth-login.mjs ---
+const { beginOAuthLogin, loginOAuth } = createOpenAIOAuthLogin({
+    clientId: CLIENT_ID,
+    originator: CODEX_OAUTH_ORIGINATOR,
+    extractAccountId,
+    expiryFromAccessToken: _expiryFromAccessToken,
+    saveTokens,
+});
+export { beginOAuthLogin, loginOAuth };