@steipete/oracle 0.15.0 → 0.15.2

package/dist/src/browser/reattach.js

@@ -5,8 +5,9 @@ import { mkdtemp, mkdir, rm } from "node:fs/promises";
 import { waitForAssistantResponse, captureAssistantMarkdown, navigateToChatGPT, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, } from "./pageActions.js";
 import { launchChrome, connectToChrome, hideChromeWindow, connectToRemoteChromeTarget, listRemoteChromeTargets, } from "./chromeLifecycle.js";
 import { resolveBrowserConfig } from "./config.js";
-import { syncCookies } from "./cookies.js";
-import { CHATGPT_URL, CONVERSATION_TURN_SELECTOR } from "./constants.js";
+import { clearStaleChatGptConversationCookies, syncCookies } from "./cookies.js";
+import { CHATGPT_URL } from "./constants.js";
+import { buildConversationTurnListExpression } from "./conversationTurns.js";
 import { cleanupStaleProfileState } from "./profileState.js";
 import { readDevToolsActivePortInfo } from "./detect.js";
 import { pickTarget, extractConversationIdFromUrl, buildConversationUrl, withTimeout, openConversationFromSidebar, openConversationFromSidebarWithRetry, waitForLocationChange, readConversationTurnIndex, buildPromptEchoMatcher, recoverPromptEcho, alignPromptEchoMarkdown, } from "./reattachHelpers.js";
@@ -14,6 +15,12 @@ import { waitForDeepResearchCompletion } from "./actions/deepResearch.js";
 export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
     const recoverSession = deps.recoverSession ??
         (async (runtimeMeta, configMeta) => resumeBrowserSessionViaNewChrome(runtimeMeta, configMeta, logger, deps));
+    let closeAttachedConnection = null;
+    const closeAttached = async () => {
+        const close = closeAttachedConnection;
+        closeAttachedConnection = null;
+        await close?.().catch(() => undefined);
+    };
     if (!runtime.chromePort && !runtime.chromeBrowserWSEndpoint) {
         logger("No running Chrome detected; reopening browser to locate the session.");
         return recoverSession(runtime, config);
@@ -37,8 +44,8 @@ export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
                 targetId: target?.targetId ?? target?.id,
                 closeTargetOnDispose: false,
             })
-            : {
-                client: (await (deps.connect ?? ((options) => CDP(options)))(browserWSEndpoint
+            : await (async () => {
+                const client = (await (deps.connect ?? ((options) => CDP(options)))(browserWSEndpoint
                     ? {
                         target: browserWSEndpoint,
                         local: true,
@@ -48,9 +55,10 @@ export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
                         host,
                         port,
                         target: target?.targetId ?? target?.id,
-                    })),
-                close: async () => undefined,
-            };
+                    }));
+                return { client, close: () => client.close() };
+            })();
+        closeAttachedConnection = () => connection.close();
         const client = connection.client;
         const { Runtime, DOM, Page } = client;
         if (Runtime?.enable) {
@@ -97,7 +105,7 @@ export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
             const researchResult = await withTimeout(waitForDeepResearch(Runtime, logger, timeoutMs, minTurnIndex ?? undefined, Page, client, {
                 requireScopedTargetOwner: true,
             }), timeoutMs + 5_000, "Reattach Deep Research response timed out");
-            await connection.close().catch(() => undefined);
+            await closeAttached();
             return {
                 answerText: researchResult.text,
                 answerMarkdown: researchResult.text,
@@ -108,10 +116,11 @@ export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
         const recovered = await recoverPromptEcho(Runtime, answer, promptEcho, logger, minTurnIndex, timeoutMs);
         const markdown = (await withTimeout(captureMarkdown(Runtime, recovered.meta, logger), 15_000, "Reattach markdown capture timed out")) ?? recovered.text;
         const aligned = alignPromptEchoMarkdown(recovered.text, markdown, promptEcho, logger);
-        await connection.close().catch(() => undefined);
+        await closeAttached();
         return { answerText: aligned.answerText, answerMarkdown: aligned.answerMarkdown };
     }
     catch (error) {
+        await closeAttached();
         const message = error instanceof Error ? error.message : String(error);
         logger(`Existing Chrome reattach failed (${message}); reopening browser to locate the session.`);
         return recoverSession(runtime, config);
@@ -163,7 +172,7 @@ async function resumeBrowserSessionViaNewChrome(runtime, config, logger, deps) {
     const chrome = await launchChrome(resolved, userDataDir, logger);
     const chromeHost = chrome.host ?? "127.0.0.1";
     const client = await connectToChrome(chrome.port, logger, chromeHost);
-    const { Network, Page, Runtime, DOM } = client;
+    const { Network, Page, Runtime, DOM, Target } = client;
     if (Runtime?.enable) {
         await Runtime.enable();
     }
@@ -183,6 +192,13 @@ async function resumeBrowserSessionViaNewChrome(runtime, config, logger, deps) {
             waitMs: resolved.cookieSyncWaitMs ?? 0,
         });
     }
+    await clearStaleChatGptConversationCookies(Network, Target, logger, {
+        preserveConversationIds: [
+            runtime.conversationId,
+            extractConversationIdFromUrl(runtime.tabUrl ?? ""),
+            extractConversationIdFromUrl(resolved.url),
+        ],
+    });
     await navigateToChatGPT(Page, Runtime, CHATGPT_URL, logger);
     await ensureNotBlocked(Runtime, resolved.headless, logger);
     await ensureLoggedIn(Runtime, logger, { appliedCookies });
@@ -268,7 +284,7 @@ async function readPromptPreviewTurnIndex(Runtime, promptPreview) {
       const needle = ${JSON.stringify(preview.toLowerCase().replace(/\s+/g, " ").slice(0, 120))};
       if (!needle) return null;
       const normalize = (value) => String(value || '').toLowerCase().replace(/\\s+/g, ' ').trim();
-      const turns = Array.from(document.querySelectorAll(${JSON.stringify(CONVERSATION_TURN_SELECTOR)}));
+      const turns = ${buildConversationTurnListExpression()};
       let matched = null;
       for (const [index, node] of turns.entries()) {
         const attr = (node.getAttribute('data-message-author-role') || node.getAttribute('data-turn') || node.dataset?.turn || '').toLowerCase();

package/dist/src/browser/reattachHelpers.js

@@ -1,15 +1,25 @@
 import { CONVERSATION_TURN_SELECTOR } from "./constants.js";
+import { buildConversationTurnCountExpression } from "./conversationTurns.js";
 import { delay } from "./utils.js";
 import { readAssistantSnapshot } from "./pageActions.js";
 export function pickTarget(targets, runtime) {
     if (!Array.isArray(targets) || targets.length === 0) {
         return undefined;
     }
-    if (runtime.chromeTargetId) {
-        const byId = targets.find((t) => (t.targetId ?? t.id) === runtime.chromeTargetId);
-        if (byId)
+    const conversationId = runtime.conversationId ?? extractConversationIdFromUrl(runtime.tabUrl ?? "");
+    const byId = runtime.chromeTargetId
+        ? targets.find((target) => (target.targetId ?? target.id) === runtime.chromeTargetId)
+        : undefined;
+    if (conversationId) {
+        if (byId && extractConversationIdFromUrl(byId.url ?? "") === conversationId) {
             return byId;
+        }
+        const byConversation = targets.find((target) => extractConversationIdFromUrl(target.url ?? "") === conversationId);
+        if (byConversation)
+            return byConversation;
     }
+    if (byId)
+        return byId;
     if (runtime.tabUrl) {
         const byUrl = targets.find((t) => t.url?.startsWith(runtime.tabUrl)) ||
             targets.find((t) => runtime.tabUrl.startsWith(t.url || ""));
@@ -253,10 +263,9 @@ export async function waitForLocationChange(Runtime, timeoutMs) {
     }
 }
 export async function readConversationTurnIndex(Runtime, logger) {
-    const selectorLiteral = JSON.stringify(CONVERSATION_TURN_SELECTOR);
     try {
         const { result } = await Runtime.evaluate({
-            expression: `document.querySelectorAll(${selectorLiteral}).length`,
+            expression: buildConversationTurnCountExpression(),
             returnByValue: true,
         });
         const raw = typeof result?.value === "number" ? result.value : Number(result?.value);

package/dist/src/browser/sessionRunner.js

@@ -127,11 +127,17 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
             generateImagePath: runOptions.generateImage,
             outputPath: runOptions.outputPath,
             followUpPrompts: runOptions.browserFollowUps,
-            runtimeHintCb: async (runtime) => {
-                await persistRuntimeHint({
+            runtimeHintCb: async (runtime, modelSelection) => {
+                const runtimeWithController = {
                     ...runtime,
                     controllerPid: runtime.controllerPid ?? process.pid,
-                });
+                };
+                if (modelSelection) {
+                    await persistRuntimeHint(runtimeWithController, modelSelection);
+                }
+                else {
+                    await persistRuntimeHint(runtimeWithController);
+                }
             },
         });
     }

package/dist/src/cli/bridge/client.js

@@ -21,7 +21,10 @@ export async function runBridgeClient(options) {
             const suffix = health.statusCode ? ` (HTTP ${health.statusCode})` : "";
             throw new Error(`Remote service health check failed: ${health.error ?? "unknown error"}${suffix}`);
         }
-        console.log(chalk.green(`Remote service OK (${remoteHost})${health.version ? ` — oracle ${health.version}` : ""}`));
+        const artifactTransfer = health.capabilities?.artifactTransfer
+            ? ` — artifacts bridge v${health.capabilities.artifactProtocolVersion}`
+            : " — artifact transfer unavailable; file downloads require manual copy";
+        console.log(chalk.green(`Remote service OK (${remoteHost})${health.version ? ` — oracle ${health.version}` : ""}${artifactTransfer}`));
     }
     const configFilePath = options.config?.trim() || defaultConfigPath();
     if (options.writeConfig !== false) {

package/dist/src/cli/bridge/doctor.js

@@ -60,6 +60,13 @@ export async function runBridgeDoctor(_options) {
             if (health.ok) {
                 const meta = health.version ? `oracle ${health.version}` : "ok";
                 lines.push(chalk.dim(`Auth (/health): ${chalk.green(meta)}`));
+                if (health.capabilities?.artifactTransfer) {
+                    lines.push(chalk.dim(`Artifact transfer: ${chalk.green(`bridge v${health.capabilities.artifactProtocolVersion}`)} (${formatBytes(health.capabilities.maxArtifactBytes)} max)`));
+                }
+                else {
+                    warn.push("Remote host does not advertise bridge artifact transfer; ChatGPT-generated files may need manual copy from the browser host.");
+                    lines.push(chalk.dim(`Artifact transfer: ${chalk.yellow("manual fallback")}`));
+                }
             }
             else {
                 const detail = health.error ?? "unknown error";
@@ -118,3 +125,15 @@ export async function runBridgeDoctor(_options) {
     console.log(lines.join("\n"));
     process.exitCode = fail.length ? 1 : 0;
 }
+function formatBytes(bytes) {
+    if (!Number.isFinite(bytes) || bytes <= 0)
+        return "unknown";
+    const units = ["B", "KB", "MB", "GB"];
+    let value = bytes;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit += 1;
+    }
+    return `${value.toFixed(value >= 10 || unit === 0 ? 0 : 1)} ${units[unit]}`;
+}

package/dist/src/cli/runOptions.js

@@ -2,6 +2,7 @@ import { DEFAULT_MODEL, MODEL_CONFIGS } from "../oracle.js";
 import { resolveEngine } from "./engine.js";
 import { normalizeModelOption, inferModelFromLabel, resolveApiModel, normalizeBaseUrl, } from "./options.js";
 import { resolveGeminiModelId } from "../oracle/gemini.js";
+import { resolveOverriddenApiModel } from "../oracle/modelResolver.js";
 import { PromptValidationError } from "../oracle/errors.js";
 import { normalizeChatGptModelForBrowser } from "./browserConfig.js";
 import { resolveConfiguredMaxFileSizeBytes } from "./fileSize.js";
@@ -62,7 +63,8 @@ export function resolveRunOptionsFromConfig({ prompt, files = [], model, models,
         // Silent coerce; multi-model still forces API.
     }
     const chosenModel = uniqueMultiModels[0] ?? resolvedModel;
-    const effectiveModelId = resolveEffectiveModelId(chosenModel);
+    const apiModelOverrides = fixedEngine === "api" ? userConfig?.modelOverrides : undefined;
+    const effectiveModelId = resolveEffectiveModelId(chosenModel, apiModelOverrides);
     const runOptions = {
         prompt: promptWithSuffix,
         model: chosenModel,
@@ -76,6 +78,7 @@ export function resolveRunOptionsFromConfig({ prompt, files = [], model, models,
         baseUrl,
         azure,
         effectiveModelId,
+        modelOverrides: apiModelOverrides,
     };
     return { runOptions, resolvedEngine: fixedEngine, engineCoercedToApi };
 }
@@ -90,7 +93,13 @@ function resolveAzureOptions(userConfig, env) {
         apiVersion: env.AZURE_OPENAI_API_VERSION ?? userConfig?.azure?.apiVersion,
     };
 }
-function resolveEffectiveModelId(model) {
+function resolveEffectiveModelId(model, modelOverrides) {
+    // A user-config override of a known model's apiModel must win, since this id
+    // becomes the on-wire request model id in run.ts (including for Gemini aliases).
+    const overridden = resolveOverriddenApiModel(model, modelOverrides);
+    if (overridden) {
+        return overridden;
+    }
     if (typeof model === "string" && model.startsWith("gemini")) {
         return resolveGeminiModelId(model);
     }

package/dist/src/cli/sessionDisplay.js

@@ -306,7 +306,12 @@ export async function attachSession(sessionId, options) {
             for (const artifact of metadata.artifacts) {
                 const label = artifact.label ?? artifact.kind;
                 const size = artifact.sizeBytes ? ` (${formatBytes(artifact.sizeBytes)})` : "";
-                console.log(`- ${chalk.cyan(label)} — ${artifact.path}${size}`);
+                const checksum = artifact.sha256 ? ` sha256=${artifact.sha256.slice(0, 12)}…` : "";
+                const validation = artifact.validation
+                    ? ` validation=${artifact.validation.ok ? "ok" : (artifact.validation.error ?? "failed")}`
+                    : "";
+                const transfer = artifact.transfer?.status ? ` transfer=${artifact.transfer.status}` : "";
+                console.log(`- ${chalk.cyan(label)} — ${artifact.path}${size}${checksum}${validation}${transfer}`);
             }
         }
         const responseSummary = formatResponseMetadata(metadata.response);

package/dist/src/cli/sessionRunner.js

@@ -33,6 +33,9 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
         write(chunk);
         return muteStdout ? true : process.stdout.write(chunk);
     };
+    let currentBrowser = browserConfig
+        ? { config: browserConfig }
+        : sessionMeta.browser;
     await sessionStore.updateSession(sessionMeta.id, {
         status: "running",
         startedAt: new Date().toISOString(),
@@ -54,11 +57,19 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             }
             const runnerDeps = {
                 ...browserDeps,
-                persistRuntimeHint: async (runtime) => {
+                persistRuntimeHint: async (runtime, modelSelection) => {
+                    const browser = {
+                        config: browserConfig,
+                        runtime,
+                        ...(modelSelection ? { modelSelection } : {}),
+                    };
                     await sessionStore.updateSession(sessionMeta.id, {
                         status: "running",
-                        browser: { config: browserConfig, runtime },
+                        browser,
                     });
+                    // Keep this attempt's copy fresh so error paths fall back to the
+                    // latest persisted browser evidence instead of stale session input.
+                    currentBrowser = browser;
                 },
             };
             const result = await runBrowserSessionExecution({
@@ -112,6 +123,7 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             const modelConfig = await resolveModelConfig(primaryModel, {
                 baseUrl: runOptions.baseUrl,
                 openRouterApiKey: process.env.OPENROUTER_API_KEY,
+                modelOverrides: runOptions.modelOverrides,
             });
             const files = await readFiles(runOptions.file ?? [], {
                 cwd,
@@ -403,7 +415,7 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
         if (connectionLost && mode === "browser" && browserCanReattach) {
             const runtime = userError.details
                 ?.runtime;
-            const recoverableRuntime = runtime ?? sessionMeta.browser?.runtime;
+            const recoverableRuntime = runtime ?? currentBrowser?.runtime;
             if (!hasRecoverableChatGptConversation(recoverableRuntime) &&
                 recoverableRuntime?.promptSubmitted !== true) {
                 log(dim("Chrome disconnected before a ChatGPT conversation was created; marking session error."));
@@ -425,6 +437,7 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                     errorMessage: message,
                     mode,
                     browser: {
+                        ...currentBrowser,
                         config: browserConfig,
                         runtime: recoverableRuntime,
                     },
@@ -449,8 +462,9 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 errorMessage: message,
                 mode,
                 browser: {
+                    ...currentBrowser,
                     config: browserConfig,
-                    runtime: runtime ?? sessionMeta.browser?.runtime,
+                    runtime: runtime ?? currentBrowser?.runtime,
                 },
                 response: { status: "running", incompleteReason: "chrome-disconnected" },
             });
@@ -479,8 +493,9 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 errorMessage: message,
                 mode,
                 browser: {
+                    ...currentBrowser,
                     config: browserConfig,
-                    runtime: runtime ?? sessionMeta.browser?.runtime,
+                    runtime: runtime ?? currentBrowser?.runtime,
                 },
                 response: { status: "incomplete", incompleteReason: "incomplete-capture" },
                 error: {
@@ -491,11 +506,12 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             });
             const autoReattachIntervalMs = browserConfig?.autoReattachIntervalMs ?? 0;
             if (autoReattachIntervalMs > 0) {
-                const autoRuntime = runtime ?? sessionMeta.browser?.runtime;
+                const autoRuntime = runtime ?? currentBrowser?.runtime;
                 const success = await autoReattachUntilComplete({
                     sessionMeta,
                     runtime: autoRuntime ?? undefined,
                     browserConfig,
+                    browserMetadata: currentBrowser,
                     runOptions,
                     modelForStatus,
                     notificationSettings,
@@ -505,7 +521,7 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                     return;
                 }
             }
-            logBrowserReattachGuidance(runtime ?? sessionMeta.browser?.runtime);
+            logBrowserReattachGuidance(runtime ?? currentBrowser?.runtime);
             return;
         }
         if (cloudflareChallenge && mode === "browser") {
@@ -537,7 +553,7 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             ? userError?.details?.runtime
             : undefined;
         if (!cloudflareChallenge && browserCanReattach) {
-            logBrowserReattachGuidance(browserRuntime ?? sessionMeta.browser?.runtime);
+            logBrowserReattachGuidance(browserRuntime ?? currentBrowser?.runtime);
         }
         await sessionStore.updateSession(sessionMeta.id, {
             status: "error",
@@ -546,8 +562,9 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             mode,
             browser: browserConfig
                 ? {
+                    ...currentBrowser,
                     config: browserConfig,
-                    runtime: browserRuntime ?? undefined,
+                    runtime: browserRuntime ?? currentBrowser?.runtime,
                 }
                 : undefined,
             response: responseMetadata,
@@ -816,7 +833,7 @@ async function writeAssistantOutput(targetPath, content, log) {
         log(dim(`write-output failed (${reason}); session completed anyway.`));
     }
 }
-async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig, runOptions, modelForStatus, notificationSettings, log, }) {
+async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig, browserMetadata, runOptions, modelForStatus, notificationSettings, log, }) {
     if (!runtime || !browserConfig) {
         log(dim("Auto-reattach disabled: missing runtime or browser config."));
         return false;
@@ -898,6 +915,7 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
                 },
                 errorMessage: undefined,
                 browser: {
+                    ...browserMetadata,
                     config: browserConfig,
                     runtime,
                 },

package/dist/src/config.js

@@ -125,6 +125,9 @@ function sanitizeProjectConfig(config) {
         sanitized.background = config.background;
     if (config.promptSuffix !== undefined)
         sanitized.promptSuffix = config.promptSuffix;
+    // NOTE: `modelOverrides` is intentionally NOT copied here. Model routing
+    // overrides are user-config only; allowing them from project configs would let
+    // an untrusted repository silently redirect API calls (apiModel) or reasoning.
     if (config.browser) {
         sanitized.browser = {};
         const browser = config.browser;

package/dist/src/oracle/client.js

@@ -141,6 +141,8 @@ function buildOpenRouterCompletionClient(instance) {
             model: body.model,
             messages,
             max_tokens: body.max_output_tokens,
+            // Custom gateways use Chat Completions, whose effort field differs from Responses.
+            ...(body.reasoning?.effort ? { reasoning_effort: body.reasoning.effort } : {}),
         };
         const streaming = { ...base, stream: true };
         const nonStreaming = { ...base, stream: false };

package/dist/src/oracle/modelResolver.js

@@ -120,6 +120,12 @@ function mapToOpenRouterId(candidate, catalog, providerHint) {
     return candidate;
 }
 export async function resolveModelConfig(model, options = {}) {
+    const base = await resolveBaseModelConfig(model, options);
+    // Apply user-config per-model overrides last, after known/OpenRouter/synthesized
+    // resolution, so an explicit override always wins.
+    return applyModelOverride(base, model, options.modelOverrides);
+}
+async function resolveBaseModelConfig(model, options = {}) {
     const known = isKnownModel(model) ? MODEL_CONFIGS[model] : null;
     const fetcher = options.fetcher ?? globalThis.fetch.bind(globalThis);
     const openRouterActive = isOpenRouterBaseUrl(options.baseUrl) || Boolean(options.openRouterApiKey);
@@ -186,6 +192,85 @@ export async function resolveModelConfig(model, options = {}) {
 export function isProModel(model) {
     return isKnownModel(model) && PRO_MODELS.has(model);
 }
+const VALID_REASONING_EFFORTS = ["low", "medium", "high", "xhigh"];
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Returns the override's `apiModel` for a *known* model when present and non-empty,
+ * otherwise `undefined`. Single source of truth for the override apiModel rule,
+ * shared by {@link applyModelOverride} and the CLI's `effectiveModelId` resolution.
+ */
+export function resolveOverriddenApiModel(model, overrides) {
+    if (!overrides || !isKnownModel(model))
+        return undefined;
+    const override = overrides[model];
+    if (!isRecord(override))
+        return undefined;
+    if (typeof override.apiModel === "string" && override.apiModel.trim() !== "") {
+        return override.apiModel.trim();
+    }
+    return undefined;
+}
+/**
+ * Apply a user-config per-model override on top of a resolved config.
+ *
+ * Scope is intentionally narrow: only *known* models can be overridden, so the
+ * tokenizer (a function, not expressible in JSON) and any unspecified fields are
+ * inherited from the base config. Override fields are validated defensively
+ * because they come from user-authored JSON5.
+ */
+export function applyModelOverride(base, model, overrides) {
+    if (!overrides || !isKnownModel(model))
+        return base;
+    const override = overrides[model];
+    if (!isRecord(override))
+        return base;
+    const result = { ...base };
+    const apiModel = resolveOverriddenApiModel(model, overrides);
+    if (apiModel) {
+        result.apiModel = apiModel;
+    }
+    if (Object.hasOwn(override, "reasoning")) {
+        const reasoning = override.reasoning;
+        if (reasoning === null) {
+            // Explicit null clears the known model's reasoning effort.
+            result.reasoning = null;
+        }
+        else if (isRecord(reasoning) &&
+            typeof reasoning.effort === "string" &&
+            VALID_REASONING_EFFORTS.includes(reasoning.effort)) {
+            result.reasoning = { effort: reasoning.effort };
+        }
+        // Malformed reasoning override is ignored (base value preserved).
+    }
+    if (typeof override.inputLimit === "number" &&
+        Number.isSafeInteger(override.inputLimit) &&
+        override.inputLimit > 0) {
+        result.inputLimit = override.inputLimit;
+    }
+    // Non-positive or non-integer inputLimit (e.g. 0, 0.5, NaN, Infinity) is ignored.
+    if (Object.hasOwn(override, "pricing")) {
+        const pricing = override.pricing;
+        if (pricing === null) {
+            result.pricing = null;
+        }
+        else if (isRecord(pricing) &&
+            typeof pricing.inputPerToken === "number" &&
+            Number.isFinite(pricing.inputPerToken) &&
+            pricing.inputPerToken >= 0 &&
+            typeof pricing.outputPerToken === "number" &&
+            Number.isFinite(pricing.outputPerToken) &&
+            pricing.outputPerToken >= 0) {
+            result.pricing = {
+                inputPerToken: pricing.inputPerToken,
+                outputPerToken: pricing.outputPerToken,
+            };
+        }
+        // Malformed pricing override is ignored (base value preserved).
+    }
+    return result;
+}
 export function resetOpenRouterCatalogCacheForTest() {
     catalogCache.clear();
 }

package/dist/src/oracle/multiModelRunner.js

@@ -2,6 +2,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { runOracle, OracleResponseError, OracleTransportError, extractResponseMetadata, asOracleUserError, extractTextOutput, classifyProviderFailure, } from "../oracle.js";
 import { sessionStore } from "../sessionStore.js";
+import { resolveOverriddenApiModel } from "./modelResolver.js";
 import { findOscProgressSequences, OSC_PROGRESS_PREFIX } from "osc-progress";
 function forwardOscProgress(chunk, shouldForward) {
     if (!shouldForward || !chunk.includes(OSC_PROGRESS_PREFIX)) {
@@ -81,7 +82,9 @@ function startModelExecution({ sessionMeta, runOptions, model, cwd, store, runOr
         });
         const result = await runOracleImpl({
             ...perModelOptions,
-            effectiveModelId: model,
+            // Respect a user-config apiModel override for this known model; falls back
+            // to the canonical model id (unchanged behavior) when no override applies.
+            effectiveModelId: resolveOverriddenApiModel(model, runOptions.modelOverrides) ?? model,
             // Drop per-model preamble; the aggregate runner prints the shared header and tips once.
             suppressHeader: true,
             suppressAnswerHeader: true,

package/dist/src/oracle/oscProgress.js

@@ -1,6 +1,6 @@
 import process from "node:process";
 import { startOscProgress as startOscProgressShared, supportsOscProgress as supportsOscProgressShared, } from "osc-progress";
-export function supportsOscProgress(env = process.env, isTty = process.stdout.isTTY) {
+export function supportsOscProgress(env = process.env, isTty = process.stdout.isTTY === true) {
     if (env.CODEX_MANAGED_BY_NPM === "1" && env.ORACLE_FORCE_OSC_PROGRESS !== "1") {
         return false;
     }
@@ -16,8 +16,9 @@ export function startOscProgress(options = {}) {
     }
     return startOscProgressShared({
         ...options,
-        // Preserve Oracle's previous default: progress emits to stdout.
+        // Preserve Oracle's previous defaults: progress emits to and checks stdout.
         write: options.write ?? ((text) => process.stdout.write(text)),
+        isTty: options.isTty ?? process.stdout.isTTY === true,
         disableEnvVar: "ORACLE_NO_OSC_PROGRESS",
         forceEnvVar: "ORACLE_FORCE_OSC_PROGRESS",
     });

package/dist/src/oracle/run.js

@@ -25,7 +25,7 @@ import { createMarkdownStreamer } from "markdansi";
 import { executeBackgroundResponse } from "./background.js";
 import { formatTokenEstimate, formatTokenValue, resolvePreviewMode } from "./runUtils.js";
 import { estimateUsdCost } from "tokentally";
-import { isOpenRouterBaseUrl, isProModel, resolveModelConfig } from "./modelResolver.js";
+import { isOpenRouterBaseUrl, isProModel, resolveModelConfig, resolveOverriddenApiModel, } from "./modelResolver.js";
 import { validateProviderRouting } from "./providerRouting.js";
 import { formatRouteTargetForLog, resolveProviderRoute, } from "./providerRoutePlan.js";
 const isStdoutTty = process.stdout.isTTY && chalk.level > 0;
@@ -133,6 +133,7 @@ export async function runOracle(options, deps = {}) {
     const modelConfig = await resolveModelConfig(options.model, {
         baseUrl,
         openRouterApiKey: resolverOpenRouterApiKey,
+        modelOverrides: options.modelOverrides,
     });
     const isLongRunningModel = isProTierModel;
     const supportsBackground = modelConfig.supportsBackground !== false;
@@ -194,6 +195,8 @@ export async function runOracle(options, deps = {}) {
     // Track the concrete model id we dispatch to (especially for Gemini preview aliases)
     const effectiveModelId = azureDeploymentName ??
         options.effectiveModelId ??
+        // A user-config apiModel override (known models only) wins over Gemini alias remapping.
+        resolveOverriddenApiModel(options.model, options.modelOverrides) ??
         (options.model.startsWith("gemini")
             ? resolveGeminiModelId(options.model)
             : (modelConfig.apiModel ?? modelConfig.model));