@steipete/oracle 0.14.0 → 0.14.1

package/dist/src/browser/chatgptImages.js

@@ -9,6 +9,33 @@ import { resolveSessionArtifactsDir } from "./artifacts.js";
 import { saveAssistantDownloadButtonArtifacts } from "./chatgptFiles.js";
 const GENERATED_IMAGE_WAIT_MIN_MS = 15_000;
 const GENERATED_IMAGE_WAIT_MAX_MS = 15 * 60_000;
+const CHATGPT_GENERATED_IMAGE_BASE_URL = "https://chatgpt.com/";
+function isAllowedChatGptHost(hostname) {
+    const value = hostname.toLowerCase();
+    return value === "chatgpt.com" || value === "chat.openai.com";
+}
+function normalizeGeneratedImageUrl(value) {
+    const raw = String(value ?? "").trim();
+    if (!raw)
+        return undefined;
+    let url;
+    try {
+        url = new URL(raw, CHATGPT_GENERATED_IMAGE_BASE_URL);
+    }
+    catch {
+        return undefined;
+    }
+    if (url.protocol !== "https:" || url.port || !isAllowedChatGptHost(url.hostname)) {
+        return undefined;
+    }
+    if (url.pathname !== "/backend-api/estuary/content") {
+        return undefined;
+    }
+    if (!(url.searchParams.get("id") ?? "").startsWith("file_")) {
+        return undefined;
+    }
+    return url.href;
+}
 function extractFileId(url) {
     try {
         return new URL(url).searchParams.get("id") ?? undefined;
@@ -41,8 +68,12 @@ function buildAssistantImageExpression(minTurnIndex) {
     const CONVERSATION_SELECTOR = ${conversationLiteral};
     const ASSISTANT_SELECTOR = ${assistantLiteral};
     const isGeneratedImage = (img) => {
-      const url = img?.src || '';
-      if (!url.includes('/backend-api/estuary/content?id=file_')) return false;
+      const url = new URL(img?.src || '', location.origin || 'https://chatgpt.com');
+      const host = url.hostname.toLowerCase();
+      if (url.protocol !== 'https:' || url.port) return false;
+      if (host !== 'chatgpt.com' && host !== 'chat.openai.com') return false;
+      if (url.pathname !== '/backend-api/estuary/content') return false;
+      if (!String(url.searchParams.get('id') || '').startsWith('file_')) return false;
       const alt = String(img.alt || '').toLowerCase();
       if (alt.includes('generated image')) return true;
       let node = img;
@@ -104,13 +135,16 @@ export async function readAssistantGeneratedImages(Runtime, minTurnIndex) {
     });
     const raw = Array.isArray(result?.value) ? result.value : [];
     const normalized = raw
-        .map((item) => ({
-        url: typeof item?.url === "string" ? item.url : "",
-        alt: typeof item?.alt === "string" ? item.alt : undefined,
-        width: typeof item?.width === "number" ? item.width : undefined,
-        height: typeof item?.height === "number" ? item.height : undefined,
-        fileId: typeof item?.url === "string" ? extractFileId(item.url) : undefined,
-    }))
+        .map((item) => {
+        const url = normalizeGeneratedImageUrl(typeof item?.url === "string" ? item.url : "");
+        return {
+            url: url ?? "",
+            alt: typeof item?.alt === "string" ? item.alt : undefined,
+            width: typeof item?.width === "number" ? item.width : undefined,
+            height: typeof item?.height === "number" ? item.height : undefined,
+            fileId: url ? extractFileId(url) : undefined,
+        };
+    })
         .filter((item) => item.url.length > 0);
     return dedupeImages(normalized);
 }
@@ -209,8 +243,51 @@ async function buildCookieHeader(Network) {
         .map((cookie) => `${cookie.name}=${cookie.value}`)
         .join("; ");
 }
+async function fetchGeneratedImageInBrowserContext(Runtime, url) {
+    const expression = `
+    (async () => {
+      const url = ${JSON.stringify(url)};
+      const response = await fetch(url, { credentials: 'include', redirect: 'follow' });
+      const contentType = response.headers.get('content-type') || '';
+      const buffer = await response.arrayBuffer();
+      const bytes = new Uint8Array(buffer);
+      let binary = '';
+      for (let index = 0; index < bytes.length; index += 0x8000) {
+        binary += String.fromCharCode(...bytes.slice(index, index + 0x8000));
+      }
+      return {
+        ok: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+        contentType,
+        finalUrl: response.url,
+        b64: btoa(binary),
+      };
+    })()
+  `;
+    const { result, exceptionDetails } = await Runtime.evaluate({
+        expression,
+        awaitPromise: true,
+        returnByValue: true,
+        timeout: 120_000,
+    });
+    if (exceptionDetails) {
+        throw new Error("browser-context fetch threw an exception");
+    }
+    const value = result?.value;
+    if (!value?.ok || typeof value.b64 !== "string") {
+        const status = typeof value?.status === "number" ? value.status : "unknown";
+        const statusText = typeof value?.statusText === "string" ? value.statusText : "";
+        throw new Error(`browser-context fetch failed: ${status} ${statusText}`.trim());
+    }
+    return {
+        buffer: Buffer.from(value.b64, "base64"),
+        contentType: typeof value.contentType === "string" ? value.contentType : null,
+        finalUrl: typeof value.finalUrl === "string" && value.finalUrl ? value.finalUrl : url,
+    };
+}
 export async function saveChatGptGeneratedImages(params) {
-    const { Network, images, outputPath, logger } = params;
+    const { Network, Runtime, images, outputPath, logger } = params;
     if (!images.length)
         return { saved: false, imageCount: 0, savedImages: [], errors: [] };
     const cookieHeader = await buildCookieHeader(Network);
@@ -228,20 +305,41 @@ export async function saveChatGptGeneratedImages(params) {
     for (let index = 0; index < images.length; index += 1) {
         const image = images[index];
         try {
-            const response = await fetch(image.url, {
-                headers: {
-                    cookie: cookieHeader,
-                    "user-agent": "Mozilla/5.0",
-                },
-                redirect: "follow",
-            });
-            if (!response.ok) {
-                throw new Error(`download failed: ${response.status} ${response.statusText}`);
+            const imageUrl = normalizeGeneratedImageUrl(image.url);
+            if (!imageUrl) {
+                throw new Error("rejected non-ChatGPT generated image URL");
+            }
+            let contentType = null;
+            let finalUrl = imageUrl;
+            let buffer;
+            try {
+                const response = await fetch(imageUrl, {
+                    headers: {
+                        cookie: cookieHeader,
+                        "user-agent": "Mozilla/5.0",
+                    },
+                    redirect: "follow",
+                });
+                if (!response.ok) {
+                    throw new Error(`download failed: ${response.status} ${response.statusText}`);
+                }
+                contentType = response.headers.get("content-type");
+                finalUrl = response.url;
+                buffer = Buffer.from(await response.arrayBuffer());
+            }
+            catch (downloadError) {
+                if (!Runtime) {
+                    throw downloadError;
+                }
+                const message = downloadError instanceof Error ? downloadError.message : String(downloadError);
+                logger?.(`[browser] ChatGPT generated image download failed via Node fetch; retrying in browser context (${image.fileId ?? imageUrl}: ${message}).`);
+                const browserFetch = await fetchGeneratedImageInBrowserContext(Runtime, imageUrl);
+                contentType = browserFetch.contentType;
+                finalUrl = browserFetch.finalUrl;
+                buffer = browserFetch.buffer;
             }
-            const contentType = response.headers.get("content-type");
             const extension = contentTypeToExtension(contentType);
             const targetPath = resolveSiblingImagePath(path.resolve(outputPath), index, extension);
-            const buffer = Buffer.from(await response.arrayBuffer());
             await fs.writeFile(targetPath, buffer);
             savedImages.push({
                 kind: "image",
@@ -249,9 +347,9 @@ export async function saveChatGptGeneratedImages(params) {
                 label: index === 0 ? "Generated image" : `Generated image ${index + 1}`,
                 mimeType: contentType ?? undefined,
                 sizeBytes: buffer.length,
-                sourceUrl: image.url,
-                url: image.url,
-                finalUrl: response.url,
+                sourceUrl: imageUrl,
+                url: imageUrl,
+                finalUrl,
                 alt: image.alt,
                 width: image.width,
                 height: image.height,
@@ -336,6 +434,7 @@ export async function collectGeneratedImageArtifacts(params) {
     let generatedImages = await readAssistantGeneratedImagesWithFallback(params.Runtime, params.minTurnIndex ?? undefined);
     let latestAnswerText = params.answerText;
     if (explicitTargetPath && generatedImages.length === 0) {
+        await params.checkBlockingUiWarning?.();
         const targetPath = path.resolve(explicitTargetPath);
         const buttonImages = await saveGeneratedImageButtonArtifacts({
             Browser: params.Browser,
@@ -352,6 +451,7 @@ export async function collectGeneratedImageArtifacts(params) {
         const deadline = Date.now() + resolveGeneratedImageWaitTimeoutMs(params.waitTimeoutMs);
         while (Date.now() < deadline) {
             await delay(1500);
+            await params.checkBlockingUiWarning?.();
             generatedImages = await readAssistantGeneratedImagesWithFallback(params.Runtime, params.minTurnIndex ?? undefined);
             if (generatedImages.length > 0) {
                 break;
@@ -363,6 +463,7 @@ export async function collectGeneratedImageArtifacts(params) {
             }
         }
         if (generatedImages.length === 0) {
+            await params.checkBlockingUiWarning?.();
             const delayedButtonImages = await saveGeneratedImageButtonArtifacts({
                 Browser: params.Browser,
                 Client: params.Client,
@@ -396,6 +497,7 @@ export async function collectGeneratedImageArtifacts(params) {
     }
     const saved = await saveChatGptGeneratedImages({
         Network: params.Network,
+        Runtime: params.Runtime,
         images: generatedImages,
         outputPath: targetPath,
         logger: params.logger,

package/dist/src/browser/index.js

@@ -240,20 +240,39 @@ function formatChatGptUiWarningType(type) {
             return "authentication/challenge";
     }
 }
-async function createAssistantTimeoutError(params) {
+async function createChatGptUiWarningError(params) {
     const [uiWarning] = await collectChatGptUiWarnings(params.Runtime);
-    if (!uiWarning) {
-        return new BrowserAutomationError("Assistant response timed out before completion; reattach later to capture the answer.", { stage: "assistant-timeout", runtime: params.runtime, diagnostics: params.diagnostics }, params.cause);
-    }
+    if (!uiWarning)
+        return null;
     params.logger(`[browser] ChatGPT UI warning detected (${uiWarning.type}): ${uiWarning.message}`);
-    return new BrowserAutomationError(`ChatGPT displayed a ${formatChatGptUiWarningType(uiWarning.type)} warning while waiting for the assistant: ${uiWarning.message}`, {
-        stage: "assistant-timeout",
+    return new BrowserAutomationError(`ChatGPT displayed a ${formatChatGptUiWarningType(uiWarning.type)} warning while waiting for ${params.waitTarget}: ${uiWarning.message}`, {
+        stage: params.stage,
         code: "chatgpt-ui-warning",
         uiWarning,
         runtime: params.runtime,
         diagnostics: params.diagnostics,
     }, params.cause);
 }
+async function throwChatGptUiWarningIfPresent(params) {
+    const error = await createChatGptUiWarningError(params);
+    if (error)
+        throw error;
+}
+async function createAssistantTimeoutError(params) {
+    const warningError = await createChatGptUiWarningError({
+        Runtime: params.Runtime,
+        logger: params.logger,
+        runtime: params.runtime,
+        stage: "assistant-timeout",
+        waitTarget: "the assistant",
+        diagnostics: params.diagnostics,
+        cause: params.cause,
+    });
+    if (!warningError) {
+        return new BrowserAutomationError("Assistant response timed out before completion; reattach later to capture the answer.", { stage: "assistant-timeout", runtime: params.runtime, diagnostics: params.diagnostics }, params.cause);
+    }
+    return warningError;
+}
 function listIgnoredRemoteChromeFlags(config) {
     return [
         config.headless ? "--browser-headless" : null,
@@ -334,7 +353,8 @@ function isImageOnlyUiChromeText(text) {
     return (normalized.length === 0 ||
         normalized === "edit" ||
         normalized === "stopped thinking" ||
-        normalized === "stopped thinking edit");
+        normalized === "stopped thinking edit" ||
+        /^thought for \d+(?:\.\d+)?\s*(?:s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours)\s+edit$/.test(normalized));
 }
 function normalizeBrowserFollowUpPrompts(values) {
     return (values ?? []).map((entry) => entry.trim()).filter(Boolean);
@@ -690,9 +710,10 @@ export async function runBrowserMode(options) {
             }
             else {
                 const strictTabIsolation = Boolean(manualLogin && reusedChrome);
+                const devtoolsRetries = manualLogin ? 6 : 0;
                 const connection = await connectWithNewTab(chrome.port, logger, config.url, chromeHost, {
                     fallbackToDefault: !strictTabIsolation,
-                    retries: strictTabIsolation ? 3 : 0,
+                    retries: devtoolsRetries,
                     retryDelayMs: 500,
                 });
                 client = connection.client;
@@ -1504,6 +1525,23 @@ export async function runBrowserMode(options) {
             outputPath: options.outputPath,
             answerText,
             waitTimeoutMs: options.config?.timeoutMs,
+            checkBlockingUiWarning: () => throwChatGptUiWarningIfPresent({
+                Runtime,
+                logger,
+                stage: "image-artifact-wait",
+                waitTarget: "generated image artifacts",
+                runtime: {
+                    chromePid: chrome.pid,
+                    chromePort: chrome.port,
+                    chromeHost,
+                    userDataDir,
+                    chromeTargetId: lastTargetId,
+                    tabUrl: lastUrl,
+                    conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                    promptSubmitted,
+                    controllerPid: process.pid,
+                },
+            }),
         });
         answerText = imageArtifacts.answerText || answerText;
         if (imageArtifacts.markdownSuffix) {
@@ -2616,6 +2654,23 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             outputPath: options.outputPath,
             answerText,
             waitTimeoutMs: options.config?.timeoutMs,
+            checkBlockingUiWarning: () => throwChatGptUiWarningIfPresent({
+                Runtime,
+                logger,
+                stage: "image-artifact-wait",
+                waitTarget: "generated image artifacts",
+                runtime: {
+                    chromePort: port,
+                    chromeHost: host,
+                    chromeBrowserWSEndpoint: browserWSEndpoint,
+                    chromeProfileRoot,
+                    chromeTargetId: remoteTargetId ?? undefined,
+                    tabUrl: lastUrl,
+                    conversationId: lastUrl ? extractConversationIdFromUrl(lastUrl) : undefined,
+                    promptSubmitted,
+                    controllerPid: process.pid,
+                },
+            }),
         });
         answerText = imageArtifacts.answerText || answerText;
         if (imageArtifacts.markdownSuffix) {

package/dist/src/browser/projectSourcesRunner.js

@@ -97,9 +97,10 @@ export async function runBrowserProjectSources(request) {
             preserveUserDataDir: manualLogin,
         });
         const strictTabIsolation = Boolean(manualLogin && reusedChrome);
+        const devtoolsRetries = manualLogin ? 6 : 0;
         const connection = await connectWithNewTab(chrome.port, logger, "about:blank", chromeHost, {
             fallbackToDefault: !strictTabIsolation,
-            retries: strictTabIsolation ? 3 : 0,
+            retries: devtoolsRetries,
             retryDelayMs: 500,
         });
         client = connection.client;

package/dist/src/browser/prompt.js

@@ -1,12 +1,14 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { readFiles, createFileSections, MODEL_CONFIGS, TOKENIZER_OPTIONS, formatFileSections, } from "../oracle.js";
+import { readFiles, createFileSections, FileValidationError, MODEL_CONFIGS, TOKENIZER_OPTIONS, formatFileSections, } from "../oracle.js";
 import { isKnownModel } from "../oracle/modelResolver.js";
 import { buildPromptMarkdown } from "../oracle/promptAssembly.js";
 import { buildAttachmentPlan } from "./policies.js";
 import { createStoredZip } from "./zipBundle.js";
 const DEFAULT_BROWSER_INLINE_CHAR_BUDGET = 60_000;
+const MAX_BROWSER_ATTACHMENTS = 10;
+const MAX_BROWSER_ZIP_BUNDLE_BYTES = 128 * 1024 * 1024;
 const MEDIA_EXTENSIONS = new Set([
     ".mp4",
     ".mov",
@@ -31,27 +33,95 @@ const MEDIA_EXTENSIONS = new Set([
     ".heif",
     ".pdf",
 ]);
+const ARCHIVE_EXTENSIONS = new Set([
+    ".7z",
+    ".aab",
+    ".apk",
+    ".br",
+    ".bz2",
+    ".cab",
+    ".crx",
+    ".deb",
+    ".dmg",
+    ".doc",
+    ".docx",
+    ".ear",
+    ".epub",
+    ".gz",
+    ".ipa",
+    ".iso",
+    ".jar",
+    ".lz",
+    ".lz4",
+    ".msi",
+    ".odp",
+    ".ods",
+    ".odt",
+    ".pkg",
+    ".ppt",
+    ".pptx",
+    ".rar",
+    ".rpm",
+    ".tar",
+    ".tgz",
+    ".war",
+    ".whl",
+    ".xls",
+    ".xlsx",
+    ".xz",
+    ".xpi",
+    ".zip",
+    ".zipx",
+    ".zst",
+]);
 export function isMediaFile(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     return MEDIA_EXTENSIONS.has(ext);
 }
+export function isRawUploadFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return MEDIA_EXTENSIONS.has(ext) || ARCHIVE_EXTENSIONS.has(ext);
+}
 function formatSectionsForBundle(sections, options = {}) {
     return formatFileSections(sections, {
         lineNumbers: options.lineNumbers ?? true,
         trailingNewline: true,
     });
 }
-async function writeBrowserBundle(sections, format) {
+function resolveBrowserBundleFormat(format, sources) {
+    if (format !== "auto") {
+        return format;
+    }
+    return sources.hasRawUploadFiles ? "zip" : "text";
+}
+function shouldWriteBrowserBundle(format, { attachmentCount, bundleRequested, textSourceCount, textPlanShouldBundle, }) {
+    if (format === "zip") {
+        return (textPlanShouldBundle ||
+            (bundleRequested && attachmentCount > 0) ||
+            attachmentCount > MAX_BROWSER_ATTACHMENTS);
+    }
+    return textSourceCount > 0 && (textPlanShouldBundle || attachmentCount > MAX_BROWSER_ATTACHMENTS);
+}
+function assertAttachmentCount(attachments, format) {
+    if (attachments.length <= MAX_BROWSER_ATTACHMENTS)
+        return;
+    throw new Error(`Browser upload has ${attachments.length} attachments after applying bundle format "${format}". Use --browser-bundle-format auto or zip to stay within the ${MAX_BROWSER_ATTACHMENTS}-attachment limit.`);
+}
+async function writeBrowserBundle(sections, sources, format) {
     const bundleDir = await fs.mkdtemp(path.join(os.tmpdir(), "oracle-browser-bundle-"));
     const tokenEstimateText = formatSectionsForBundle(sections, {
         lineNumbers: format === "text",
     });
     if (format === "zip") {
+        const totalSourceBytes = sources.reduce((total, source) => total + source.sizeBytes, 0);
+        if (totalSourceBytes > MAX_BROWSER_ZIP_BUNDLE_BYTES) {
+            throw new Error(`Browser ZIP bundle inputs exceed the ${MAX_BROWSER_ZIP_BUNDLE_BYTES}-byte in-memory limit.`);
+        }
         const bundlePath = path.join(bundleDir, "attachments-bundle.zip");
-        const buffer = createStoredZip(sections.map((section) => ({
-            path: section.displayPath,
-            content: section.content,
-        })));
+        const buffer = createStoredZip(await Promise.all(sources.map(async (source) => ({
+            path: source.displayPath,
+            content: await fs.readFile(source.absolutePath),
+        }))));
         await fs.writeFile(bundlePath, buffer);
         return {
             attachment: {
@@ -60,7 +130,7 @@ async function writeBrowserBundle(sections, format) {
                 sizeBytes: buffer.length,
                 generatedBundle: true,
             },
-            metadata: { originalCount: sections.length, bundlePath, format },
+            metadata: { originalCount: sources.length, bundlePath, format },
             tokenEstimateText,
         };
     }
@@ -81,11 +151,27 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
     const cwd = deps.cwd ?? process.cwd();
     const readFilesFn = deps.readFilesImpl ?? readFiles;
     const allFilePaths = runOptions.file ?? [];
-    const textFilePaths = allFilePaths.filter((f) => !isMediaFile(f));
-    const mediaFilePaths = allFilePaths.filter((f) => isMediaFile(f));
-    const mediaAttachments = await Promise.all(mediaFilePaths.map(async (filePath) => {
+    const discoveredFiles = allFilePaths.length > 0
+        ? await readFilesFn(allFilePaths, {
+            cwd,
+            maxFileSizeBytes: 0,
+            readContents: false,
+        })
+        : [];
+    const textFilePaths = discoveredFiles
+        .filter((file) => !isRawUploadFile(file.path))
+        .map((file) => file.path);
+    const rawUploadFiles = discoveredFiles.filter((file) => isRawUploadFile(file.path));
+    const maxFileSizeBytes = runOptions.maxFileSizeBytes;
+    const rawUploadAttachments = await Promise.all(rawUploadFiles.map(async ({ path: filePath }) => {
         const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
         const stats = await fs.stat(resolvedPath);
+        if (maxFileSizeBytes && stats.size > maxFileSizeBytes) {
+            throw new FileValidationError(`The following file exceeds the ${maxFileSizeBytes}-byte limit:\n- ${path.relative(cwd, resolvedPath) || resolvedPath} (${stats.size} bytes)`, {
+                files: [resolvedPath],
+                limitBytes: maxFileSizeBytes,
+            });
+        }
         return {
             path: resolvedPath,
             displayPath: path.relative(cwd, resolvedPath) || path.basename(resolvedPath),
@@ -105,7 +191,10 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
         ? "never"
         : (runOptions.browserAttachments ?? "auto");
     const bundleRequested = Boolean(runOptions.browserBundleFiles);
-    const bundleFormat = runOptions.browserBundleFormat ?? "text";
+    const bundleFormat = runOptions.browserBundleFormat ?? "auto";
+    if (attachmentsPolicy === "never" && rawUploadAttachments.length > 0) {
+        throw new FileValidationError("Raw or binary files cannot be pasted inline when browser attachments are disabled. Use --browser-attachments auto or always.", { files: rawUploadAttachments.map((attachment) => attachment.displayPath) });
+    }
     const inlinePlan = buildAttachmentPlan(sections, { inlineFiles: true, bundleRequested });
     const uploadPlan = buildAttachmentPlan(sections, { inlineFiles: false, bundleRequested });
     const baseComposerSections = [];
@@ -124,25 +213,47 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
             : inlineComposerText.length <= DEFAULT_BROWSER_INLINE_CHAR_BUDGET || sections.length === 0
                 ? inlinePlan
                 : uploadPlan;
-    const composerText = (selectedPlan.inlineBlock
+    const textBundleSources = sections.map((section) => ({
+        absolutePath: section.absolutePath,
+        displayPath: section.displayPath,
+        sizeBytes: Buffer.byteLength(section.content, "utf8"),
+    }));
+    const rawUploadBundleSources = rawUploadAttachments.map((attachment) => ({
+        absolutePath: attachment.path,
+        displayPath: attachment.displayPath,
+        sizeBytes: attachment.sizeBytes ?? 0,
+    }));
+    const allBundleSources = [...textBundleSources, ...rawUploadBundleSources];
+    const attachments = [...selectedPlan.attachments, ...rawUploadAttachments];
+    const resolvedBundleFormat = resolveBrowserBundleFormat(bundleFormat, {
+        hasRawUploadFiles: rawUploadAttachments.length > 0,
+    });
+    const shouldBundle = shouldWriteBrowserBundle(resolvedBundleFormat, {
+        attachmentCount: attachments.length,
+        bundleRequested,
+        textSourceCount: textBundleSources.length,
+        textPlanShouldBundle: selectedPlan.shouldBundle,
+    });
+    const composerText = (!shouldBundle && selectedPlan.inlineBlock
         ? [...baseComposerSections, selectedPlan.inlineBlock]
         : baseComposerSections)
         .filter(Boolean)
         .join("\n\n")
         .trim();
-    const attachments = [...selectedPlan.attachments, ...mediaAttachments];
-    const shouldBundle = selectedPlan.shouldBundle;
     let bundleText = null;
     let bundled = null;
     if (shouldBundle) {
-        const writtenBundle = await writeBrowserBundle(sections, bundleFormat);
+        const writtenBundle = await writeBrowserBundle(sections, resolvedBundleFormat === "zip" ? allBundleSources : textBundleSources, resolvedBundleFormat);
         bundleText = writtenBundle.tokenEstimateText;
         attachments.length = 0;
         attachments.push(writtenBundle.attachment);
-        attachments.push(...mediaAttachments);
+        if (resolvedBundleFormat === "text") {
+            attachments.push(...rawUploadAttachments);
+        }
         bundled = writtenBundle.metadata;
     }
-    const inlineFileCount = selectedPlan.inlineFileCount;
+    assertAttachmentCount(attachments, resolvedBundleFormat);
+    const inlineFileCount = shouldBundle ? 0 : selectedPlan.inlineFileCount;
     const modelConfig = isKnownModel(runOptions.model)
         ? MODEL_CONFIGS[runOptions.model]
         : MODEL_CONFIGS["gpt-5.1"];
@@ -167,15 +278,27 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
     let fallback = null;
     if (attachmentsPolicy === "auto" && selectedPlan.mode === "inline" && sections.length > 0) {
         const fallbackComposerText = baseComposerSections.join("\n\n").trim();
-        const fallbackAttachments = [...uploadPlan.attachments, ...mediaAttachments];
+        const fallbackAttachments = [...uploadPlan.attachments, ...rawUploadAttachments];
         let fallbackBundled = null;
-        if (uploadPlan.shouldBundle) {
-            const writtenBundle = await writeBrowserBundle(sections, bundleFormat);
+        const fallbackBundleFormat = resolveBrowserBundleFormat(bundleFormat, {
+            hasRawUploadFiles: rawUploadAttachments.length > 0,
+        });
+        const fallbackShouldBundle = shouldWriteBrowserBundle(fallbackBundleFormat, {
+            attachmentCount: fallbackAttachments.length,
+            bundleRequested,
+            textSourceCount: textBundleSources.length,
+            textPlanShouldBundle: uploadPlan.shouldBundle,
+        });
+        if (fallbackShouldBundle) {
+            const writtenBundle = await writeBrowserBundle(sections, fallbackBundleFormat === "zip" ? allBundleSources : textBundleSources, fallbackBundleFormat);
             fallbackAttachments.length = 0;
             fallbackAttachments.push(writtenBundle.attachment);
-            fallbackAttachments.push(...mediaAttachments);
+            if (fallbackBundleFormat === "text") {
+                fallbackAttachments.push(...rawUploadAttachments);
+            }
             fallbackBundled = writtenBundle.metadata;
         }
+        assertAttachmentCount(fallbackAttachments, fallbackBundleFormat);
         fallback = {
             composerText: fallbackComposerText,
             attachments: fallbackAttachments,
@@ -190,7 +313,13 @@ export async function assembleBrowserPrompt(runOptions, deps = {}) {
         inlineFileCount,
         tokenEstimateIncludesInlineFiles,
         attachmentsPolicy,
-        attachmentMode: selectedPlan.mode,
+        attachmentMode: shouldBundle
+            ? "bundle"
+            : attachments.length > 0
+                ? "upload"
+                : selectedPlan.mode === "bundle"
+                    ? "inline"
+                    : selectedPlan.mode,
         fallback,
         bundled,
     };

package/dist/src/cli/browserConfig.js

@@ -1,5 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { normalizeThinkingTimeLevel } from "../oracle/thinkingTime.js";
 import { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from "../browser/constants.js";
 import { normalizeChatgptUrl } from "../browser/utils.js";
 import { parseDuration } from "../duration.js";
@@ -153,7 +154,7 @@ export async function buildBrowserConfig(options) {
         allowCookieErrors: options.browserAllowCookieErrors ?? true,
         remoteChrome,
         browserTabRef: options.browserTab ?? undefined,
-        thinkingTime: options.browserThinkingTime,
+        thinkingTime: normalizeThinkingTimeLevel(options.browserThinkingTime) ?? undefined,
         researchMode: options.browserResearch === "deep" ? "deep" : "off",
         archiveConversations: options.browserArchive,
     };

package/dist/src/cli/browserDefaults.js

@@ -1,5 +1,6 @@
 import { CHATGPT_URL } from "../browser/constants.js";
 import { normalizeChatgptUrl } from "../browser/utils.js";
+import { normalizeThinkingTimeLevel } from "../oracle/thinkingTime.js";
 export function applyBrowserDefaultsFromConfig(options, config, getSource) {
     const browser = config.browser;
     if (!browser)
@@ -89,7 +90,7 @@ export function applyBrowserDefaultsFromConfig(options, config, getSource) {
         options.browserModelStrategy = browser.modelStrategy;
     }
     if (isUnset("browserThinkingTime") && browser.thinkingTime !== undefined) {
-        options.browserThinkingTime = browser.thinkingTime;
+        options.browserThinkingTime = normalizeThinkingTimeLevel(browser.thinkingTime) ?? undefined;
     }
     if (isUnset("browserResearch") && browser.researchMode !== undefined) {
         options.browserResearch = browser.researchMode;