@steipete/oracle 0.14.1 → 0.15.1

package/dist/src/browser/windowsCookies.js

@@ -0,0 +1,219 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import { existsSync, promises as fsp } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import sqlite3 from 'sqlite3';
+import { createRequire } from 'node:module';
+import { spawnSync } from 'node:child_process';
+let cachedUnprotect = null;
+function getUnprotectData() {
+    if (cachedUnprotect) {
+        return cachedUnprotect;
+    }
+    try {
+        // win-dpapi is CommonJS; require it explicitly and support both named/default shapes.
+        const dpapiModule = createRequire(import.meta.url)('win-dpapi');
+        const unprotect = dpapiModule?.Dpapi?.unprotectData ??
+            dpapiModule?.default?.unprotectData ??
+            ((_) => {
+                throw new Error('win-dpapi unprotectData not available');
+            });
+        cachedUnprotect = unprotect;
+        return unprotect;
+    }
+    catch (error) {
+        if (process.platform !== 'win32') {
+            // On macOS/Linux we don't need DPAPI; return a function that makes misuse obvious.
+            cachedUnprotect = () => {
+                throw new Error('win-dpapi is unavailable on non-Windows platforms');
+            };
+            return cachedUnprotect;
+        }
+        throw error;
+    }
+}
+export async function loadWindowsCookies(dbPath, filterNames) {
+    if (process.platform !== 'win32') {
+        throw new Error('loadWindowsCookies is only supported on Windows');
+    }
+    const localStatePath = await locateLocalState(dbPath);
+    const cookiesCopy = await copyLockedFile(dbPath, 'Cookies'); // name the copy exactly "Cookies"
+    const cookiesDirForFallback = await ensureCookiesDirForFallback(cookiesCopy);
+    const localStateCopy = await copyLockedFile(localStatePath, 'Local State');
+    const aesKey = await extractWindowsAesKey(localStateCopy);
+    const rows = await readChromeCookiesDb(cookiesCopy, filterNames);
+    const cookies = [];
+    for (const row of rows) {
+        const enc = row.encrypted_value && row.encrypted_value.length > 0 ? row.encrypted_value : Buffer.from(row.value ?? '', 'utf8');
+        const decrypted = enc.length > 0 ? decryptCookie(enc, aesKey) : '';
+        cookies.push({
+            name: row.name,
+            value: decrypted,
+            domain: row.host_key?.startsWith('.') ? row.host_key.slice(1) : row.host_key,
+            path: row.path ?? '/',
+            expires: normalizeExpiration(row.expires_utc),
+            secure: Boolean(row.is_secure),
+            httpOnly: Boolean(row.is_httponly),
+        });
+    }
+    if (process.env.ORACLE_DEBUG_COOKIES === '1') {
+        // eslint-disable-next-line no-console
+        console.log(`[cookies] windows decrypt decoded ${cookies.length} cookies from ${cookiesCopy} (fallback dir ${cookiesDirForFallback})`);
+    }
+    return cookies.filter((c) => c.value);
+}
+function decryptCookie(value, aesKey) {
+    const prefix = value.slice(0, 3).toString();
+    // Chrome prefixes AES-GCM encrypted cookies with version markers like v10/v11/v20; treat all v** the same.
+    if (/^v\d{2}$/u.test(prefix)) {
+        const iv = value.slice(3, 15);
+        const tag = value.slice(value.length - 16);
+        const data = value.slice(15, value.length - 16);
+        const decipher = crypto.createDecipheriv('aes-256-gcm', aesKey, iv);
+        decipher.setAuthTag(tag);
+        const decrypted = Buffer.concat([decipher.update(data), decipher.final()]);
+        return decrypted.toString('utf8');
+    }
+    const unprotectData = getUnprotectData();
+    const unprotected = unprotectData(value, undefined, 'CurrentUser');
+    return Buffer.from(unprotected).toString('utf8');
+}
+async function locateLocalState(dbPath) {
+    // Prefer sibling Local State near the profile path; fall back to default location.
+    const guess = path.resolve(path.join(path.dirname(dbPath), '..', 'Local State'));
+    if (existsSync(guess))
+        return guess;
+    const localState = path.join(os.homedir(), 'AppData', 'Local', 'Google', 'Chrome', 'User Data', 'Local State');
+    if (existsSync(localState))
+        return localState;
+    throw new Error('Chrome Local State not found for AES key');
+}
+async function extractWindowsAesKey(localStatePath) {
+    const raw = await fs.readFile(localStatePath, 'utf8');
+    const state = JSON.parse(raw);
+    const encKeyB64 = state?.os_crypt?.encrypted_key;
+    if (!encKeyB64)
+        throw new Error('encrypted_key missing in Local State');
+    const encKey = Buffer.from(encKeyB64, 'base64');
+    const dpapiBlob = encKey.slice(5); // strip "DPAPI"
+    const unprotectData = getUnprotectData();
+    const unprotected = unprotectData(dpapiBlob, undefined, 'CurrentUser');
+    return Buffer.from(unprotected);
+}
+async function readChromeCookiesDb(dbPath, filterNames) {
+    const db = await openSqlite(dbPath);
+    const placeholders = filterNames && filterNames.size > 0 ? `AND name IN (${Array.from(filterNames).map(() => '?').join(',')})` : '';
+    const params = filterNames ? Array.from(filterNames) : [];
+    const sql = `SELECT name,value,encrypted_value,host_key,path,expires_utc,is_secure,is_httponly FROM cookies WHERE host_key LIKE '%chatgpt.com%' ${placeholders}`;
+    try {
+        return await allSqlite(db, sql, params);
+    }
+    finally {
+        db.close();
+    }
+}
+function openSqlite(dbPath) {
+    return new Promise((resolve, reject) => {
+        const db = new sqlite3.Database(dbPath, sqlite3.OPEN_READONLY, (err) => {
+            if (err)
+                reject(err);
+            else
+                resolve(db);
+        });
+    });
+}
+async function copyLockedFile(sourcePath, targetName) {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'oracle-cookie-'));
+    const tempPath = targetName ? path.join(tempDir, targetName) : path.join(tempDir, path.basename(sourcePath));
+    const psScript = `
+$src = '${sourcePath.replace(/'/g, "''")}'
+$dst = '${tempPath.replace(/'/g, "''")}'
+try {
+  $fs = [System.IO.File]::Open($src, [System.IO.FileMode]::Open, [System.IO.FileAccess]::Read, [System.IO.FileShare]::ReadWrite)
+  $bytes = New-Object byte[] $fs.Length
+  $null = $fs.Read($bytes, 0, $fs.Length)
+  $fs.Close()
+  [System.IO.File]::WriteAllBytes($dst, $bytes)
+  exit 0
+} catch {
+  exit 1
+}
+`;
+    const encoded = Buffer.from(psScript, 'utf16le').toString('base64');
+    const result = spawnSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-EncodedCommand', encoded], {
+        timeout: 15000,
+        encoding: 'utf8',
+    });
+    if (result.status !== 0) {
+        // Fallback: best-effort normal copy
+        await fs.copyFile(sourcePath, tempPath);
+    }
+    if (process.env.ORACLE_DEBUG_COOKIES === '1') {
+        // eslint-disable-next-line no-console
+        console.log(`[cookies] copied locked file ${sourcePath} -> ${tempPath}`);
+    }
+    return tempPath;
+}
+// Create a directory containing a file named "Cookies" for chrome-cookies-secure fallback
+export async function ensureCookiesDirForFallback(cookieFile) {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'oracle-cookies-secure-'));
+    const target = path.join(dir, 'Cookies');
+    await fs.copyFile(cookieFile, target);
+    return dir;
+}
+function allSqlite(db, sql, params) {
+    return new Promise((resolve, reject) => {
+        db.all(sql, params, (err, rows) => {
+            if (err)
+                reject(err);
+            else
+                resolve((rows ?? []));
+        });
+    });
+}
+function normalizeExpiration(expires) {
+    if (!expires || Number.isNaN(expires)) {
+        return undefined;
+    }
+    const value = Number(expires);
+    if (value <= 0)
+        return undefined;
+    if (value > 1_000_000_000_000) {
+        return Math.round(value / 1_000_000 - 11644473600);
+    }
+    if (value > 1_000_000_000) {
+        return Math.round(value / 1000);
+    }
+    return Math.round(value);
+}
+export async function materializeCookieFile(sourcePath) {
+    if (process.platform !== 'win32')
+        return sourcePath;
+    const resolved = await resolveDirectoryCandidate(sourcePath);
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'oracle-cookies-'));
+    const tempPath = path.join(tempDir, 'Cookies');
+    await fs.copyFile(resolved, tempPath);
+    return tempPath;
+}
+async function resolveDirectoryCandidate(inputPath) {
+    const stat = await fs.stat(inputPath).catch(() => null);
+    if (!stat?.isDirectory())
+        return inputPath;
+    const network = path.join(inputPath, 'Network', 'Cookies');
+    const direct = path.join(inputPath, 'Cookies');
+    if (await fileExists(network))
+        return network;
+    if (await fileExists(direct))
+        return direct;
+    return inputPath;
+}
+async function fileExists(candidate) {
+    try {
+        const stat = await fsp.stat(candidate);
+        return stat.isFile();
+    }
+    catch {
+        return false;
+    }
+}

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/browserConfig.js

@@ -64,6 +64,18 @@ export function normalizeChatGptModelForBrowser(model) {
     return model;
 }
 export async function buildBrowserConfig(options) {
+    if (options.copyProfile && options.browserKeepBrowser) {
+        throw new Error("--copy-profile cannot be combined with --browser-keep-browser: the copied profile is a throwaway that is deleted after the run, so it must not be retained.");
+    }
+    if (options.copyProfile && options.browserManualLogin) {
+        throw new Error("--copy-profile cannot be combined with --browser-manual-login: choose either a throwaway copied profile or the persistent manual-login profile.");
+    }
+    if (options.copyProfile && options.remoteChrome) {
+        throw new Error("--copy-profile cannot be combined with --remote-chrome: copied profiles require a locally launched Chrome instance.");
+    }
+    if (options.copyProfile && options.remoteHost) {
+        throw new Error("--copy-profile cannot be combined with --remote-host: the local profile source is not available to the remote browser service.");
+    }
     const desiredModelOverride = options.browserModelLabel?.trim();
     const normalizedOverride = desiredModelOverride?.toLowerCase() ?? "";
     const baseModel = options.model.toLowerCase();
@@ -98,7 +110,9 @@ export async function buildBrowserConfig(options) {
             ? desiredModelOverride
             : mapModelToBrowserLabel(options.model);
     return {
-        chromeProfile: options.browserChromeProfile ?? DEFAULT_CHROME_PROFILE,
+        chromeProfile: options.copyProfile
+            ? (options.browserChromeProfile ?? null)
+            : (options.browserChromeProfile ?? DEFAULT_CHROME_PROFILE),
         chromePath: options.browserChromePath ?? null,
         chromeCookiePath: options.browserCookiePath ?? null,
         attachRunning,
@@ -146,6 +160,7 @@ export async function buildBrowserConfig(options) {
         keepBrowser: options.browserKeepBrowser ? true : undefined,
         manualLogin: options.browserManualLogin === undefined ? undefined : options.browserManualLogin,
         manualLoginProfileDir: options.browserManualLoginProfileDir ?? undefined,
+        copyProfileSource: options.copyProfile ?? undefined,
         hideWindow: options.browserHideWindow ? true : undefined,
         desiredModel,
         modelStrategy,
@@ -171,6 +186,7 @@ function validateAttachRunningOptions(options, { attachRunning, hasInlineCookies
         options.browserKeepBrowser ? "--browser-keep-browser" : null,
         options.browserManualLogin ? "--browser-manual-login" : null,
         options.browserManualLoginProfileDir ? "--browser-manual-login-profile-dir" : null,
+        options.copyProfile ? "--copy-profile" : null,
         hasInlineCookies ? "--browser-inline-cookies/--browser-inline-cookies-file" : null,
         options.browserPort != null || options.browserDebugPort != null
             ? "--browser-port/--browser-debug-port"

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,
@@ -389,6 +401,7 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             userError.details?.stage === "assistant-timeout";
         const cloudflareChallenge = userError?.category === "browser-automation" &&
             userError.details?.stage === "cloudflare-challenge";
+        const browserCanReattach = !browserConfig?.copyProfileSource;
         let reattachGuidanceLogged = false;
         const logBrowserReattachGuidance = (runtime) => {
             if (reattachGuidanceLogged || mode !== "browser")
@@ -399,10 +412,10 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             reattachGuidanceLogged = true;
             log(formatBrowserReattachGuidance(sessionMeta.id));
         };
-        if (connectionLost && 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."));
@@ -424,6 +437,7 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                     errorMessage: message,
                     mode,
                     browser: {
+                        ...currentBrowser,
                         config: browserConfig,
                         runtime: recoverableRuntime,
                     },
@@ -448,15 +462,16 @@ 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" },
             });
             logBrowserReattachGuidance(recoverableRuntime);
             return;
         }
-        if (assistantTimeout && mode === "browser") {
+        if (assistantTimeout && mode === "browser" && browserCanReattach) {
             const runtime = userError.details
                 ?.runtime;
             log(dim("Assistant response timed out; marking capture incomplete for reattach."));
@@ -478,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: {
@@ -490,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,
@@ -504,14 +521,19 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                     return;
                 }
             }
-            logBrowserReattachGuidance(runtime ?? sessionMeta.browser?.runtime);
+            logBrowserReattachGuidance(runtime ?? currentBrowser?.runtime);
             return;
         }
         if (cloudflareChallenge && mode === "browser") {
             const details = userError.details;
-            log(dim("Cloudflare challenge detected; browser left running so you can complete the check."));
-            if (details?.reuseProfileHint) {
-                log(dim(`Reuse this browser profile with: ${details.reuseProfileHint}`));
+            if (browserCanReattach) {
+                log(dim("Cloudflare challenge detected; browser left running so you can complete the check."));
+                if (details?.reuseProfileHint) {
+                    log(dim(`Reuse this browser profile with: ${details.reuseProfileHint}`));
+                }
+            }
+            else {
+                log(dim("Cloudflare challenge detected; copied profile closed and removed."));
             }
         }
         if (userError) {
@@ -527,11 +549,11 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
         if (transportLine) {
             log(dim(`Transport: ${transportLine}`));
         }
-        const browserRuntime = mode === "browser"
+        const browserRuntime = mode === "browser" && browserCanReattach
             ? userError?.details?.runtime
             : undefined;
-        if (!cloudflareChallenge) {
-            logBrowserReattachGuidance(browserRuntime ?? sessionMeta.browser?.runtime);
+        if (!cloudflareChallenge && browserCanReattach) {
+            logBrowserReattachGuidance(browserRuntime ?? currentBrowser?.runtime);
         }
         await sessionStore.updateSession(sessionMeta.id, {
             status: "error",
@@ -540,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,
@@ -810,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;
@@ -892,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();
 }