@steipete/oracle 0.19.0 → 0.20.1

package/dist/src/cli/sessionRunner.js

@@ -9,7 +9,6 @@ import { formatResponseMetadata, formatTransportMetadata } from "./sessionDispla
 import { markErrorLogged } from "./errorUtils.js";
 import { sendSessionNotification, deriveNotificationSettingsFromMetadata, } from "./notifier.js";
 import { sessionStore } from "../sessionStore.js";
-import { wait } from "../sessionManager.js";
 import { runMultiModelApiSession } from "../oracle/multiModelRunner.js";
 import { MODEL_CONFIGS, DEFAULT_SYSTEM_PROMPT } from "../oracle/config.js";
 import { isKnownModel } from "../oracle/modelResolver.js";
@@ -22,30 +21,71 @@ import { sanitizeOscProgress } from "./oscUtils.js";
 import { readFiles } from "../oracle/files.js";
 import { cwd as getCwd } from "node:process";
 import { resumeBrowserSession } from "../browser/reattach.js";
+import { recoveryCaptureFromRuntime, retireCancelledBrowserTarget, retireRecoveredBrowserTarget, } from "../browser/recoveryTarget.js";
 import { hasRecoverableChatGptConversation } from "../browser/reattachability.js";
-import { estimateTokenCount } from "../browser/utils.js";
+import { delay, estimateTokenCount } from "../browser/utils.js";
 import { computeFileSha256, sanitizeArtifactFilename } from "../browser/artifacts.js";
 import { formatElapsed } from "../oracle/format.js";
 import { formatBrowserReattachGuidance } from "./reattachGuidance.js";
+import { BrowserRunCancelledError } from "../oracle/errors.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, }) {
+export async function performSessionRun({ sessionMeta, runOptions, mode, browserConfig, cwd, log, write, version, notifications, browserDeps, muteStdout = false, signal, }) {
     const writeInline = (chunk) => {
         // Keep session logs intact while still echoing inline output to the user.
         write(chunk);
         return muteStdout ? true : process.stdout.write(chunk);
     };
     let currentBrowser = browserConfig
-        ? { config: browserConfig }
+        ? {
+            config: browserConfig,
+            ...(mode === "browser" && sessionMeta.browser?.runtime?.submittedPromptHash !== undefined
+                ? { runtime: { submittedPromptHash: null } }
+                : {}),
+        }
         : sessionMeta.browser;
     await sessionStore.updateSession(sessionMeta.id, {
         status: "running",
         startedAt: new Date().toISOString(),
         mode,
-        ...(browserConfig ? { browser: { config: browserConfig } } : {}),
+        ...(browserConfig ? { browser: currentBrowser } : {}),
     });
     const notificationSettings = notifications ?? deriveNotificationSettingsFromMetadata(sessionMeta, process.env);
     const modelForStatus = runOptions.model ?? sessionMeta.model;
+    const checkBrowserCancellation = () => {
+        if (mode === "browser" && signal?.aborted)
+            throw new BrowserRunCancelledError();
+    };
+    const finalizeBrowserCancellation = async (cancellationError) => {
+        const completedAt = new Date().toISOString();
+        log("Browser run cancelled.");
+        if (modelForStatus) {
+            await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
+                status: "cancelled",
+                completedAt,
+                response: { status: "cancelled" },
+                error: undefined,
+                transport: undefined,
+            });
+        }
+        await sessionStore.updateSession(sessionMeta.id, {
+            status: "cancelled",
+            completedAt,
+            errorMessage: undefined,
+            mode,
+            browser: browserConfig
+                ? {
+                    ...currentBrowser,
+                    config: browserConfig,
+                }
+                : undefined,
+            response: { status: "cancelled" },
+            error: undefined,
+            transport: undefined,
+        });
+        await retireCancelledBrowserTarget(sessionMeta.id, recoveryCaptureFromRuntime(currentBrowser?.runtime), log);
+        throw cancellationError;
+    };
     try {
         if (mode === "browser") {
             if (!browserConfig) {
@@ -79,13 +119,17 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 browserConfig,
                 cwd,
                 log,
+                signal,
             }, runnerDeps);
+            checkBrowserCancellation();
             const writtenOutputPath = await writeAssistantOutput(runOptions.writeOutputPath, result.answerText ?? "", log);
+            checkBrowserCancellation();
             const outputArtifacts = await copyBrowserOutputArtifacts({
                 outputPath: writtenOutputPath,
                 savedFiles: runOptions.writeArtifacts ? result.savedFiles : undefined,
                 log,
             });
+            checkBrowserCancellation();
             const browserWarnings = [...(result.warnings ?? []), ...outputArtifacts.warnings];
             await sendSessionNotification({
                 sessionId: sessionMeta.id,
@@ -95,13 +139,16 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 usage: result.usage,
                 characters: result.answerText?.length,
             }, notificationSettings, log, result.answerText?.slice(0, 140));
+            checkBrowserCancellation();
             if (modelForStatus) {
                 await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
                     status: "completed",
                     completedAt: new Date().toISOString(),
                     usage: result.usage,
                 });
+                checkBrowserCancellation();
             }
+            checkBrowserCancellation();
             await sessionStore.updateSession(sessionMeta.id, {
                 status: "completed",
                 completedAt: new Date().toISOString(),
@@ -400,6 +447,9 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
         });
     }
     catch (error) {
+        if (error instanceof BrowserRunCancelledError) {
+            return await finalizeBrowserCancellation(error);
+        }
         const message = formatError(error);
         log(`ERROR: ${message}`);
         markErrorLogged(error);
@@ -425,6 +475,11 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             const runtime = userError.details
                 ?.runtime;
             const recoverableRuntime = runtime ?? currentBrowser?.runtime;
+            currentBrowser = {
+                ...currentBrowser,
+                config: browserConfig,
+                runtime: recoverableRuntime,
+            };
             if (!hasRecoverableChatGptConversation(recoverableRuntime) &&
                 recoverableRuntime?.promptSubmitted !== true) {
                 log(dim("Chrome disconnected before a ChatGPT conversation was created; marking session error."));
@@ -494,22 +549,32 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             const connectionLostIntervalMs = configuredIntervalMs > 0
                 ? configuredIntervalMs
                 : Math.max(1_000, Math.min(browserConfig?.timeoutMs ?? 30_000, 30_000));
-            const success = await autoReattachUntilComplete({
-                sessionMeta,
-                runtime: recoverableRuntime ?? undefined,
-                browserConfig: {
-                    ...browserConfig,
-                    autoReattachIntervalMs: connectionLostIntervalMs,
-                    autoReattachDelayMs: browserConfig?.autoReattachDelayMs ?? 0,
-                    autoReattachTimeoutMs: browserConfig?.autoReattachTimeoutMs ?? browserConfig?.timeoutMs ?? 120_000,
-                },
-                browserMetadata: currentBrowser,
-                runOptions,
-                modelForStatus,
-                notificationSettings,
-                log,
-                maxAttempts: configuredIntervalMs > 0 ? undefined : 1,
-            });
+            let success;
+            try {
+                success = await autoReattachUntilComplete({
+                    sessionMeta,
+                    runtime: recoverableRuntime ?? undefined,
+                    browserConfig: {
+                        ...browserConfig,
+                        autoReattachIntervalMs: connectionLostIntervalMs,
+                        autoReattachDelayMs: browserConfig?.autoReattachDelayMs ?? 0,
+                        autoReattachTimeoutMs: browserConfig?.autoReattachTimeoutMs ?? browserConfig?.timeoutMs ?? 120_000,
+                    },
+                    browserMetadata: currentBrowser,
+                    runOptions,
+                    modelForStatus,
+                    notificationSettings,
+                    log,
+                    maxAttempts: configuredIntervalMs > 0 ? undefined : 1,
+                    signal,
+                });
+            }
+            catch (recoveryError) {
+                if (signal?.aborted || recoveryError instanceof BrowserRunCancelledError) {
+                    return await finalizeBrowserCancellation(new BrowserRunCancelledError());
+                }
+                throw recoveryError;
+            }
             if (success) {
                 return;
             }
@@ -530,6 +595,11 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             };
             const autoReattachIntervalMs = browserConfig?.autoReattachIntervalMs ?? 0;
             const autoRuntime = runtime ?? currentBrowser?.runtime;
+            currentBrowser = {
+                ...currentBrowser,
+                config: browserConfig,
+                runtime: autoRuntime,
+            };
             const willAutoReattach = autoReattachIntervalMs > 0 && Boolean(autoRuntime);
             if (willAutoReattach) {
                 if (modelForStatus) {
@@ -553,16 +623,26 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                     response: timeoutResponse,
                     error: timeoutError,
                 });
-                const success = await autoReattachUntilComplete({
-                    sessionMeta,
-                    runtime: autoRuntime,
-                    browserConfig,
-                    browserMetadata: currentBrowser,
-                    runOptions,
-                    modelForStatus,
-                    notificationSettings,
-                    log,
-                });
+                let success;
+                try {
+                    success = await autoReattachUntilComplete({
+                        sessionMeta,
+                        runtime: autoRuntime,
+                        browserConfig,
+                        browserMetadata: currentBrowser,
+                        runOptions,
+                        modelForStatus,
+                        notificationSettings,
+                        log,
+                        signal,
+                    });
+                }
+                catch (recoveryError) {
+                    if (signal?.aborted || recoveryError instanceof BrowserRunCancelledError) {
+                        return await finalizeBrowserCancellation(new BrowserRunCancelledError());
+                    }
+                    throw recoveryError;
+                }
                 if (success) {
                     return;
                 }
@@ -975,7 +1055,7 @@ async function writeAssistantOutput(targetPath, content, log) {
         log(dim(`write-output failed (${reason}); session completed anyway.`));
     }
 }
-async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig, browserMetadata, runOptions, modelForStatus, notificationSettings, log, maxAttempts, }) {
+async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig, browserMetadata, runOptions, modelForStatus, notificationSettings, log, maxAttempts, signal, }) {
     if (!runtime || !browserConfig) {
         log(dim("Auto-reattach disabled: missing runtime or browser config."));
         return false;
@@ -990,12 +1070,16 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
         120_000;
     const maxTotalMs = 2 * 60 * 60 * 1000; // 2h hard cap; avoid infinite polling by default.
     const maxDeadline = Date.now() + maxTotalMs;
+    const checkCancellation = () => {
+        if (signal?.aborted)
+            throw new BrowserRunCancelledError();
+    };
     const attemptLimit = typeof maxAttempts === "number" && maxAttempts > 0
         ? Math.floor(maxAttempts)
         : Number.POSITIVE_INFINITY;
     if (delayMs > 0) {
         log(dim(`Auto-reattach starting in ${formatElapsed(delayMs)}...`));
-        await wait(delayMs);
+        await delay(delayMs, signal);
     }
     if (Number.isFinite(attemptLimit)) {
         log(dim(`Auto-reattach will try up to ${attemptLimit} attempt(s).`));
@@ -1011,6 +1095,7 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
     logger.verbose = true;
     let attempt = 0;
     for (;;) {
+        checkCancellation();
         const remainingBudgetMs = maxDeadline - Date.now();
         if (remainingBudgetMs <= 0) {
             log(dim(`Auto-reattach stopped after ${formatElapsed(maxTotalMs)} without capturing an answer.`));
@@ -1024,9 +1109,11 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
                 ...browserConfig,
                 timeoutMs,
             };
-            const result = await resumeBrowserSession(runtime, reattachConfig, logger, {
+            const result = await awaitBrowserCancellation(resumeBrowserSession(runtime, reattachConfig, logger, {
                 promptPreview: sessionMeta.promptPreview,
-            });
+                signal,
+            }), signal);
+            checkCancellation();
             captureSucceeded = true;
             const answerText = result.answerMarkdown || result.answerText || "";
             const outputTokens = estimateTokenCount(answerText);
@@ -1039,11 +1126,11 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
                 existingArtifacts: sessionMeta.artifacts,
                 logger,
             });
-            const logWriter = sessionStore.createLogWriter(sessionMeta.id);
-            logWriter.logLine(`[auto-reattach] captured assistant response on attempt ${attempt}`);
-            logWriter.logLine("Answer:");
-            logWriter.logLine(answerText);
-            logWriter.stream.end();
+            checkCancellation();
+            const paths = await sessionStore.getPaths(sessionMeta.id);
+            checkCancellation();
+            await fs.appendFile(paths.log, `[auto-reattach] captured assistant response on attempt ${attempt}\nAnswer:\n${answerText}\n`, "utf8");
+            checkCancellation();
             if (modelForStatus) {
                 await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
                     status: "completed",
@@ -1055,8 +1142,10 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
                         totalTokens: outputTokens,
                     },
                 });
+                checkCancellation();
             }
             await writeAssistantOutput(runOptions.writeOutputPath, answerText, log);
+            checkCancellation();
             await sendSessionNotification({
                 sessionId: sessionMeta.id,
                 sessionName: sessionMeta.options?.slug ?? sessionMeta.id,
@@ -1068,6 +1157,7 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
                 },
                 characters: answerText.length,
             }, notificationSettings, log, answerText.slice(0, 140));
+            checkCancellation();
             await sessionStore.updateSession(sessionMeta.id, {
                 status: "completed",
                 completedAt: new Date().toISOString(),
@@ -1089,9 +1179,13 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
                 transport: undefined,
             });
             log(kleur.green("Auto-reattach succeeded; session marked completed."));
+            await retireRecoveredBrowserTarget(sessionMeta.id, result.captureTarget, logger);
             return true;
         }
         catch (error) {
+            if (signal?.aborted || error instanceof BrowserRunCancelledError) {
+                throw new BrowserRunCancelledError();
+            }
             if (captureSucceeded) {
                 const message = formatError(error);
                 if (modelForStatus) {
@@ -1129,7 +1223,25 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
             log(dim(`Auto-reattach stopped after ${formatElapsed(maxTotalMs)} without capturing an answer.`));
             return false;
         }
-        await wait(Math.min(intervalMs, remainingAfterAttemptMs));
+        await delay(Math.min(intervalMs, remainingAfterAttemptMs), signal);
+    }
+}
+async function awaitBrowserCancellation(task, signal) {
+    if (!signal)
+        return task;
+    if (signal.aborted)
+        throw new BrowserRunCancelledError();
+    let abort;
+    const cancelled = new Promise((_, reject) => {
+        abort = () => reject(new BrowserRunCancelledError());
+        signal.addEventListener("abort", abort, { once: true });
+    });
+    try {
+        return await Promise.race([task, cancelled]);
+    }
+    finally {
+        if (abort)
+            signal.removeEventListener("abort", abort);
     }
 }
 export function deriveModelOutputPath(basePath, model) {

package/dist/src/mcp/tools/consult.js

@@ -74,9 +74,9 @@ const consultInputShape = {
         .optional()
         .describe("Browser-only: model picker strategy. Mirrors the CLI --browser-model-strategy flag."),
     browserResearchMode: z
-        .enum(["deep"])
+        .enum(["search", "deep"])
         .optional()
-        .describe("Browser-only: activate ChatGPT Deep Research mode for broad web research."),
+        .describe("Browser-only: explicitly select ChatGPT Web Search or Deep Research."),
     browserArchive: z
         .enum(["auto", "always", "never"])
         .optional()

package/dist/src/mcp/types.js

@@ -23,7 +23,7 @@ export const consultInputSchema = z
     browserBundleFormat: z.enum(["auto", "text", "zip"]).optional(),
     browserThinkingTime: browserThinkingTimeInputSchema.optional(),
     browserModelStrategy: z.enum(["select", "current", "ignore"]).optional(),
-    browserResearchMode: z.enum(["deep"]).optional(),
+    browserResearchMode: z.enum(["search", "deep"]).optional(),
     browserArchive: z.enum(["auto", "always", "never"]).optional(),
     browserFollowUps: z.array(z.string()).optional(),
     browserKeepBrowser: z.boolean().optional(),

package/dist/src/oracle/config.js

@@ -30,6 +30,20 @@ const countTokensAnthropic = (input) => {
 // supported limit at the base-rate boundary until cost estimation supports tiers.
 const GPT_5_6_BASE_RATE_INPUT_LIMIT = 272_000;
 export const MODEL_CONFIGS = {
+    "gpt-6-astra": {
+        model: "gpt-6-astra",
+        provider: "openai",
+        tokenizer: countTokensGpt5,
+        // Conservative base-rate budget, not Astra's maximum context window.
+        // https://developers.openai.com/api/docs/models/gpt-6-astra
+        inputLimit: 272_000,
+        pricing: {
+            inputPerToken: 10 / 1_000_000,
+            outputPerToken: 50 / 1_000_000,
+        },
+        reasoning: { effort: "xhigh" },
+        searchToolType: "web_search",
+    },
     "gpt-5.6": {
         model: "gpt-5.6",
         provider: "openai",

package/dist/src/oracle/geminiModels.js

@@ -1,4 +1,5 @@
 const MODEL_ID_MAP = {
+    "gpt-6-astra": "gpt-6-astra",
     "gemini-3.1-flash-lite": "gemini-3.1-flash-lite",
     "gemini-3.1-pro": "gemini-3.1-pro-preview",
     "gemini-3.5-flash": "gemini-3.5-flash",

package/dist/src/oracle/run.js

@@ -36,6 +36,15 @@ const DEFAULT_TIMEOUT_PRO_MS = 60 * 60 * 1000;
 const GPT_5_6_API_MODELS = new Set(["gpt-5.6", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"]);
 const REASONING_EFFORTS = new Set(["none", "low", "medium", "high", "xhigh", "max"]);
 const REASONING_MODES = new Set(["standard", "pro"]);
+// Astra has a narrower effort range than the GPT-5.6 API family. Keep this
+// capability separate from GPT_5_6_API_MODELS so adding a model cannot
+// accidentally inherit a family's exact option set.
+const MODEL_REASONING_CAPABILITIES = new Map([
+    [
+        "gpt-6-astra",
+        { efforts: new Set(["low", "medium", "high", "xhigh", "max"]), modes: REASONING_MODES },
+    ],
+]);
 const defaultWait = (ms) => new Promise((resolve) => {
     setTimeout(resolve, ms);
 });
@@ -72,9 +81,13 @@ function runtimeKeySource({ route, providerMode, optionsApiKey, }) {
         return "XAI_API_KEY";
     return optionsApiKey ? "apiKey option" : route.keySource;
 }
-function validateReasoningOptions(options, route) {
+function validateReasoningOptions(options, route, modelConfig) {
     const { reasoningEffort, reasoningMode } = options;
-    if (!reasoningEffort && !reasoningMode)
+    const capabilities = GPT_5_6_API_MODELS.has(options.model)
+        ? { efforts: REASONING_EFFORTS, modes: REASONING_MODES }
+        : MODEL_REASONING_CAPABILITIES.get(options.model);
+    const effectiveEffort = reasoningEffort ?? modelConfig?.reasoning?.effort;
+    if (!reasoningEffort && !reasoningMode && !effectiveEffort)
         return;
     if (reasoningEffort && !REASONING_EFFORTS.has(reasoningEffort)) {
         throw new PromptValidationError(`Invalid reasoning effort "${reasoningEffort}". Expected none, low, medium, high, xhigh, or max.`, { model: options.model, reasoningEffort });
@@ -82,14 +95,20 @@ function validateReasoningOptions(options, route) {
     if (reasoningMode && !REASONING_MODES.has(reasoningMode)) {
         throw new PromptValidationError(`Invalid reasoning mode "${reasoningMode}". Expected standard or pro.`, { model: options.model, reasoningMode });
     }
-    if (!GPT_5_6_API_MODELS.has(options.model)) {
+    if ((reasoningEffort || reasoningMode) && !capabilities) {
         const option = reasoningMode
             ? `Reasoning mode "${reasoningMode}"`
             : `Reasoning effort "${reasoningEffort}"`;
         const guidance = reasoningMode
             ? `Use --model gpt-5.6-sol --reasoning-mode ${reasoningMode}.`
             : `Use --model gpt-5.6-sol --reasoning-effort ${reasoningEffort}.`;
-        throw new PromptValidationError(`${option} is available only for GPT-5.6 API models. ${guidance}`, { model: options.model, reasoningEffort, reasoningMode });
+        throw new PromptValidationError(`${option} is available only for GPT-5.6 or GPT-6 Astra API models. ${guidance}`, { model: options.model, reasoningEffort, reasoningMode });
+    }
+    if (effectiveEffort && capabilities && !capabilities.efforts.has(effectiveEffort)) {
+        throw new PromptValidationError(`Reasoning effort "${effectiveEffort}" is not supported for ${options.model}. Expected low, medium, high, xhigh, or max.`, { model: options.model, reasoningEffort: effectiveEffort, reasoningMode });
+    }
+    if (reasoningMode && capabilities && !capabilities.modes.has(reasoningMode)) {
+        throw new PromptValidationError(`Reasoning mode "${reasoningMode}" is not supported for ${options.model}. Expected standard or pro.`, { model: options.model, reasoningEffort, reasoningMode });
     }
     if (reasoningMode &&
         !route.isAzureOpenAI &&
@@ -166,6 +185,10 @@ export async function runOracle(options, deps = {}) {
         openRouterApiKey: resolverOpenRouterApiKey,
         modelOverrides: options.modelOverrides,
     });
+    // Validate the resolved default as well as explicit flags. This catches a
+    // model override such as Astra + reasoning.effort=none, while allowing an
+    // explicit supported effort to replace an invalid bundled/overridden default.
+    validateReasoningOptions(options, route, modelConfig);
     const isLongRunningModel = isProTierModel;
     const supportsBackground = modelConfig.supportsBackground !== false;
     const useBackground = supportsBackground ? (options.background ?? isLongRunningModel) : false;

package/dist/src/remote/client.js

@@ -13,6 +13,9 @@ import { BrowserRunCancelledError } from "../oracle/errors.js";
 export function createRemoteBrowserExecutor({ host, token }) {
     // Return a drop-in replacement for runBrowserMode so the browser session runner can stay unchanged.
     return async function remoteBrowserExecutor(options) {
+        if (options.config?.researchMode === "search") {
+            throw new Error("Web Search is a local browser pilot; --remote-host does not negotiate this capability yet. Use local Chrome or --browser-attach-running.");
+        }
         const callerSignal = options.signal;
         if (callerSignal?.aborted)
             throw new BrowserRunCancelledError("Browser run cancelled before the request was sent.");

package/dist/src/remote/server.js

@@ -814,10 +814,12 @@ function sanitizeResult(result, warnings = []) {
         answerChars: result.answerChars,
         modelSelection: result.modelSelection,
         thinkingSelection: result.thinkingSelection,
+        researchPlan: result.researchPlan,
         archive: result.archive,
         tabUrl: result.tabUrl,
         conversationId: result.conversationId,
         promptSubmitted: result.promptSubmitted,
+        submittedPromptHash: result.submittedPromptHash,
         warnings: warnings.length > 0 ? warnings : undefined,
         chromePid: undefined,
         chromePort: undefined,

package/dist/src/sessionManager.js

@@ -304,7 +304,14 @@ export async function initializeSession(options, cwd, notifications, baseSlugOve
         })),
         cwd,
         mode,
-        browser: browserConfig ? { config: browserConfig } : undefined,
+        browser: mode === "browser"
+            ? {
+                ...(browserConfig ? { config: browserConfig } : {}),
+                runtime: { submittedPromptHash: null },
+            }
+            : browserConfig
+                ? { config: browserConfig }
+                : undefined,
         notifications,
         options: {
             prompt: options.prompt,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steipete/oracle",
-  "version": "0.19.0",
+  "version": "0.20.1",
   "description": "CLI wrapper around OpenAI Responses API with GPT-5.6 Sol, GPT-5.6, GPT-5.5 Pro, GPT-5.5, GPT-5.4, GPT-5.2, GPT-5.1, and GPT-5.1 Codex high reasoning modes.",
   "keywords": [],
   "homepage": "https://askoracle.sh",
@@ -61,7 +61,7 @@
     "@google/genai": "^2.21.0",
     "@google/generative-ai": "^0.24.1",
     "@modelcontextprotocol/server": "^2.0.0",
-    "@steipete/sweet-cookie": "^0.4.2",
+    "@steipete/sweet-cookie": "^0.4.3",
     "chalk": "^6.0.0",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.34.0",
@@ -70,17 +70,17 @@
     "dotenv": "^17.4.2",
     "fast-glob": "^3.3.3",
     "gpt-tokenizer": "^4.0.0",
-    "inquirer": "14.2.1",
+    "inquirer": "14.2.2",
     "json5": "^2.2.3",
     "kleur": "^4.1.5",
     "markdansi": "0.3.3",
-    "openai": "^7.10.0",
+    "openai": "^7.13.0",
     "osc-progress": "^0.3.3",
     "qs": "^6.16.0",
     "shiki": "^4.4.3",
     "toasted-notifier": "^10.1.0",
-    "tokentally": "^0.1.4",
-    "zod": "^4.5.4"
+    "tokentally": "^0.1.6",
+    "zod": "^4.6.0"
   },
   "devDependencies": {
     "@anthropic-ai/tokenizer": "^0.0.4",
@@ -88,13 +88,13 @@
     "@modelcontextprotocol/sdk": "^1.30.0",
     "@types/chrome-remote-interface": "^0.34.0",
     "@types/inquirer": "^9.0.10",
-    "@types/node": "^26.4.1",
+    "@types/node": "^26.5.1",
     "@vitest/coverage-v8": "5.0.0",
-    "devtools-protocol": "0.0.1692173",
+    "devtools-protocol": "0.0.1694333",
     "es-toolkit": "^1.52.0",
     "esbuild": "^0.28.2",
-    "oxfmt": "0.66.0",
-    "oxlint": "^1.81.0",
+    "oxfmt": "0.67.0",
+    "oxlint": "^1.82.0",
     "puppeteer-core": "^25.10.0",
     "tsx": "^4.23.13",
     "typescript": "^7.0.2",