mixdog 0.8.0 → 0.9.0

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

@@ -1,9 +1,9 @@
 /**
- * OpenAI ChatGPT OAuth (Codex) provider.
+ * OpenAI ChatGPT OAuth subscription provider.
  *
  * Dispatches over the WebSocket upgrade of chatgpt.com/backend-api/codex/
  * responses (responses_websockets=2026-02-06 beta). Authenticates via PKCE
- * OAuth or reuses ~/.codex/auth.json. Streaming/framing lives in
+ * OAuth using Mixdog-owned token storage. Streaming/framing lives in
  * openai-oauth-ws.mjs; this file owns auth, model catalog, request-body
  * shape, and HTTP/SSE fallback when WebSocket transport is unhealthy.
  */
@@ -11,7 +11,6 @@ import { createServer } from 'http';
 import { randomBytes, createHash } from 'crypto';
 import { readFileSync, existsSync, mkdirSync, statSync, unlinkSync } from 'fs';
 import { join } from 'path';
-import { homedir } from 'os';
 import { getPluginData } from '../config.mjs';
 import { enrichModels } from './model-catalog.mjs';
 import { writeJsonAtomicSync } from '../../../shared/atomic-file.mjs';
@@ -22,13 +21,13 @@ import {
     buildStableProviderPromptCacheKey,
     resolveProviderPromptCacheLane,
     resolveProviderCacheKey,
-} from '../smart-bridge/cache-strategy.mjs';
+} from '../agent-runtime/cache-strategy.mjs';
 import {
-    appendBridgeTrace,
-    traceBridgeFetch,
-    traceBridgeSse,
-    traceBridgeUsage,
-} from '../bridge-trace.mjs';
+    appendAgentTrace,
+    traceAgentFetch,
+    traceAgentSse,
+    traceAgentUsage,
+} from '../agent-trace.mjs';
 import {
     PROVIDER_GENERATE_TOTAL_TIMEOUT_MS,
     PROVIDER_HTTP_RESPONSE_TIMEOUT_MS,
@@ -36,24 +35,28 @@ import {
 } from '../stall-policy.mjs';
 import { populateHttpStatusFromMessage } from './retry-classifier.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
+import { makeInvalidToolArgsMarker } from './openai-compat-stream.mjs';
 import {
-    contentHasImage,
     normalizeContentForOpenAIResponses,
     splitToolContentForOpenAIResponses,
 } from './media-normalization.mjs';
+import {
+    customToolCallFromResponseItem,
+    customToolInputFromArguments,
+    isCustomToolCallRecord,
+    isResponsesFreeformTool,
+    toResponsesCustomTool,
+} from './custom-tool-wire.mjs';
 // --- Constants ---
 const CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
 const CODEX_OAUTH_ORIGINATOR = 'codex_cli_rs';
 const TOKEN_URL = 'https://auth.openai.com/oauth/token';
 const CODEX_RESPONSES_URL = 'https://chatgpt.com/backend-api/codex/responses';
-const OPENAI_CODEX_REMOTE_COMPACT_FALLBACK = 'openai-codex';
-const OPENAI_CODEX_REMOTE_COMPACT_VERSION = 1;
-const REMOTE_COMPACT_RETAINED_TOKEN_BUDGET = 64_000;
-// Version string baked into the models endpoint query — Codex rejects the
-// request without it. Keep close to the latest published Codex CLI because
+// Version string baked into the models endpoint query — the OAuth backend rejects the
+// request without it. Keep close to the latest published @openai/codex CLI because
 // older versions trigger a visibility-filtered catalog (e.g. only rollout
 // models). Bump when the real CLI bumps.
-// Codex backend gates new model exposures (e.g. gpt-5.5 only on >= 0.130.0)
+// OpenAI OAuth backend gates new model exposures (e.g. gpt-5.5 only on >= 0.130.0)
 // on the client_version header. Resolve dynamically from npm so newly-shipped
 // models surface within a day instead of waiting on a hardcoded bump here.
 // Cached 24h in-process; npm failure falls back to the floor below.
@@ -149,7 +152,7 @@ export function codexModelSupportsServiceTier(id, serviceTier) {
     return tiers.some(t => t?.id === serviceTier);
 }
 
-// Codex returns dated ids (gpt-5.4-mini-2026-03-17). Strip the trailing
+// 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) {
@@ -172,7 +175,7 @@ function _normalizeCodexModel(m) {
     const additionalSpeedTiers = Array.isArray(m?.additional_speed_tiers)
         ? m.additional_speed_tiers.map(t => String(t || '').trim()).filter(Boolean)
         : [];
-    // Codex doesn't use dated ids — everything is effectively a version alias.
+    // Catalog ids are version aliases without separate display dating.
     return {
         id,
         name: m?.display_name || id,
@@ -206,8 +209,8 @@ function _codexFamily(id) {
     return 'gpt';
 }
 
-// Compare two Codex ids by the X.Y version embedded in `gpt-X.Y`. Mirrors
-// anthropic-oauth's _compareVersion, but Codex ids have no trailing date so
+// 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);
@@ -225,7 +228,7 @@ function _isMainCodexFamily(family) {
 }
 
 // Mark the highest-version model per family as `latest: true`. VERSION-based
-// (Codex ids carry no `created`), mirroring anthropic-oauth's per-family pass.
+// (ids carry no `created`), mirroring anthropic-oauth's per-family pass.
 function _markLatestCodex(models) {
     const byFamily = new Map();
     for (const m of models) {
@@ -268,7 +271,7 @@ function getOwnTokenPath() {
 }
 
 // Public predicate used by config.buildDefaultConfig — provider is enabled
-// when own tokens exist OR codex bootstrap auth is present. Single truth:
+// when own Mixdog tokens exist. Single truth:
 // same loader the runtime uses (loadTokens), no parallel hard-coded path probe.
 export function hasOpenAIOAuthCredentials() {
     try {
@@ -281,7 +284,7 @@ export function describeOpenAIOAuthCredentials() {
     try {
         const tokens = loadTokens();
         if (!tokens?.access_token) {
-            return { authenticated: false, status: 'Not Set', detail: '~/.codex/auth.json or mixdog token store' };
+            return { authenticated: false, status: 'Not Set', detail: 'Mixdog token store' };
         }
         const hasRefresh = Boolean(tokens.refresh_token);
         const expiresAt = _normalizeExpiresAt(tokens.expires_at ?? tokens.expiresAt);
@@ -310,7 +313,7 @@ function _normalizeExpiresAt(value) {
 }
 function _tokensMaxMtime() {
     let max = 0;
-    const paths = [getOwnTokenPath(), join(homedir(), '.codex', 'auth.json')];
+    const paths = [getOwnTokenPath()];
     for (const p of paths) {
         try {
             const s = statSync(p);
@@ -319,10 +322,6 @@ function _tokensMaxMtime() {
     }
     return max;
 }
-
-function _codexCliAuthPath() {
-    return join(homedir(), '.codex', 'auth.json');
-}
 function _loadOwnCodexTokens() {
     const ownPath = getOwnTokenPath();
     if (!existsSync(ownPath)) return null;
@@ -334,7 +333,7 @@ function _loadOwnCodexTokens() {
                 ...own,
                 expires_at: _normalizeExpiresAt(own.expires_at ?? own.expiresAt) || _expiryFromAccessToken(own.access_token),
                 account_id: own.account_id || extractAccountId(own.access_token),
-                source: 'mixdog',
+                source: 'Mixdog token store',
                 _mtimeMs: stat.mtimeMs,
             };
         }
@@ -342,38 +341,8 @@ function _loadOwnCodexTokens() {
     catch { /* fall through */ }
     return null;
 }
-function _loadCodexCliTokens() {
-    const codexPath = _codexCliAuthPath();
-    if (!existsSync(codexPath)) return null;
-    try {
-        const stat = statSync(codexPath);
-        const data = JSON.parse(readFileSync(codexPath, 'utf-8'));
-        const tokens = data.tokens || data;
-        if (tokens.access_token && tokens.refresh_token) {
-            const expiresAt = _normalizeExpiresAt(data.expires_at ?? tokens.expires_at ?? data.expiresAt ?? tokens.expiresAt) || _expiryFromAccessToken(tokens.access_token);
-            return {
-                access_token: tokens.access_token,
-                refresh_token: tokens.refresh_token,
-                expires_at: expiresAt,
-                account_id: tokens.account_id || extractAccountId(tokens.access_token),
-                source: 'codex-cli',
-                _mtimeMs: stat.mtimeMs,
-            };
-        }
-    }
-    catch { /* fall through */ }
-    return null;
-}
-// Own store is authoritative (accurate expires_at from refresh); the Codex CLI
-// store seeds the initial bootstrap. But the refresh-token lineage is shared
-// single-use with the Codex CLI, so when the CLI store is STRICTLY newer on
-// disk (an independent `codex login`/CLI refresh) we must adopt it instead of
-// replaying our consumed token. Freshest-wins, own preferred on a tie.
 function loadTokens() {
-    const own = _loadOwnCodexTokens();
-    const cli = _loadCodexCliTokens();
-    if (own && cli) return (cli._mtimeMs > own._mtimeMs) ? cli : own;
-    return own || cli;
+    return _loadOwnCodexTokens();
 }
 function saveTokens(tokens) {
     const target = getOwnTokenPath();
@@ -387,55 +356,8 @@ export function forgetOpenAIOAuthCredentials() {
         unlinkSync(ownPath);
         removed = true;
     }
-    const codexPath = _codexCliAuthPath();
-    if (existsSync(codexPath)) {
-        try {
-            const raw = JSON.parse(readFileSync(codexPath, 'utf-8'));
-            if (raw?.tokens && typeof raw.tokens === 'object') {
-                delete raw.tokens.access_token;
-                delete raw.tokens.refresh_token;
-                delete raw.tokens.id_token;
-                raw.last_refresh = new Date().toISOString();
-                writeJsonAtomicSync(codexPath, raw, { lock: true, fsyncDir: true });
-                removed = true;
-            } else if (raw?.access_token || raw?.refresh_token) {
-                delete raw.access_token;
-                delete raw.refresh_token;
-                delete raw.id_token;
-                raw.last_refresh = new Date().toISOString();
-                writeJsonAtomicSync(codexPath, raw, { lock: true, fsyncDir: true });
-                removed = true;
-            }
-        } catch (err) {
-            throw new Error(`OpenAI OAuth reset failed for ${codexPath}: ${err?.message || err}`);
-        }
-    }
     return { removed };
 }
-// Write rotated tokens back to the Codex CLI store (~/.codex/auth.json) so the
-// Codex CLI picks up the rotation instead of replaying a consumed refresh_token
-// from the shared single-use lineage. Mirrors anthropic-oauth's write-back.
-// Best-effort; the own store stays authoritative. Host-owned file: preserve all
-// other fields and don't re-permission it (no secret/mode).
-function _writeBackCodexCliTokens(tokens) {
-    const path = _codexCliAuthPath();
-    if (!existsSync(path)) return;
-    try {
-        const raw = JSON.parse(readFileSync(path, 'utf-8'));
-        if (!raw || typeof raw !== 'object') return;
-        const slot = (raw.tokens && typeof raw.tokens === 'object') ? raw.tokens : raw;
-        slot.access_token = tokens.access_token;
-        slot.refresh_token = tokens.refresh_token;
-        raw.last_refresh = new Date().toISOString();
-        // Preserve the Codex CLI file's existing POSIX mode (writeJsonAtomicSync
-        // otherwise defaults to 0o600, re-permissioning a host-owned file).
-        let mode;
-        try { mode = statSync(path).mode & 0o777; } catch { /* keep helper default */ }
-        writeJsonAtomicSync(path, raw, { lock: true, fsyncDir: true, mode });
-    } catch (err) {
-        process.stderr.write(`[openai-oauth] Codex CLI store write-back failed: ${String(err?.message || err).slice(0, 200)}\n`);
-    }
-}
 function extractAccountId(token) {
     try {
         const parts = token.split('.');
@@ -449,11 +371,7 @@ function extractAccountId(token) {
     }
 }
 // Derive token expiry from the access_token's JWT `exp` claim (epoch ms), as a
-// fallback when the source store carries no explicit expires_at — e.g. the Codex
-// CLI's ~/.codex/auth.json records only last_refresh, so expires_at resolves to 0
-// and ensureAuth reads that as "never expires", disabling proactive refresh; the
-// token then only refreshes reactively after a request fails (and a WS handshake
-// 401 can surface as an opaque transport error that the 401 path misses). Returns
+// fallback when the Mixdog token store carries no explicit expires_at. Returns
 // 0 for opaque (non-JWT) tokens. JWT `exp` is epoch SECONDS (RFC 7519).
 function _expiryFromAccessToken(token) {
     try {
@@ -487,7 +405,7 @@ async function refreshTokens(refreshToken) {
         });
         if (!res.ok) {
             const text = await res.text().catch(() => '');
-            // Distinguish a terminally-dead refresh token (consumed by the Codex
+            // Distinguish a terminally-dead refresh token (consumed by the official
             // CLI's single-use lineage) from transient failures, so the caller can
             // re-read disk and retry once with a newer token instead of
             // collapsing every failure to a generic null.
@@ -506,11 +424,6 @@ async function refreshTokens(refreshToken) {
             expires_at: expiresAt,
             account_id: extractAccountId(json.access_token),
         };
-        // CLI store first, own store last: the own store keeps the newest mtime
-        // (and its accurate refresh expires_at), so freshest-wins loadTokens
-        // treats our refresh as authoritative while the CLI still picks up the
-        // rotated token.
-        _writeBackCodexCliTokens(tokens);
         saveTokens(tokens);
         return tokens;
     } catch (err) {
@@ -526,18 +439,6 @@ function _cloneJson(value) {
     try { return JSON.parse(JSON.stringify(value)); } catch { return value; }
 }
 
-function _nativeCompactState(providerState, model) {
-    const state = providerState?.openaiCodex?.remoteCompact;
-    if (!state || state.version !== OPENAI_CODEX_REMOTE_COMPACT_VERSION) return null;
-    if (!Array.isArray(state.nativePrefix) || state.nativePrefix.length === 0) return null;
-    if (state.model && model && state.model !== model) return null;
-    return state;
-}
-
-function _isRemoteCompactFallbackMessage(m) {
-    return m?._mixdogRemoteCompactFallback === OPENAI_CODEX_REMOTE_COMPACT_FALLBACK;
-}
-
 function _contentTextParts(content, type = 'input_text') {
     if (typeof content === 'string') return content ? [{ type, text: content }] : [];
     if (!Array.isArray(content)) {
@@ -556,127 +457,41 @@ function _contentTextParts(content, type = 'input_text') {
     return out;
 }
 
-function _messageToNativeRetainedItem(m) {
-    const role = m?.role;
-    if (role !== 'user') return null;
-    if (_isRemoteCompactFallbackMessage(m)) return null;
-    const content = _contentTextParts(m.content, 'input_text');
-    if (!content.length) return null;
-    return { type: 'message', role, content };
-}
-
-function _nativeMessageTextTokenCount(item) {
-    if (!item || item.type !== 'message') return 0;
-    const content = Array.isArray(item.content) ? item.content : [];
-    let chars = 0;
-    for (const part of content) {
-        if (typeof part?.text === 'string') chars += part.text.length;
-    }
-    return Math.max(1, Math.ceil(chars / 4));
-}
-
-function _truncateTextForTokens(text, maxTokens) {
-    const value = String(text || '');
-    const maxChars = Math.max(0, Math.floor(maxTokens * 4));
-    if (value.length <= maxChars) return value;
-    if (maxChars <= 32) return value.slice(0, maxChars);
-    const marker = `...${Math.max(1, Math.ceil((value.length - maxChars) / 4))} tokens truncated...`;
-    const room = Math.max(0, maxChars - marker.length);
-    const head = Math.ceil(room / 2);
-    const tail = Math.floor(room / 2);
-    return `${value.slice(0, head)}${marker}${value.slice(value.length - tail)}`;
-}
-
-function _truncateNativeMessageToTokenBudget(item, maxTokens) {
-    if (!item || item.type !== 'message') return item;
-    const clone = _cloneJson(item);
-    let remaining = Math.max(0, Math.floor(maxTokens));
-    const content = [];
-    for (const part of Array.isArray(clone.content) ? clone.content : []) {
-        if (typeof part?.text !== 'string') {
-            content.push(part);
-            continue;
-        }
-        if (remaining <= 0) continue;
-        const tokenCount = Math.max(1, Math.ceil(part.text.length / 4));
-        if (tokenCount <= remaining) {
-            content.push(part);
-            remaining -= tokenCount;
-        } else {
-            const truncated = _truncateTextForTokens(part.text, remaining);
-            if (truncated) content.push({ ...part, text: truncated });
-            remaining = 0;
-        }
-    }
-    if (!content.length) return null;
-    clone.content = content;
-    return clone;
-}
-
-function _truncateRetainedNativeMessages(items, maxTokens = REMOTE_COMPACT_RETAINED_TOKEN_BUDGET) {
-    let remaining = Math.max(0, Math.floor(maxTokens));
-    const reversed = [];
-    for (let i = items.length - 1; i >= 0; i -= 1) {
-        if (remaining <= 0) break;
-        const item = items[i];
-        const tokenCount = _nativeMessageTextTokenCount(item);
-        if (tokenCount <= remaining) {
-            reversed.push(item);
-            remaining -= tokenCount;
-            continue;
-        }
-        const truncated = _truncateNativeMessageToTokenBudget(item, remaining);
-        if (truncated) reversed.push(truncated);
-        remaining = 0;
-    }
-    return reversed.reverse();
-}
-
-function _buildOpenAICodexNativeCompactPrefix(messages, compactionItem) {
-    const retained = [];
-    for (const m of messages || []) {
-        const item = _messageToNativeRetainedItem(m);
-        if (item) retained.push(item);
-    }
-    const compact = _cloneJson(compactionItem);
-    return [..._truncateRetainedNativeMessages(retained), compact];
-}
-
-function _withOpenAICodexRemoteCompactState(providerState, { model, nativePrefix, responseId } = {}) {
-    return {
-        ...(providerState || {}),
-        openaiCodex: {
-            ...(providerState?.openaiCodex || {}),
-            remoteCompact: {
-                version: OPENAI_CODEX_REMOTE_COMPACT_VERSION,
-                model: model || null,
-                nativePrefix,
-                responseId: responseId || null,
-                installedAt: Date.now(),
-            },
-        },
-    };
-}
-
 /**
  * Convert a message slice to Responses API input items.
  */
 function convertMessagesToResponsesInput(messages, opts = {}) {
     const out = [];
-    const nativeCompact = _nativeCompactState(opts.providerState, opts.model);
-    if (nativeCompact) {
-        for (const item of nativeCompact.nativePrefix) out.push(_cloneJson(item));
-    }
     const pendingToolMedia = [];
+    const customToolCallNameById = new Map();
     const flushToolMedia = () => {
         if (!pendingToolMedia.length) return;
         out.push({ role: 'user', content: pendingToolMedia.splice(0) });
     };
     for (const m of messages) {
         if (!m || m.role === 'system') continue;
-        if (nativeCompact && _isRemoteCompactFallbackMessage(m)) continue;
         if (m.role === 'tool') {
+            if (Array.isArray(m.nativeToolSearch?.openaiTools)) {
+                out.push({
+                    type: 'tool_search_output',
+                    call_id: m.toolCallId || '',
+                    status: 'completed',
+                    execution: 'client',
+                    tools: m.nativeToolSearch.openaiTools,
+                });
+                continue;
+            }
             const { output, mediaContent } = splitToolContentForOpenAIResponses(m.content);
+            if (customToolCallNameById.has(m.toolCallId || '')) {
+                out.push({
+                    type: 'custom_tool_call_output',
+                    call_id: m.toolCallId || '',
+                    name: customToolCallNameById.get(m.toolCallId || '') || undefined,
+                    output,
+                });
+                if (mediaContent) pendingToolMedia.push(...mediaContent);
+                continue;
+            }
             out.push({
                 type: 'function_call_output',
                 call_id: m.toolCallId || '',
@@ -687,7 +502,7 @@ function convertMessagesToResponsesInput(messages, opts = {}) {
         }
         flushToolMedia();
         if (m.role === 'assistant' && Array.isArray(m.toolCalls) && m.toolCalls.length) {
-            // Reasoning replay deliberately omitted: Codex rejects an
+            // Reasoning replay deliberately omitted: openai-oauth rejects an
             // `rs_*` reasoning item with the same id across the same
             // handshake session_id (in-memory conversation state lives
             // for the WS_IDLE_MS window even after a socket close).
@@ -695,12 +510,29 @@ function convertMessagesToResponsesInput(messages, opts = {}) {
             // reasoning in `input` triggers "Duplicate item".
             if (m.content) out.push({ role: 'assistant', content: normalizeContentForOpenAIResponses(m.content, { role: 'assistant' }) });
             for (const tc of m.toolCalls) {
-                out.push({
-                    type: 'function_call',
-                    call_id: tc.id,
-                    name: tc.name,
-                    arguments: JSON.stringify(tc.arguments),
-                });
+                if (tc.nativeType === 'tool_search_call' || tc.name === 'tool_search') {
+                    out.push({
+                        type: 'tool_search_call',
+                        call_id: tc.id,
+                        execution: 'client',
+                        arguments: tc.arguments || {},
+                    });
+                } else if (isCustomToolCallRecord(tc)) {
+                    if (tc.id) customToolCallNameById.set(tc.id, tc.name || '');
+                    out.push({
+                        type: 'custom_tool_call',
+                        call_id: tc.id,
+                        name: tc.name,
+                        input: customToolInputFromArguments(tc.name, tc.arguments),
+                    });
+                } else {
+                    out.push({
+                        type: 'function_call',
+                        call_id: tc.id,
+                        name: tc.name,
+                        arguments: JSON.stringify(tc.arguments),
+                    });
+                }
             }
             continue;
         }
@@ -713,8 +545,22 @@ function convertMessagesToResponsesInput(messages, opts = {}) {
     return out;
 }
 
-function messagesHaveImageContent(messages) {
-    return (messages || []).some((m) => contentHasImage(m?.content));
+function toOpenAIResponsesTool(t) {
+    if (t?.name === 'tool_search') {
+        return {
+            type: 'tool_search',
+            execution: 'client',
+            description: t.description,
+            parameters: t.inputSchema,
+        };
+    }
+    if (isResponsesFreeformTool(t)) return toResponsesCustomTool(t);
+    return {
+        type: 'function',
+        name: t.name,
+        description: t.description,
+        parameters: t.inputSchema,
+    };
 }
 
 export function buildRequestBody(messages, model, tools, sendOpts) {
@@ -726,11 +572,16 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
         providerState: opts.providerState,
         model,
     });
-    // Match the body shape pi-mono and the official Codex CLI ship so the
+    // Match the body shape pi-mono and the official OpenAI CLI ship so the
     // server-side auto-cache routes correctly. text.verbosity / include /
     // tool_choice / parallel_tool_calls are all inert without side effects
-    // for most callers but their presence affects how Codex classifies the
+    // for most callers but their presence affects how the OAuth backend classifies the
     // request (and therefore whether the prompt cache is consulted).
+    const include = ['reasoning.encrypted_content'];
+    for (const item of Array.isArray(opts.nativeInclude) ? opts.nativeInclude : []) {
+        const value = String(item || '').trim();
+        if (value && !include.includes(value)) include.push(value);
+    }
     const body = {
         model,
         instructions,
@@ -739,7 +590,7 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
         stream: true,
         reasoning: { effort: opts.effort || 'medium' },
         text: { verbosity: 'medium' },
-        include: ['reasoning.encrypted_content'],
+        include,
         tool_choice: opts.toolChoice || 'auto',
         parallel_tool_calls: true,
     };
@@ -750,22 +601,23 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
         body.max_output_tokens = Math.floor(maxOutputTokens);
     }
     if (opts.fast === true) {
-        // 'priority' is the only fast-class value the Codex OAuth backend
+        // 'priority' is the only fast-class value the OpenAI OAuth backend
         // accepts on the wire: 'fast' is hard-rejected ("Unsupported
-        // service_tier: fast", probed 2026-06-11). Match official Codex:
+        // service_tier: fast", probed 2026-06-11). Match official CLI behavior:
         // only send the request value when the model catalog advertises it.
         if (codexModelSupportsServiceTier(model, 'priority')) {
             body.service_tier = 'priority';
         }
     }
-    // Add tools
-    if (tools?.length) {
-        body.tools = tools.map(t => ({
-            type: 'function',
-            name: t.name,
-            description: t.description,
-            parameters: t.inputSchema,
-        }));
+    // Add tools. `nativeTools` are server-hosted Responses tools (for
+    // example web_search) and must be passed through without wrapping them as
+    // function tools.
+    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 promptCacheProvider = opts.promptCacheProvider || 'openai-oauth';
     const promptCacheLane = opts.promptCacheLane || resolveProviderPromptCacheLane(promptCacheProvider, opts);
@@ -782,21 +634,9 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
         cacheLaneShards: promptCacheLane.shards,
     });
     // NOTE: prompt_cache_retention is a public OpenAI Responses API parameter,
-    // but the Codex OAuth endpoint still rejects it ("Unsupported parameter:
+    // but the openai-oauth endpoint still rejects it ("Unsupported parameter:
     // prompt_cache_retention", re-probed 2026-06-22). Leave retention on the
-    // Codex server default; public OpenAI direct injects 24h separately.
-    return body;
-}
-
-function buildRemoteCompactionRequestBody(messages, model, tools, sendOpts) {
-    const body = buildRequestBody(messages, model, tools, {
-        ...(sendOpts || {}),
-        expectCompaction: true,
-    });
-    body.input = [
-        ...(Array.isArray(body.input) ? body.input : []),
-        { type: 'compaction_trigger' },
-    ];
+    // openai-oauth server default; public OpenAI direct injects 24h separately.
     return body;
 }
 
@@ -806,12 +646,29 @@ function _envFlag(name, fallback = true) {
     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.
+// Native convergence (openai-oauth / anthropic-oauth / opencode): 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(value || '{}');
+        const parsed = JSON.parse(text);
         return parsed && typeof parsed === 'object' ? parsed : {};
-    } catch {
-        return {};
+    } catch (err) {
+        return makeInvalidToolArgsMarker(text, err instanceof Error ? err.message : String(err));
     }
 }
 
@@ -892,6 +749,7 @@ function _shouldUseOpenAIHttpFallback(err, externalSignal) {
     // chunk to the client, the HTTP fallback would re-run the request and
     // concatenate a second attempt onto rendered output. Never fall back.
     if (err?.liveTextEmitted === true) return false;
+    if (err?.emittedToolCall === true || err?.unsafeToRetry === true) return false;
     const status = Number(err?.httpStatus || err?.status || 0);
     if (status === 401 || status === 403 || status === 404 || status === 429) return false;
     if (status >= 500 && status < 600) return true;
@@ -900,7 +758,13 @@ function _shouldUseOpenAIHttpFallback(err, externalSignal) {
         return true;
     }
     const classifier = String(err?.retryClassifier || err?.midstreamClassifier || '');
-    if (['timeout', 'reset', 'dns', 'refused', 'network', 'acquire_timeout', 'http_5xx', 'first_byte_timeout', 'first_meaningful_timeout'].includes(classifier)) {
+    if ([
+        'timeout', 'reset', 'dns', 'refused', 'network', 'acquire_timeout', 'http_5xx',
+        'first_byte_timeout', 'first_meaningful_timeout',
+        'ws_1006', 'ws_1011', 'ws_1012', 'ws_1000', 'ws_4000', 'agent_stall', 'stream_stalled',
+        'response_failed_disconnected', 'response_failed_network', 'response_failed_auth_expired',
+        'ws_send_failed',
+    ].includes(classifier)) {
         return true;
     }
     if (/^http_5\d\d$/.test(classifier)) return true;
@@ -960,7 +824,7 @@ export async function sendViaHttpSse({
         headerTimeout.cleanup();
     }
 
-    traceBridgeFetch({
+    traceAgentFetch({
         sessionId: poolKey,
         headersMs: Date.now() - fetchStartedAt,
         httpStatus: response.status,
@@ -1019,7 +883,6 @@ export async function sendViaHttpSse({
     const toolCalls = [];
     const pendingCalls = new Map();
     const reasoningItems = [];
-    const compactionItems = [];
     const citations = [];
     const citationKeys = new Set();
     const webSearchCalls = [];
@@ -1067,10 +930,34 @@ export async function sendViaHttpSse({
             });
         }
     };
-    const pushCompactionItem = (item) => {
-        if (!item || !['compaction', 'compaction_summary', 'context_compaction'].includes(item.type)) return;
-        if (!item.encrypted_content) return;
-        compactionItems.push(item);
+    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;
@@ -1123,11 +1010,13 @@ export async function sendViaHttpSse({
                 meaningful();
                 break;
             }
+            case 'response.custom_tool_call_input.delta':
+                meaningful();
+                break;
             case 'response.output_item.done': {
                 const item = event.item || {};
                 pushReasoningItem(item);
                 pushWebSearchCall(item);
-                pushCompactionItem(item);
                 if (item.type === 'function_call') {
                     const tc = toolCalls.find(t => t._pendingItemId === (item.id || ''));
                     if (tc) {
@@ -1138,6 +1027,11 @@ export async function sendViaHttpSse({
                             emitToolCall(tc);
                         }
                     }
+                } else if (item.type === 'tool_search_call') {
+                    pushToolSearchCall(item);
+                } else if (item.type === 'custom_tool_call') {
+                    pushCustomToolCall(item);
+                    meaningful();
                 }
                 break;
             }
@@ -1165,8 +1059,11 @@ export async function sendViaHttpSse({
                         pushReasoningItem(item);
                     } else if (item.type === 'web_search_call') {
                         pushWebSearchCall(item);
-                    } else if (['compaction', 'compaction_summary', 'context_compaction'].includes(item.type)) {
-                        pushCompactionItem(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 —
@@ -1282,15 +1179,12 @@ export async function sendViaHttpSse({
     if (unresolved) {
         throw new Error(`OpenAI OAuth HTTP fallback function_call salvage failed: missing call_id/name for item_id=${unresolved._pendingItemId || '?'}`);
     }
-    if (opts?.expectCompaction === true && compactionItems.length !== 1) {
-        throw new Error(`OpenAI OAuth HTTP fallback remote compaction expected exactly one compaction output item, got ${compactionItems.length}`);
-    }
     if (!completed && !content && !toolCalls.length) {
         throw new Error('OpenAI OAuth HTTP fallback ended before response.completed');
     }
 
     const liveModel = model || useModel;
-    traceBridgeSse({
+    traceAgentSse({
         sessionId: poolKey,
         sseParseMs: Date.now() - sseStartedAt,
         ttftMs,
@@ -1299,7 +1193,7 @@ export async function sendViaHttpSse({
         transport: 'sse',
     });
     if (usage) {
-        traceBridgeUsage({
+        traceAgentUsage({
             sessionId: poolKey,
             iteration,
             inputTokens: usage.inputTokens || 0,
@@ -1318,8 +1212,6 @@ export async function sendViaHttpSse({
         content,
         model: liveModel,
         reasoningItems: reasoningItems.length ? reasoningItems : undefined,
-        compactionItem: compactionItems.length === 1 ? compactionItems[0] : undefined,
-        compactionItems: compactionItems.length ? compactionItems : undefined,
         toolCalls: toolCalls.length ? toolCalls.map(({ _pendingItemId, ...t }) => t) : undefined,
         citations: citations.length ? citations : undefined,
         webSearchCalls: webSearchCalls.length ? webSearchCalls : undefined,
@@ -1339,137 +1231,29 @@ export class OpenAIOAuthProvider {
     tokens = null;
     _refreshFallbackUntil = 0;
     _forceHttpFallback = false;
+    _forceHttpFallbackUntil = 0;
     config;
     constructor(config) {
         this.config = config || {};
         this.tokens = loadTokens();
-        // Warm a kept-alive socket to the Codex responses API so the first
+        // Warm a kept-alive socket to the OAuth responses API so the first
         // request skips the cold TLS handshake. Best-effort; never throws.
         preconnect('https://chatgpt.com');
     }
     getCachedModelInfo(model) {
         return _findCachedCodexModel(model);
     }
-    async remoteCompactMessages(messages, model, tools, sendOpts = {}) {
-        const opts = {
-            ...sendOpts,
-            expectCompaction: true,
-            nativeCompact: true,
-        };
-        const useModel = model || await ensureLatestCodexModel(this);
-        const promptCacheLane = resolveProviderPromptCacheLane('openai-oauth', opts, this.config);
-        const bodyOpts = {
-            ...opts,
-            promptCacheLane,
-        };
-        const body = buildRemoteCompactionRequestBody(messages, useModel, tools, bodyOpts);
-        let auth = await this.ensureAuth();
-        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;
-        const onStageChange = typeof opts.onStageChange === 'function' ? opts.onStageChange : null;
-        const sendWs = typeof opts._sendViaWebSocketFn === 'function' ? opts._sendViaWebSocketFn : sendViaWebSocket;
-        const sendHttp = typeof opts._sendViaHttpSseFn === 'function' ? opts._sendViaHttpSseFn : sendViaHttpSse;
-        const dispatchHttp = async (reason, originalErr = null) => {
-            appendBridgeTrace({
-                sessionId: poolKey,
-                iteration,
-                kind: 'transport_fallback',
-                provider: 'openai-oauth',
-                model: useModel,
-                transport: 'http',
-                payload: {
-                    from: 'websocket',
-                    to: 'http',
-                    reason,
-                    remote_compact: true,
-                    error_code: originalErr?.code || null,
-                    error_http_status: Number(originalErr?.httpStatus || 0) || null,
-                },
-            });
-            return sendHttp({
-                auth,
-                body,
-                opts,
-                onStreamDelta: null,
-                onToolCall: null,
-                onStageChange,
-                externalSignal: opts.signal || null,
-                poolKey,
-                cacheKey,
-                iteration,
-                useModel,
-                fetchFn: opts._fetchFn,
-            });
-        };
-        const dispatchWs = (forceFresh = false) => sendWs({
-            auth,
-            body,
-            sendOpts: opts,
-            onStreamDelta: null,
-            onToolCall: null,
-            onStageChange,
-            externalSignal: opts.signal || null,
-            poolKey,
-            cacheKey,
-            iteration,
-            useModel,
-            displayModel: _displayCodexModel,
-            forceFresh,
-            includeResponseId: true,
-        });
-
-        let result;
-        if (opts.forceHttpFallback === true
-            || this._forceHttpFallback
-            || _envFlag('MIXDOG_OPENAI_OAUTH_FORCE_HTTP_FALLBACK', false)) {
-            result = await dispatchHttp('forced');
-        } else {
-            try {
-                result = await dispatchWs(false);
-            } catch (err) {
-                const status = err?.httpStatus;
-                if (status === 401 || status === 403) {
-                    this._refreshFallbackUntil = 0;
-                    auth = await this.ensureAuth({ forceRefresh: true, reason: String(status) });
-                    result = await dispatchWs(true);
-                } else if (_shouldUseOpenAIHttpFallback(err, opts.signal || null)) {
-                    result = await dispatchHttp(err?.retryClassifier || err?.midstreamClassifier || err?.code || err?.message || 'ws_failed', err);
-                } else {
-                    throw err;
-                }
-            }
-        }
-
-        if (!result?.compactionItem) {
-            throw new Error('OpenAI OAuth remote compact completed without compaction item');
-        }
-        const liveModel = result.model || useModel;
-        if (liveModel && !_codexCatalogHas(liveModel)) void this._refreshModelCache();
-        const nativePrefix = _buildOpenAICodexNativeCompactPrefix(messages, result.compactionItem);
-        return {
-            model: liveModel,
-            usage: result.usage,
-            responseId: result.responseId || null,
-            providerState: _withOpenAICodexRemoteCompactState(opts.providerState, {
-                model: useModel,
-                nativePrefix,
-                responseId: result.responseId || null,
-            }),
-        };
-    }
     async ensureAuth({ forceRefresh = false, reason = 'preemptive' } = {}) {
         if (!this.tokens) this.tokens = loadTokens();
         if (!this.tokens)
-            throw new Error('OpenAI OAuth not authenticated. Run codex login first.');
-        // Pick up disk-rotated tokens (codex login, host refresh) the moment
-        // the auth file is rewritten — without this, a fresh login is ignored
-        // until the in-memory token hits its expiry skew.
+            throw new Error('OpenAI OAuth not authenticated. Open /providers in mixdog to sign in.');
+        // Pick up Mixdog-owned token updates the moment the auth file is
+        // rewritten — without this, a fresh login is ignored until the in-memory
+        // token hits its expiry skew.
         const diskMtime = _tokensMaxMtime();
-        // Watermark guards termination: if the newest file on disk isn't loadable
-        // (e.g. a logged-out host auth.json beside a valid own store), loadTokens
-        // falls back to the older valid store; record the scanned mtime so this
-        // check can't re-fire on every ensureAuth().
+        // Watermark guards termination: if the rewritten file is temporarily
+        // unreadable/partial, record the scanned mtime so this check can't
+        // re-fire on every ensureAuth().
         if (diskMtime > 0 && diskMtime > (this._lastDiskScan || 0) && diskMtime > (this.tokens._mtimeMs || 0)) {
             const fresh = loadTokens();
             if (fresh?.access_token) {
@@ -1526,30 +1310,16 @@ export class OpenAIOAuthProvider {
                     this._refreshFallbackUntil = Date.now() + TOKEN_REFRESH_SKEW_MS;
                     return latest;
                 }
-                throw new Error('OpenAI OAuth refresh token not available. Run codex login to re-authenticate.');
+                throw new Error('OpenAI OAuth refresh token not available. Open /providers in mixdog to sign in again.');
             }
 
             try {
                 const _refreshT0 = Date.now();
                 const _expiringInMs = (latest?.expires_at ?? 0) - Date.now();
-                if (process.env.MIXDOG_DEBUG_BRIDGE) { process.stderr.write(`[bridge-trace] auth-refresh-needed expiringInMs=${_expiringInMs}\n`); }
+                if (process.env.MIXDOG_DEBUG_AGENT) { process.stderr.write(`[agent-trace] auth-refresh-needed expiringInMs=${_expiringInMs}\n`); }
                 process.stderr.write(`[openai-oauth] Token ${reason}, refreshing...\n`);
-                let refreshed;
-                try {
-                    refreshed = await refreshTokens(latest.refresh_token);
-                } catch (refreshErr) {
-                    // invalid_grant: the Codex CLI rotated this single-use refresh
-                    // token between our disk read and this refresh. Re-read both
-                    // stores and retry ONCE with the freshest different token.
-                    if (!refreshErr?.isInvalidGrant) throw refreshErr;
-                    process.stderr.write('[openai-oauth] invalid_grant — re-reading disk, retrying refresh\n');
-                    const candidates = [_loadOwnCodexTokens(), _loadCodexCliTokens()].filter(Boolean)
-                        .sort((a, b) => (b._mtimeMs || 0) - (a._mtimeMs || 0));
-                    const freshTok = candidates.find(c => c.refresh_token && c.refresh_token !== latest.refresh_token);
-                    if (!freshTok) throw refreshErr;
-                    refreshed = await refreshTokens(freshTok.refresh_token);
-                }
-                if (process.env.MIXDOG_DEBUG_BRIDGE) { process.stderr.write(`[bridge-trace] auth-refresh-done elapsed=${Date.now() - _refreshT0}ms ok=${!!refreshed}\n`); }
+                const refreshed = await refreshTokens(latest.refresh_token);
+                if (process.env.MIXDOG_DEBUG_AGENT) { process.stderr.write(`[agent-trace] auth-refresh-done elapsed=${Date.now() - _refreshT0}ms ok=${!!refreshed}\n`); }
                 if (!refreshed) throw new Error('refresh returned null');
                 process.stderr.write(`[openai-oauth] Token refreshed, expires in ${Math.round(((refreshed.expires_at || Date.now()) - Date.now()) / 1000)}s\n`);
                 return refreshed;
@@ -1561,7 +1331,7 @@ export class OpenAIOAuthProvider {
                     process.stderr.write(`[openai-oauth] Refresh failed (${msg}); using still-valid current token\n`);
                     return latest;
                 }
-                throw new Error(`OpenAI OAuth token refresh failed (${msg}). Run codex login to re-authenticate.`);
+                throw new Error(`OpenAI OAuth token refresh failed (${msg}). Re-authenticate via provider login.`);
             }
         })().finally(() => { _oauthRefreshInFlight = null; });
 
@@ -1569,6 +1339,10 @@ export class OpenAIOAuthProvider {
         return this.tokens;
     }
     async send(messages, model, tools, sendOpts) {
+        // Re-warm a kept-alive socket before the turn (TTL-gated no-op while
+        // hot). After an idle gap it re-opens one in parallel with auth/body
+        // build so the HTTP/SSE path skips the cold TLS handshake.
+        preconnect('https://chatgpt.com');
         const opts = sendOpts || {};
         const onStageChange = typeof opts.onStageChange === 'function' ? opts.onStageChange : null;
         const onStreamDelta = typeof opts.onStreamDelta === 'function' ? opts.onStreamDelta : null;
@@ -1577,7 +1351,7 @@ export class OpenAIOAuthProvider {
         const externalSignal = opts.signal || null;
         const _sendSessionId = opts.sessionId || '(none)';
         const _sendRole = opts.role || '(none)';
-        if (process.env.MIXDOG_DEBUG_BRIDGE) { process.stderr.write(`[bridge-trace] auth-start sessionHash=${createHash('sha256').update(String(_sendSessionId)).digest('hex').slice(0, 8)} role=${_sendRole} expiringInMs=${this.tokens?.expires_at ? this.tokens.expires_at - Date.now() : 'unknown'}\n`); }
+        if (process.env.MIXDOG_DEBUG_AGENT) { process.stderr.write(`[agent-trace] auth-start sessionHash=${createHash('sha256').update(String(_sendSessionId)).digest('hex').slice(0, 8)} role=${_sendRole} expiringInMs=${this.tokens?.expires_at ? this.tokens.expires_at - Date.now() : 'unknown'}\n`); }
         // Build request body in parallel with auth resolution. ensureAuth is
         // a no-op fast-path on cached tokens, but a refresh round-trip can
         // take 300ms+; the body build (message serialisation) overlaps cleanly.
@@ -1597,11 +1371,10 @@ export class OpenAIOAuthProvider {
         const _authP = this.ensureAuth();
         let auth = await _authP;
         const body = await _bodyP;
-        const hasImageContent = messagesHaveImageContent(messages);
         // 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 Codex's "No tool call found for function call
+        // 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
@@ -1625,8 +1398,21 @@ export class OpenAIOAuthProvider {
             }
             return result;
         };
-        const dispatchHttp = async (reason, originalErr = null) => {
-            appendBridgeTrace({
+        const httpFallbackActive = () => {
+            if (this._forceHttpFallbackUntil > Date.now()) return true;
+            if (this._forceHttpFallback || this._forceHttpFallbackUntil) {
+                this._forceHttpFallback = false;
+                this._forceHttpFallbackUntil = 0;
+            }
+            return false;
+        };
+        const markStickyHttpFallback = () => {
+            const ttlMs = _envPositiveInt('MIXDOG_OPENAI_OAUTH_HTTP_FALLBACK_STICKY_MS', 60_000);
+            this._forceHttpFallback = true;
+            this._forceHttpFallbackUntil = Date.now() + ttlMs;
+        };
+        const dispatchHttp = async (reason, originalErr = null, { sticky = false } = {}) => {
+            appendAgentTrace({
                 sessionId: poolKey,
                 iteration,
                 kind: 'transport_fallback',
@@ -1642,7 +1428,13 @@ export class OpenAIOAuthProvider {
                     error_classifier: originalErr?.retryClassifier || originalErr?.midstreamClassifier || null,
                 },
             });
-            process.stderr.write(`[openai-oauth] WebSocket unhealthy (${reason}); falling back to HTTP/SSE\n`);
+            if (reason === 'forced') {
+                if (_envFlag('MIXDOG_OPENAI_OAUTH_LOG_FORCED_FALLBACK', false)) {
+                    process.stderr.write('[openai-oauth] WebSocket bypassed (forced); using HTTP/SSE\n');
+                }
+            } else {
+                process.stderr.write(`[openai-oauth] WebSocket unhealthy (${reason}); falling back to HTTP/SSE\n`);
+            }
             const result = await sendHttp({
                 auth,
                 body,
@@ -1658,9 +1450,9 @@ export class OpenAIOAuthProvider {
                 useModel,
                 fetchFn: opts._fetchFn,
             });
-            this._forceHttpFallback = true;
-            if (process.env.MIXDOG_DEBUG_BRIDGE) {
-                process.stderr.write(`[bridge-trace] provider-send-end elapsed=${Date.now() - _t1}ms result=ok transport=http-fallback\n`);
+            if (sticky) markStickyHttpFallback();
+            if (process.env.MIXDOG_DEBUG_AGENT) {
+                process.stderr.write(`[agent-trace] provider-send-end elapsed=${Date.now() - _t1}ms result=ok transport=http-fallback\n`);
             }
             return recordLiveModel(result);
         };
@@ -1681,18 +1473,17 @@ export class OpenAIOAuthProvider {
             forceFresh,
         });
         if (opts.forceHttpFallback === true
-            || this._forceHttpFallback
-            || hasImageContent
+            || httpFallbackActive()
             || _envFlag('MIXDOG_OPENAI_OAUTH_FORCE_HTTP_FALLBACK', false)) {
-            return dispatchHttp(hasImageContent ? 'image_content' : 'forced');
+            return dispatchHttp('forced');
         }
 
         // Prefer WebSocket for hot cache/delta transport; fall back to HTTP/SSE
         // after retry-exhausted handshake/acquire/no-first-event failures.
         try {
-            if (process.env.MIXDOG_DEBUG_BRIDGE) { process.stderr.write(`[bridge-trace] provider-send-start model=${useModel} role=${_sendRole} sessionHash=${createHash('sha256').update(String(_sendSessionId)).digest('hex').slice(0, 8)} iteration=${iteration ?? '(none)'}\n`); }
+            if (process.env.MIXDOG_DEBUG_AGENT) { process.stderr.write(`[agent-trace] provider-send-start model=${useModel} role=${_sendRole} 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_BRIDGE) { process.stderr.write(`[bridge-trace] provider-send-end elapsed=${Date.now() - _t1}ms result=ok\n`); }
+            if (process.env.MIXDOG_DEBUG_AGENT) { process.stderr.write(`[agent-trace] provider-send-end elapsed=${Date.now() - _t1}ms result=ok\n`); }
             return recordLiveModel(result);
         } catch (err) {
             const status = err?.httpStatus;
@@ -1705,17 +1496,21 @@ export class OpenAIOAuthProvider {
             const liveTextEmitted = err?.liveTextEmitted === true || err?.unsafeToRetry === true;
             if ((status === 401 || status === 403) && !liveTextEmitted) {
                 process.stderr.write(`[openai-oauth-ws] ${status} — forcing refresh and retrying once over WS\n`);
-                if (process.env.MIXDOG_DEBUG_BRIDGE) { process.stderr.write(`[bridge-trace] provider-${status}-retry attempt=1\n`); }
+                if (process.env.MIXDOG_DEBUG_AGENT) { process.stderr.write(`[agent-trace] provider-${status}-retry attempt=1\n`); }
                 this._refreshFallbackUntil = 0;
                 auth = await this.ensureAuth({ forceRefresh: true, reason: String(status) });
                 try {
                     const result = await dispatchWs(true);
-                    if (process.env.MIXDOG_DEBUG_BRIDGE) { process.stderr.write(`[bridge-trace] provider-send-end elapsed=${Date.now() - _t1}ms result=ok\n`); }
+                    if (process.env.MIXDOG_DEBUG_AGENT) { process.stderr.write(`[agent-trace] provider-send-end elapsed=${Date.now() - _t1}ms result=ok\n`); }
                     return recordLiveModel(result);
                 } catch (retryErr) {
                     if (_shouldUseOpenAIHttpFallback(retryErr, externalSignal)) {
                         try {
-                            return await dispatchHttp(retryErr?.retryClassifier || retryErr?.code || retryErr?.message || 'ws_auth_retry_failed', retryErr);
+                            return await dispatchHttp(
+                                retryErr?.retryClassifier || retryErr?.code || retryErr?.message || 'ws_auth_retry_failed',
+                                retryErr,
+                                { sticky: true },
+                            );
                         } catch (fallbackErr) {
                             try { retryErr.fallbackError = fallbackErr; } catch {}
                             throw retryErr;
@@ -1738,7 +1533,11 @@ export class OpenAIOAuthProvider {
             }
             if (_shouldUseOpenAIHttpFallback(err, externalSignal)) {
                 try {
-                    return await dispatchHttp(err?.retryClassifier || err?.midstreamClassifier || err?.code || err?.message || 'ws_failed', err);
+                    return await dispatchHttp(
+                        err?.retryClassifier || err?.midstreamClassifier || err?.code || err?.message || 'ws_failed',
+                        err,
+                        { sticky: true },
+                    );
                 } catch (fallbackErr) {
                     try { err.fallbackError = fallbackErr; } catch {}
                     throw err;
@@ -1748,7 +1547,7 @@ export class OpenAIOAuthProvider {
         }
     }
     async listModels() {
-        // Dynamic lookup via Codex /backend-api/codex/models. Cached 24h.
+        // Dynamic lookup via /backend-api/codex/models. Cached 24h.
         // Endpoint returns rich metadata (context_window, reasoning levels,
         // visibility) that is more detailed than /v1/models.
         const cached = await _loadCodexModelCache();
@@ -1772,7 +1571,7 @@ export class OpenAIOAuthProvider {
                 },
                 dispatcher: getLlmDispatcher(),
             });
-            if (!res.ok) throw new Error(`codex list_models ${res.status}`);
+            if (!res.ok) throw new Error(`openai-oauth list_models ${res.status}`);
             const data = await res.json();
             const items = Array.isArray(data?.models) ? data.models : [];
             const normalized = items.map(m => _normalizeCodexModel(m));
@@ -1785,7 +1584,7 @@ export class OpenAIOAuthProvider {
             _lastCodexListModelsError = err?.message || String(err);
             process.stderr.write(`[openai-oauth] listModels fetch failed (${_lastCodexListModelsError})\n`);
             // No fallback catalog — empty list signals the UI to show a
-            // "catalog unavailable, retry" state. Codex has no equivalent to
+            // "catalog unavailable, retry" state. openai-oauth has no equivalent to
             // Anthropic's family tokens so there's no meaningful minimal list.
             return [];
         }
@@ -1857,7 +1656,64 @@ function _scrubOAuthLoginBody(text) {
         .replace(/[A-Za-z0-9_-]{32,}\.[A-Za-z0-9._-]+/g, '[REDACTED]');
 }
 
-export async function loginOAuth() {
+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);
@@ -1872,18 +1728,20 @@ export async function loginOAuth() {
     url.searchParams.set('state', state);
     url.searchParams.set('originator', CODEX_OAUTH_ORIGINATOR);
 
-    return new Promise((resolve, reject) => {
+    let server = null;
+    let timeout = null;
+    let finish = null;
+    const waitForCallback = new Promise((resolve, reject) => {
         let settled = false;
-        let timeout = null;
-        const settle = (value, error = null) => {
+        finish = (value, error = null) => {
             if (settled) return;
             settled = true;
             if (timeout) clearTimeout(timeout);
-            try { server.close(); } catch { /* already closed */ }
+            try { server?.close(); } catch { /* already closed */ }
             if (error) reject(error);
             else resolve(value);
         };
-        const server = createServer(async (req, res) => {
+        server = createServer(async (req, res) => {
             const u = new URL(req.url || '/', `http://${CALLBACK_HOST}:${CALLBACK_PORT}`);
             if (u.pathname !== CALLBACK_PATH) {
                 res.writeHead(404);
@@ -1894,53 +1752,21 @@ export async function loginOAuth() {
             if (!code || u.searchParams.get('state') !== state) {
                 res.writeHead(400);
                 res.end('Invalid');
-                settle(null);
+                finish(null);
                 return;
             }
             res.writeHead(200, { 'Content-Type': 'text/html' });
-            res.end('<html><body><h2>Codex login successful! You can close this tab.</h2></body></html>');
+            res.end('<html><body><h2>OpenAI OAuth login successful! You can close this tab.</h2></body></html>');
             try {
-                const tokenRes = await fetch(TOKEN_URL, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-                    body: new URLSearchParams({
-                        grant_type: 'authorization_code',
-                        code,
-                        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(() => '');
-                    settle(null, new Error(`[openai-oauth] token exchange ${tokenRes.status}: ${_scrubOAuthLoginBody(text).slice(0, 500)}`));
-                    return;
-                }
-                const json = await tokenRes.json();
-                if (!json.access_token || !json.refresh_token) {
-                    settle(null, new Error('[openai-oauth] token exchange response missing access_token or refresh_token'));
-                    return;
-                }
-                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);
-                settle(tokens);
+                const tokens = await exchangeAuthorizationCode({ pkce, code });
+                finish(tokens);
             } catch (err) {
-                settle(null, err instanceof Error ? err : new Error(String(err)));
+                finish(null, err instanceof Error ? err : new Error(String(err)));
             }
         });
-        timeout = setTimeout(() => settle(null), LOGIN_TIMEOUT_MS);
+        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 (Codex):\n${url.toString()}\n\n`);
+            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());
@@ -1948,6 +1774,27 @@ export async function loginOAuth() {
                 process.stderr.write(`[openai-oauth] browser open failed: ${String(err?.message || err).slice(0, 200)}\n`);
             }
         });
-        server.on('error', (err) => settle(null, new Error(`[openai-oauth] callback server failed on ${CALLBACK_HOST}:${CALLBACK_PORT}: ${err?.message || err}`)));
+        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;
 }