@steipete/oracle 0.17.3 → 0.19.0

package/dist/src/browser/sessionRunner.js

@@ -2,10 +2,11 @@ import chalk from "chalk";
 import { formatTokenCount } from "../oracle/runUtils.js";
 import { formatFinishLine } from "../oracle/finishLine.js";
 import { runBrowserMode } from "../browserMode.js";
-import { assembleBrowserPrompt } from "./prompt.js";
+import { DEFAULT_BROWSER_CONFIG } from "./config.js";
+import { assembleBrowserPrompt, cleanupGeneratedBrowserBundles, materializeBrowserFallback, } from "./prompt.js";
 import { BrowserAutomationError } from "../oracle/errors.js";
 import { appendArtifacts, saveBrowserTranscriptArtifact, saveDeepResearchReportArtifact, } from "./artifacts.js";
-import { formatBrowserModelSelectionEvidence, formatBrowserModelTarget, resolveBrowserModelDisplayName, } from "./modelDisplay.js";
+import { formatBrowserModelSelectionEvidence, formatBrowserThinkingSelectionEvidence, formatBrowserModelTarget, resolveBrowserModelDisplayName, } from "./modelDisplay.js";
 const LARGE_PRO_FAST_INPUT_TOKEN_THRESHOLD = 25_000;
 const LARGE_PRO_FAST_ELAPSED_MS_THRESHOLD = 120_000;
 function buildUnavailableModelSelectionEvidence(browserConfig) {
@@ -57,7 +58,50 @@ function buildBrowserRunWarnings(args) {
 export async function runBrowserSessionExecution({ runOptions, browserConfig, cwd, log }, deps = {}) {
     const assemblePrompt = deps.assemblePrompt ?? assembleBrowserPrompt;
     const executeBrowser = deps.executeBrowser ?? runBrowserMode;
-    const promptArtifacts = await assemblePrompt(runOptions, { cwd });
+    const persistRuntimeHint = deps.persistRuntimeHint ?? (() => { });
+    const inputTimeoutMs = browserConfig.inputTimeoutMs ?? DEFAULT_BROWSER_CONFIG.inputTimeoutMs;
+    let preparationTimedOut = false;
+    let preparationTimeout;
+    let promptArtifacts;
+    try {
+        promptArtifacts = await Promise.race([
+            assemblePrompt(runOptions, { cwd }).then(async (artifacts) => {
+                if (preparationTimedOut)
+                    await cleanupGeneratedBrowserBundles(artifacts);
+                return artifacts;
+            }),
+            new Promise((_, reject) => {
+                preparationTimeout = setTimeout(() => {
+                    preparationTimedOut = true;
+                    reject(new BrowserAutomationError(`Browser prompt preparation timed out after ${inputTimeoutMs}ms; increase --browser-input-timeout if local files need more time.`, {
+                        stage: "prepare-prompt",
+                        code: "prompt-preparation-timeout",
+                        timeoutMs: inputTimeoutMs,
+                    }));
+                }, inputTimeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (preparationTimeout) {
+            clearTimeout(preparationTimeout);
+        }
+    }
+    try {
+        return await executeAssembledBrowserSession({
+            runOptions,
+            browserConfig,
+            log,
+            promptArtifacts,
+            executeBrowser,
+            persistRuntimeHint,
+        });
+    }
+    finally {
+        await cleanupGeneratedBrowserBundles(promptArtifacts);
+    }
+}
+async function executeAssembledBrowserSession({ runOptions, browserConfig, log, promptArtifacts, executeBrowser, persistRuntimeHint, }) {
     if (runOptions.verbose) {
         log(chalk.dim(`[verbose] Browser config: ${JSON.stringify({
             ...browserConfig,
@@ -91,7 +135,7 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
         if (typeof message !== "string")
             return;
         const shouldAlwaysPrint = message.startsWith("[browser] ") &&
-            /archive|fallback|follow-up|retry|thinking|waiting for chatgpt|browser slot|browser control|browser guidance|model selection|model picker/i.test(message);
+            /archive|fallback|follow-up|retry|thinking|waiting for chatgpt|remote debugging approval|browser slot|browser control|browser guidance|model selection|model picker/i.test(message);
         if (!runOptions.verbose && !shouldAlwaysPrint)
             return;
         log(message);
@@ -103,7 +147,22 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
     if (runOptions.verbose) {
         log(chalk.dim("Chrome automation does not stream output; this may take a minute..."));
     }
-    const persistRuntimeHint = deps.persistRuntimeHint ?? (() => { });
+    let fallbackSubmission = undefined;
+    if (promptArtifacts.fallback) {
+        fallbackSubmission = {
+            prompt: promptArtifacts.fallback.composerText,
+            attachments: promptArtifacts.fallback.attachments,
+            pendingBundle: promptArtifacts.fallback.pendingBundle ?? undefined,
+            prepare: async () => {
+                const prepared = await materializeBrowserFallback(promptArtifacts);
+                if (!prepared || !fallbackSubmission)
+                    return;
+                fallbackSubmission.prompt = prepared.composerText;
+                fallbackSubmission.attachments = prepared.attachments;
+                fallbackSubmission.pendingBundle = undefined;
+            },
+        };
+    }
     const executionBrowserConfig = runOptions.browserResumeConversationUrl
         ? { ...browserConfig, resumeConversationUrl: runOptions.browserResumeConversationUrl }
         : browserConfig;
@@ -112,12 +171,7 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
         browserResult = await executeBrowser({
             prompt: promptArtifacts.composerText,
             attachments: promptArtifacts.attachments,
-            fallbackSubmission: promptArtifacts.fallback
-                ? {
-                    prompt: promptArtifacts.fallback.composerText,
-                    attachments: promptArtifacts.fallback.attachments,
-                }
-                : undefined,
+            fallbackSubmission,
             config: executionBrowserConfig,
             log: automationLogger,
             heartbeatIntervalMs: runOptions.heartbeatIntervalMs,
@@ -151,6 +205,10 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
     if (modelSelection) {
         log(`[browser] Model selection evidence: ${formatBrowserModelSelectionEvidence(modelSelection, runOptions.model)}`);
     }
+    const thinkingSelection = browserResult.thinkingSelection;
+    if (thinkingSelection) {
+        log(`[browser] Thinking effort evidence: ${formatBrowserThinkingSelectionEvidence(thinkingSelection)}`);
+    }
     const warnings = buildBrowserRunWarnings({
         runOptions,
         browserConfig,
@@ -227,9 +285,11 @@ export async function runBrowserSessionExecution({ runOptions, browserConfig, cw
         },
         archive: browserResult.archive,
         modelSelection,
+        thinkingSelection,
         warnings,
         answerText,
         artifacts: savedArtifacts,
+        savedFiles: browserResult.savedFiles,
     };
 }
 export async function ensureSessionArtifacts(params) {