@steipete/oracle 0.12.1 → 0.14.0

package/dist/src/cli/followup.js

@@ -0,0 +1,72 @@
+import { CHATGPT_URL } from "../browser/constants.js";
+import { buildConversationUrl } from "../browser/reattachHelpers.js";
+import { resolveRecoveryUrl } from "../browser/recoverConversation.js";
+import { isRecoverableChatGptConversationUrl } from "../browser/reattachability.js";
+import { DEFAULT_MODEL } from "../oracle/config.js";
+/**
+ * Resolve the ChatGPT conversation URL to reopen for a browser follow-up.
+ *
+ * Reuses the same recoverable-URL gate as conversation recovery
+ * (`resolveRecoveryUrl`): prefer the post-harvest URL, fall back to the
+ * runtime tab URL, and reject home / project-shell / external URLs via
+ * `isRecoverableChatGptConversationUrl`. Only when neither candidate is a
+ * recoverable `chatgpt.com/c/<id>` URL do we rebuild from a stored
+ * `conversationId` against the session's ChatGPT base — and that rebuilt URL is
+ * gated too. This prevents a stale or attacker-controlled URL in session
+ * metadata from navigating the signed-in browser profile somewhere unintended.
+ */
+export function resolveBrowserResumeConversationUrl(metadata, fallbackBaseUrl = CHATGPT_URL) {
+    const gatedUrl = resolveRecoveryUrl(metadata);
+    if (gatedUrl) {
+        return gatedUrl;
+    }
+    const conversationId = metadata.browser?.runtime?.conversationId?.trim();
+    if (!conversationId) {
+        return null;
+    }
+    const baseUrl = metadata.browser?.config?.url ?? fallbackBaseUrl;
+    const built = buildConversationUrl({ conversationId }, baseUrl);
+    if (built && isRecoverableChatGptConversationUrl(built)) {
+        return built;
+    }
+    return null;
+}
+export async function resolveBrowserFollowupReference(value, store) {
+    const trimmed = value.trim();
+    if (!trimmed || trimmed.startsWith("resp_")) {
+        return null;
+    }
+    const metadata = await store.readSession(trimmed);
+    if (!metadata) {
+        return null;
+    }
+    const mode = metadata.mode ?? metadata.options?.mode;
+    const hasBrowserMetadata = Boolean(metadata.browser?.runtime || metadata.browser?.config || metadata.options?.browserConfig);
+    if (mode !== "browser" && !hasBrowserMetadata) {
+        return null;
+    }
+    const resumeConversationUrl = resolveBrowserResumeConversationUrl(metadata);
+    if (!resumeConversationUrl) {
+        throw new Error(`Session ${trimmed} is a browser session but does not contain a ChatGPT conversation URL. Run "oracle status --hours 72 --limit 20" to list recent sessions.`);
+    }
+    const parentBrowserConfig = metadata.options?.browserConfig ?? metadata.browser?.config;
+    if (!parentBrowserConfig) {
+        throw new Error(`Session ${trimmed} is missing its stored browser configuration.`);
+    }
+    const storedModel = metadata.options?.model ?? metadata.model;
+    const model = typeof storedModel === "string" && storedModel.startsWith("gpt-")
+        ? storedModel
+        : DEFAULT_MODEL;
+    return {
+        sessionId: metadata.id,
+        resumeConversationUrl,
+        model,
+        browserConfig: {
+            ...parentBrowserConfig,
+            browserTabRef: null,
+            resumeConversationUrl,
+            researchMode: "off",
+            archiveConversations: "never",
+        },
+    };
+}

package/dist/src/cli/help.js

@@ -49,7 +49,7 @@ function renderHelpFooter(program, colors) {
         `${colors.bullet("•")} Spell out the project + platform + version requirements (repo name, target OS/toolchain versions, API dependencies) so Oracle doesn’t guess defaults.`,
         `${colors.bullet("•")} When comparing multiple repos/files, spell out each repo + path + role (e.g., “Project A SettingsView → apps/project-a/Sources/SettingsView.swift; Project B SettingsView → ../project-b/mac/...”) so the model knows exactly which file is which.`,
         `${colors.bullet("•")} Best results: 6–30 sentences plus key source files; very short prompts often yield generic answers.`,
-        `${colors.bullet("•")} Oracle is one-shot by default. API runs can continue with ${colors.accent("--followup <sessionId|responseId>")}; browser runs can ask sequential ChatGPT turns with repeated ${colors.accent("--browser-follow-up")}.`,
+        `${colors.bullet("•")} Oracle is one-shot by default. Continue saved API or ChatGPT browser sessions with ${colors.accent("--followup <sessionId|responseId>")}; use repeated ${colors.accent("--browser-follow-up")} for planned same-run ChatGPT turns.`,
         `${colors.bullet("•")} Run ${colors.accent("--files-report")} to inspect token spend before hitting the API.`,
         `${colors.bullet("•")} Non-preview runs spawn detached sessions (especially gpt-5.5-pro API). If the CLI times out, do not re-run — reattach with ${colors.accent("oracle session <slug>")} to resume/inspect the existing run.`,
         `${colors.bullet("•")} Set a memorable 3–5 word slug via ${colors.accent('--slug "<words>"')} to keep session IDs tidy.`,

package/dist/src/cli/options.js

@@ -228,6 +228,14 @@ export function resolveApiModel(modelValue) {
         throw new InvalidArgumentError("Gemini Deep Think is browser-only today. Use --engine browser --model gemini-3-deep-think.");
     }
     if (normalized.includes("gemini")) {
+        if (normalized.includes("3.5") && normalized.includes("flash")) {
+            return "gemini-3.5-flash";
+        }
+        if ((normalized.includes("3.1") || normalized.includes("3_1")) &&
+            normalized.includes("flash") &&
+            normalized.includes("lite")) {
+            return "gemini-3.1-flash-lite";
+        }
         if (normalized.includes("3.1") || normalized.includes("3_1")) {
             return "gemini-3.1-pro";
         }
@@ -266,6 +274,14 @@ export function inferModelFromLabel(modelValue) {
         return "gemini-3-pro-deep-think";
     }
     if (normalized.includes("gemini")) {
+        if (normalized.includes("3.5") && normalized.includes("flash")) {
+            return "gemini-3.5-flash";
+        }
+        if ((normalized.includes("3.1") || normalized.includes("3_1")) &&
+            normalized.includes("flash") &&
+            normalized.includes("lite")) {
+            return "gemini-3.1-flash-lite";
+        }
         if (normalized.includes("3.1") || normalized.includes("3_1")) {
             return "gemini-3.1-pro";
         }
@@ -280,6 +296,10 @@ export function inferModelFromLabel(modelValue) {
     if ((normalized.includes("5.5") || normalized.includes("5_5")) && normalized.includes("pro")) {
         return "gpt-5.5-pro";
     }
+    if ((normalized.includes("5.5") || normalized.includes("5_5")) &&
+        (normalized.includes("instant") || normalized.includes("fast"))) {
+        return "gpt-5.5-instant";
+    }
     if (normalized.includes("5.5") || normalized.includes("5_5")) {
         return "gpt-5.5";
     }

package/dist/src/cli/reattachGuidance.js

@@ -0,0 +1,8 @@
+export function formatBrowserReattachGuidance(sessionId) {
+    return [
+        "This run did not return cleanly, but it may still be alive. Reattach:",
+        `  oracle session ${sessionId} --render    # final markdown when complete`,
+        `  oracle session ${sessionId} --live      # tail until done`,
+        `  oracle session ${sessionId} --harvest   # snapshot the current answer now`,
+    ].join("\n");
+}

package/dist/src/cli/runOptions.js

@@ -7,14 +7,17 @@ import { normalizeChatGptModelForBrowser } from "./browserConfig.js";
 import { resolveConfiguredMaxFileSizeBytes } from "./fileSize.js";
 import { isAzureOpenAICandidateModel } from "../oracle/providerRouting.js";
 export function resolveRunOptionsFromConfig({ prompt, files = [], model, models, engine, userConfig, env = process.env, }) {
-    const resolvedEngine = resolveEngineWithConfig({
+    const resolvedEngine = resolveEngine({
         engine,
         configEngine: userConfig?.engine,
         env,
     });
+    const envEnginePreference = (env.ORACLE_ENGINE ?? "").trim().toLowerCase();
     const browserRequested = engine === "browser";
-    const browserConfigured = userConfig?.engine === "browser";
-    const envBrowserConfigured = (env.ORACLE_ENGINE ?? "").trim().toLowerCase() === "browser";
+    const explicitApiEngineRequested = engine === "api" || (!engine && envEnginePreference === "api");
+    const browserConfigured = userConfig?.engine === "browser" && !explicitApiEngineRequested;
+    const envBrowserConfigured = !engine && envEnginePreference === "browser";
+    const browserEngineRequested = browserRequested || browserConfigured || envBrowserConfigured;
     const requestedModelList = Array.isArray(models) ? models : [];
     const normalizedRequestedModels = requestedModelList
         .map((entry) => normalizeModelOption(entry))
@@ -25,35 +28,22 @@ export function resolveRunOptionsFromConfig({ prompt, files = [], model, models,
     const isCodex = apiModel.startsWith("gpt-5.1-codex");
     const isClaude = apiModel.startsWith("claude");
     const isGrok = apiModel.startsWith("grok");
-    const isGeminiApiOnly = apiModel === "gemini-3.1-pro";
     const engineWasBrowser = resolvedEngine === "browser";
     const allModels = normalizedRequestedModels.length > 0
         ? Array.from(new Set(normalizedRequestedModels.map((entry) => resolveApiModel(entry))))
         : [apiModel];
     const browserCompatibilityModels = normalizedRequestedModels.length > 0 ? allModels : [browserModel];
-    const includesGeminiApiOnly = allModels.some((m) => m === "gemini-3.1-pro");
-    if ((browserRequested || browserConfigured) && includesGeminiApiOnly) {
-        throw new PromptValidationError("gemini-3.1-pro is API-only today. Use --engine api or switch to gemini-3-pro for Gemini web.", { engine: "browser", models: allModels });
-    }
     const isBrowserCompatible = (m) => m.startsWith("gpt-") || m.startsWith("gemini");
-    const hasNonBrowserCompatibleTarget = (browserRequested || browserConfigured) &&
-        browserCompatibilityModels.some((m) => !isBrowserCompatible(m));
+    const hasNonBrowserCompatibleTarget = browserEngineRequested && browserCompatibilityModels.some((m) => !isBrowserCompatible(m));
     if (hasNonBrowserCompatibleTarget) {
         throw new PromptValidationError("Browser engine only supports GPT and Gemini models. Re-run with --engine api for Grok, Claude, or other models.", { engine: "browser", models: allModels });
     }
     const azure = resolveAzureOptions(userConfig, env);
     const azureAutoApi = Boolean(azure?.endpoint) &&
-        !browserRequested &&
-        !browserConfigured &&
-        !envBrowserConfigured &&
+        !browserEngineRequested &&
         allModels.some(isAzureOpenAICandidateModel);
-    const engineCoercedToApi = engineWasBrowser && (isCodex || isClaude || isGrok || isGeminiApiOnly || azureAutoApi);
-    const fixedEngine = isCodex ||
-        isClaude ||
-        isGrok ||
-        isGeminiApiOnly ||
-        azureAutoApi ||
-        normalizedRequestedModels.length > 0
+    const engineCoercedToApi = engineWasBrowser && (isCodex || isClaude || isGrok || azureAutoApi);
+    const fixedEngine = isCodex || isClaude || isGrok || azureAutoApi || normalizedRequestedModels.length > 0
         ? "api"
         : resolvedEngine;
     // Browser runs use ChatGPT picker labels/aliases; API runs must keep API model ids intact.
@@ -89,17 +79,6 @@ export function resolveRunOptionsFromConfig({ prompt, files = [], model, models,
     };
     return { runOptions, resolvedEngine: fixedEngine, engineCoercedToApi };
 }
-function resolveEngineWithConfig({ engine, configEngine, apiProviderRequested, env, }) {
-    if (engine)
-        return engine;
-    const envOverride = (env.ORACLE_ENGINE ?? "").trim().toLowerCase();
-    if (envOverride === "api" || envOverride === "browser") {
-        return envOverride;
-    }
-    if (configEngine)
-        return configEngine;
-    return resolveEngine({ engine: undefined, apiProviderRequested, env });
-}
 function resolveAzureOptions(userConfig, env) {
     const endpoint = env.AZURE_OPENAI_ENDPOINT ?? userConfig?.azure?.endpoint;
     if (!endpoint?.trim()) {

package/dist/src/cli/sessionCommand.js

@@ -109,16 +109,20 @@ export async function handleSessionCommand(sessionId, command, deps = defaultDep
             process.exitCode = 1;
             return;
         }
+        // Commander sets `recover: false` when --no-recover is passed; default is `true`.
+        const recoverIfMissing = sessionOptions.recover !== false;
         if (harvestRequested) {
             await deps.harvestSessionBrowserOutput(sessionId, {
                 writeOutputPath,
                 browserTabRef,
+                recoverIfMissing,
             });
             return;
         }
         await deps.liveTailSessionBrowserOutput(sessionId, {
             writeOutputPath,
             browserTabRef,
+            recoverIfMissing,
         });
         return;
     }

package/dist/src/cli/sessionDisplay.js

@@ -628,6 +628,14 @@ function matchesModel(entry, filter) {
         (entry.model ? [entry.model.toLowerCase()] : []);
     return models.includes(normalized);
 }
+function formatLineageParentLabel(lineage) {
+    if (!lineage?.parentSessionId) {
+        return undefined;
+    }
+    return lineage.parentResponseId
+        ? `${lineage.parentSessionId} (${abbreviateResponseId(lineage.parentResponseId)})`
+        : lineage.parentSessionId;
+}
 function buildStatusTreeRows(entries, responseOwners) {
     const entryById = new Map(entries.map((entry) => [entry.id, entry]));
     const orderIndex = new Map(entries.map((entry, index) => [entry.id, index]));
@@ -668,7 +676,7 @@ function buildStatusTreeRows(entries, responseOwners) {
         visited.add(entry.id);
         const lineage = lineageById.get(entry.id);
         const hiddenParent = lineage?.parentSessionId && !entryById.has(lineage.parentSessionId)
-            ? `${lineage.parentSessionId} (${abbreviateResponseId(lineage.parentResponseId)})`
+            ? formatLineageParentLabel(lineage)
             : undefined;
         const children = childMap.get(entry.id) ?? [];
         rows.push({ entry, displaySlug: entry.id, detachedParentLabel: hiddenParent });
@@ -694,13 +702,19 @@ async function buildSessionChainLine(metadata) {
         return `root -> ${metadata.id}`;
     }
     if (lineageWithoutLookup.parentSessionId) {
-        return `${lineageWithoutLookup.parentSessionId} (${abbreviateResponseId(lineageWithoutLookup.parentResponseId)}) -> ${metadata.id}`;
+        return `${formatLineageParentLabel(lineageWithoutLookup)} -> ${metadata.id}`;
+    }
+    if (!lineageWithoutLookup.parentResponseId) {
+        return `root -> ${metadata.id}`;
     }
     const sessions = await sessionStore.listSessions().catch(() => []);
     const responseOwners = buildResponseOwnerIndex(sessions);
     const lineage = resolveSessionLineage(metadata, responseOwners) ?? lineageWithoutLookup;
     if (lineage.parentSessionId) {
-        return `${lineage.parentSessionId} (${abbreviateResponseId(lineage.parentResponseId)}) -> ${metadata.id}`;
+        return `${formatLineageParentLabel(lineage)} -> ${metadata.id}`;
+    }
+    if (!lineage.parentResponseId) {
+        return `root -> ${metadata.id}`;
     }
     return `${abbreviateResponseId(lineage.parentResponseId)} -> ${metadata.id}`;
 }

package/dist/src/cli/sessionLineage.js

@@ -39,17 +39,20 @@ export function buildResponseOwnerIndex(sessions) {
 }
 export function resolveSessionLineage(meta, responseOwners) {
     const previous = meta.options?.previousResponseId?.trim();
-    if (!previous) {
+    let parentSessionId = meta.options?.followupSessionId?.trim();
+    if (!previous && !parentSessionId) {
         return null;
     }
-    let parentSessionId = meta.options?.followupSessionId?.trim();
-    if (!parentSessionId && responseOwners) {
+    if (!parentSessionId && previous && responseOwners) {
         parentSessionId = responseOwners.get(previous);
     }
     if (parentSessionId === meta.id) {
         parentSessionId = undefined;
     }
-    return { parentResponseId: previous, parentSessionId };
+    return {
+        parentResponseId: previous || undefined,
+        parentSessionId,
+    };
 }
 export function abbreviateResponseId(responseId, max = 18) {
     if (responseId.length <= max) {

package/dist/src/cli/sessionRunner.js

@@ -24,6 +24,7 @@ import { resumeBrowserSession } from "../browser/reattach.js";
 import { hasRecoverableChatGptConversation } from "../browser/reattachability.js";
 import { estimateTokenCount } from "../browser/utils.js";
 import { formatElapsed } from "../oracle/format.js";
+import { formatBrowserReattachGuidance } from "./reattachGuidance.js";
 const isTty = process.stdout.isTTY;
 const dim = (text) => (isTty ? kleur.dim(text) : text);
 export async function performSessionRun({ sessionMeta, runOptions, mode, browserConfig, cwd, log, write, version, notifications, browserDeps, muteStdout = false, }) {
@@ -388,6 +389,16 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             userError.details?.stage === "assistant-timeout";
         const cloudflareChallenge = userError?.category === "browser-automation" &&
             userError.details?.stage === "cloudflare-challenge";
+        let reattachGuidanceLogged = false;
+        const logBrowserReattachGuidance = (runtime) => {
+            if (reattachGuidanceLogged || mode !== "browser")
+                return;
+            if (!hasRecoverableChatGptConversation(runtime) && runtime?.promptSubmitted !== true) {
+                return;
+            }
+            reattachGuidanceLogged = true;
+            log(formatBrowserReattachGuidance(sessionMeta.id));
+        };
         if (connectionLost && mode === "browser") {
             const runtime = userError.details
                 ?.runtime;
@@ -442,6 +453,7 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 },
                 response: { status: "running", incompleteReason: "chrome-disconnected" },
             });
+            logBrowserReattachGuidance(recoverableRuntime);
             return;
         }
         if (assistantTimeout && mode === "browser") {
@@ -492,7 +504,7 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                     return;
                 }
             }
-            log(dim(`Reattach later with: oracle session ${sessionMeta.id}`));
+            logBrowserReattachGuidance(runtime ?? sessionMeta.browser?.runtime);
             return;
         }
         if (cloudflareChallenge && mode === "browser") {
@@ -518,6 +530,9 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
         const browserRuntime = mode === "browser"
             ? userError?.details?.runtime
             : undefined;
+        if (!cloudflareChallenge) {
+            logBrowserReattachGuidance(browserRuntime ?? sessionMeta.browser?.runtime);
+        }
         await sessionStore.updateSession(sessionMeta.id, {
             status: "error",
             completedAt: new Date().toISOString(),

package/dist/src/config.js

@@ -1,26 +1,181 @@
 import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import JSON5 from "json5";
 import { getOracleHomeDir } from "./oracleHome.js";
-function resolveConfigPath() {
+export const PROJECT_CONFIG_RELATIVE_PATH = path.join(".oracle", "config.json");
+function resolveUserConfigPath() {
     return path.join(getOracleHomeDir(), "config.json");
 }
-export async function loadUserConfig() {
-    const CONFIG_PATH = resolveConfigPath();
+export async function loadUserConfig(options = {}) {
+    const userConfigPath = resolveUserConfigPath();
+    const userConfig = await readConfigFile(userConfigPath);
+    const projectConfigPaths = options.includeProject === false
+        ? []
+        : await discoverProjectConfigPaths({
+            cwd: options.cwd ?? process.cwd(),
+            userConfigPath,
+        });
+    const loadedConfigs = [];
+    if (userConfig.loaded) {
+        loadedConfigs.push(userConfig);
+    }
+    let merged = userConfig.loaded ? userConfig.config : {};
+    for (const projectConfigPath of projectConfigPaths) {
+        const projectConfig = await readConfigFile(projectConfigPath);
+        if (!projectConfig.loaded)
+            continue;
+        loadedConfigs.push(projectConfig);
+        merged = mergeUserConfig(merged, sanitizeProjectConfig(projectConfig.config));
+    }
+    const loadedPaths = loadedConfigs.map((entry) => entry.path);
+    return {
+        config: merged,
+        path: userConfigPath,
+        paths: loadedPaths,
+        loaded: userConfig.loaded,
+    };
+}
+async function readConfigFile(configPath) {
     try {
-        const raw = await fs.readFile(CONFIG_PATH, "utf8");
+        const raw = await fs.readFile(configPath, "utf8");
         const parsed = JSON5.parse(raw);
-        return { config: parsed ?? {}, path: CONFIG_PATH, loaded: true };
+        return { config: parsed ?? {}, path: configPath, loaded: true };
     }
     catch (error) {
         const code = error.code;
         if (code === "ENOENT") {
-            return { config: {}, path: CONFIG_PATH, loaded: false };
+            return { config: {}, path: configPath, loaded: false };
         }
-        console.warn(`Failed to read ${CONFIG_PATH}: ${error instanceof Error ? error.message : String(error)}`);
-        return { config: {}, path: CONFIG_PATH, loaded: false };
+        console.warn(`Failed to read ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
+        return { config: {}, path: configPath, loaded: false };
     }
 }
 export function configPath() {
-    return resolveConfigPath();
+    return resolveUserConfigPath();
+}
+async function discoverProjectConfigPaths({ cwd, userConfigPath, }) {
+    const start = path.resolve(cwd);
+    const home = os.homedir();
+    const candidates = [];
+    const seen = new Set([path.resolve(userConfigPath)]);
+    let current = start;
+    while (true) {
+        if (current === home) {
+            break;
+        }
+        const candidate = path.join(current, PROJECT_CONFIG_RELATIVE_PATH);
+        const resolved = path.resolve(candidate);
+        if (!seen.has(resolved)) {
+            try {
+                const stat = await fs.stat(resolved);
+                if (stat.isFile()) {
+                    candidates.unshift(resolved);
+                    seen.add(resolved);
+                }
+            }
+            catch (error) {
+                if (error.code !== "ENOENT") {
+                    console.warn(`Failed to inspect ${resolved}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return candidates;
+}
+function mergeUserConfig(base, override) {
+    return deepMerge(base, override);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMerge(base, override) {
+    if (!isRecord(base) || !isRecord(override)) {
+        return override;
+    }
+    const result = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        const existing = result[key];
+        result[key] = isRecord(existing) && isRecord(value) ? deepMerge(existing, value) : value;
+    }
+    return result;
+}
+function sanitizeProjectConfig(config) {
+    const sanitized = {};
+    if (config.engine !== undefined)
+        sanitized.engine = config.engine;
+    if (config.model !== undefined)
+        sanitized.model = config.model;
+    if (config.search !== undefined)
+        sanitized.search = config.search;
+    if (config.maxFileSizeBytes !== undefined)
+        sanitized.maxFileSizeBytes = config.maxFileSizeBytes;
+    if (config.notify !== undefined)
+        sanitized.notify = config.notify;
+    if (config.heartbeatSeconds !== undefined)
+        sanitized.heartbeatSeconds = config.heartbeatSeconds;
+    if (config.filesReport !== undefined)
+        sanitized.filesReport = config.filesReport;
+    if (config.background !== undefined)
+        sanitized.background = config.background;
+    if (config.promptSuffix !== undefined)
+        sanitized.promptSuffix = config.promptSuffix;
+    if (config.browser) {
+        sanitized.browser = {};
+        const browser = config.browser;
+        const allowedBrowserKeys = [
+            "attachRunning",
+            "timeoutMs",
+            "inputTimeoutMs",
+            "attachmentTimeoutMs",
+            "assistantRecheckDelayMs",
+            "assistantRecheckTimeoutMs",
+            "reuseChromeWaitMs",
+            "profileLockTimeoutMs",
+            "maxConcurrentTabs",
+            "autoReattachDelayMs",
+            "autoReattachIntervalMs",
+            "autoReattachTimeoutMs",
+            "cookieSyncWaitMs",
+            "hideWindow",
+            "keepBrowser",
+            "modelStrategy",
+            "thinkingTime",
+            "researchMode",
+            "archiveConversations",
+            "manualLogin",
+        ];
+        for (const key of allowedBrowserKeys) {
+            if (browser[key] !== undefined) {
+                sanitized.browser[key] = browser[key];
+            }
+        }
+        const chatgptUrl = browser.chatgptUrl ?? browser.url;
+        if (chatgptUrl === null ||
+            (chatgptUrl !== undefined && isTrustedProjectChatgptUrl(chatgptUrl))) {
+            sanitized.browser.chatgptUrl = chatgptUrl;
+            sanitized.browser.url = chatgptUrl;
+        }
+    }
+    return sanitized;
+}
+function isTrustedProjectChatgptUrl(rawUrl) {
+    if (!rawUrl) {
+        return false;
+    }
+    try {
+        const parsed = new URL(rawUrl);
+        if (parsed.protocol !== "https:") {
+            return false;
+        }
+        return parsed.hostname === "chatgpt.com" || parsed.hostname === "chat.openai.com";
+    }
+    catch {
+        return false;
+    }
 }

package/dist/src/gemini-web/client.js

@@ -1,13 +1,8 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { buildGeminiWebModelHeader, FALLBACK_GEMINI_WEB_MODEL, } from "./models.js";
 const USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
 const MODEL_HEADER_NAME = "x-goog-ext-525001261-jspb";
-const MODEL_HEADERS = {
-    "gemini-3-pro": '[1,null,null,null,"9d8ca3786ebdfbea",null,null,0,[4]]',
-    "gemini-3-pro-deep-think": '[1,null,null,null,"e6fa609c3fa255c0",null,null,0,[4],null,null,3]',
-    "gemini-2.5-pro": '[1,null,null,null,"4af6c7f5da75d65d",null,null,0,[4]]',
-    "gemini-2.5-flash": '[1,null,null,null,"9ec249fc9ad08861",null,null,0,[4]]',
-};
 const GEMINI_APP_URL = "https://gemini.google.com/app";
 const GEMINI_STREAM_GENERATE_URL = "https://gemini.google.com/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate";
 const GEMINI_UPLOAD_URL = "https://content-push.googleapis.com/upload";
@@ -276,7 +271,7 @@ export async function runGeminiWebOnce(input) {
             "x-same-domain": "1",
             "user-agent": USER_AGENT,
             cookie: cookieHeader,
-            [MODEL_HEADER_NAME]: MODEL_HEADERS[input.model],
+            [MODEL_HEADER_NAME]: buildGeminiWebModelHeader(input.model),
         },
         body: params.toString(),
     });
@@ -324,9 +319,9 @@ export async function runGeminiWebOnce(input) {
 }
 export async function runGeminiWebWithFallback(input) {
     const attempt = await runGeminiWebOnce(input);
-    if (isGeminiModelUnavailable(attempt.errorCode) && input.model !== "gemini-2.5-flash") {
-        const fallback = await runGeminiWebOnce({ ...input, model: "gemini-2.5-flash" });
-        return { ...fallback, effectiveModel: "gemini-2.5-flash" };
+    if (isGeminiModelUnavailable(attempt.errorCode) && input.model !== FALLBACK_GEMINI_WEB_MODEL) {
+        const fallback = await runGeminiWebOnce({ ...input, model: FALLBACK_GEMINI_WEB_MODEL });
+        return { ...fallback, effectiveModel: FALLBACK_GEMINI_WEB_MODEL };
     }
     return { ...attempt, effectiveModel: input.model };
 }

package/dist/src/gemini-web/executor.js

@@ -4,6 +4,7 @@ import { runProviderDomFlow } from "../browser/providerDomFlow.js";
 import { delay } from "../browser/utils.js";
 import { runGeminiWebWithFallback, saveFirstGeminiImageFromOutput } from "./client.js";
 import { geminiDeepThinkDomProvider } from "../browser/providers/index.js";
+import { resolveGeminiWebModel } from "./models.js";
 import { openGeminiBrowserSession } from "./browserSessionManager.js";
 import { selectGeminiExecutionMode } from "./executionMode.js";
 const GEMINI_COOKIE_NAMES = [
@@ -38,30 +39,6 @@ function resolveInvocationPath(value) {
         return undefined;
     return path.isAbsolute(trimmed) ? trimmed : path.resolve(process.cwd(), trimmed);
 }
-function resolveGeminiWebModel(desiredModel, log) {
-    const desired = typeof desiredModel === "string" ? desiredModel.trim() : "";
-    if (!desired)
-        return "gemini-3-pro";
-    const normalized = desired.toLowerCase().replace(/[_\s]+/g, "-");
-    switch (normalized) {
-        case "gemini-3-pro":
-        case "gemini-3.0-pro":
-            return "gemini-3-pro";
-        case "gemini-3-deep-think":
-        case "gemini-3-pro-deep-think":
-        case "gemini-3-pro-deepthink":
-            return "gemini-3-pro-deep-think";
-        case "gemini-2.5-pro":
-            return "gemini-2.5-pro";
-        case "gemini-2.5-flash":
-            return "gemini-2.5-flash";
-        default:
-            if (normalized.startsWith("gemini-") || normalized.includes("gemini")) {
-                log?.(`[gemini-web] Unsupported Gemini web model "${desired}". Falling back to gemini-3-pro.`);
-            }
-            return "gemini-3-pro";
-    }
-}
 function resolveCookieDomain(cookie) {
     const rawDomain = cookie.domain?.trim();
     if (rawDomain) {