@steipete/oracle 0.18.0 → 0.20.0

package/dist/src/cli/recoveredBrowserHarvest.js

@@ -0,0 +1,50 @@
+import fs from "node:fs/promises";
+import { sessionStore } from "../sessionStore.js";
+import { isRecoveredConversationHarvestReady } from "../browser/recoverConversation.js";
+import { hasOtherLiveBrowserController, matchesOwnedRecoveryTarget, retireRecoveredBrowserTarget, } from "../browser/recoveryTarget.js";
+import { extractConversationIdFromUrl } from "../browser/reattachHelpers.js";
+import { estimateTokenCount } from "../browser/utils.js";
+export async function completeOwnedBrowserHarvest(sessionId, harvested, integrity, logger) {
+    if (harvested.state !== "completed" ||
+        harvested.stopExists ||
+        integrity.status !== "matched" ||
+        integrity.explicitTarget)
+        return;
+    const metadata = await sessionStore.readSession(sessionId);
+    if (!metadata?.browser?.runtime?.ownedRecoveryTarget ||
+        !isRecoveredConversationHarvestReady(harvested))
+        return;
+    const runtime = metadata.browser?.runtime;
+    const capture = {
+        host: harvested.host ?? "",
+        port: harvested.port ?? 0,
+        targetId: harvested.targetId,
+        browserWSEndpoint: runtime?.chromeBrowserWSEndpoint,
+        conversationId: harvested.conversationId ?? extractConversationIdFromUrl(harvested.url),
+    };
+    if (hasOtherLiveBrowserController(metadata) || !matchesOwnedRecoveryTarget(metadata, capture))
+        return;
+    // Harvest previously persisted only a snippet/hash. Save the full answer before retirement.
+    const answer = harvested.lastAssistantMarkdown || harvested.lastAssistantText;
+    const paths = await sessionStore.getPaths(sessionId);
+    await fs.appendFile(paths.log, `[reattach] harvested assistant response from existing Chrome tab\nAnswer:\n${answer}\n`, "utf8");
+    const outputTokens = estimateTokenCount(answer);
+    const usage = { inputTokens: 0, outputTokens, reasoningTokens: 0, totalTokens: outputTokens };
+    if (metadata.model) {
+        await sessionStore.updateModelRun(sessionId, metadata.model, {
+            status: "completed",
+            completedAt: new Date().toISOString(),
+            usage,
+        });
+    }
+    await sessionStore.updateSession(sessionId, {
+        status: "completed",
+        completedAt: new Date().toISOString(),
+        usage,
+        errorMessage: undefined,
+        error: undefined,
+        transport: undefined,
+        response: { status: "completed" },
+    });
+    await retireRecoveredBrowserTarget(sessionId, capture, logger);
+}

package/dist/src/cli/runOptions.js

@@ -4,7 +4,7 @@ import { normalizeModelOption, inferModelFromLabel, resolveApiModel, normalizeBa
 import { resolveGeminiModelId } from "../oracle/gemini.js";
 import { resolveOverriddenApiModel } from "../oracle/modelResolver.js";
 import { PromptValidationError } from "../oracle/errors.js";
-import { normalizeChatGptModelForBrowser } from "./browserConfig.js";
+import { normalizeChatGptModelForBrowser, isGpt6ProAlias } 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, }) {
@@ -24,7 +24,10 @@ export function resolveRunOptionsFromConfig({ prompt, files = [], model, models,
         .map((entry) => normalizeModelOption(entry))
         .filter(Boolean);
     const cliModelArg = normalizeModelOption(model ?? userConfig?.model) || DEFAULT_MODEL;
-    const apiModel = resolveApiModel(cliModelArg);
+    const isGpt6Pro = isGpt6ProAlias(cliModelArg);
+    const apiModel = isGpt6Pro && (resolvedEngine === "browser" || browserEngineRequested)
+        ? "gpt-6-pro"
+        : resolveApiModel(cliModelArg);
     // Browser label inference is intentionally engine-scoped: API model ids such as
     // gpt-5.6-luna must remain provider values even though browser mode rejects
     // unrecognized GPT-5.6 picker variants.
@@ -36,9 +39,11 @@ export function resolveRunOptionsFromConfig({ prompt, files = [], model, models,
     const isGrok = apiModel.startsWith("grok");
     const engineWasBrowser = resolvedEngine === "browser";
     const allModels = normalizedRequestedModels.length > 0
-        ? Array.from(new Set(normalizedRequestedModels.map((entry) => resolveApiModel(entry))))
+        ? Array.from(new Set(normalizedRequestedModels.map((entry) => isGpt6ProAlias(entry) && (resolvedEngine === "browser" || browserEngineRequested)
+            ? "gpt-6-pro"
+            : resolveApiModel(entry))))
         : [apiModel];
-    const browserCompatibilityModels = normalizedRequestedModels.length > 0 ? allModels : [browserModel];
+    const browserCompatibilityModels = normalizedRequestedModels.length > 0 ? allModels : [browserModel ?? apiModel];
     const isBrowserCompatible = (m) => m.startsWith("gpt-") || m.startsWith("gemini");
     const hasNonBrowserCompatibleTarget = browserEngineRequested && browserCompatibilityModels.some((m) => !isBrowserCompatible(m));
     if (hasNonBrowserCompatibleTarget) {
@@ -52,6 +57,16 @@ export function resolveRunOptionsFromConfig({ prompt, files = [], model, models,
     const fixedEngine = isCodex || isClaude || isGrok || azureAutoApi || normalizedRequestedModels.length > 0
         ? "api"
         : resolvedEngine;
+    if (fixedEngine === "api") {
+        if (isGpt6ProAlias(cliModelArg)) {
+            resolveApiModel(cliModelArg);
+        }
+        for (const entry of normalizedRequestedModels) {
+            if (isGpt6ProAlias(entry)) {
+                resolveApiModel(entry);
+            }
+        }
+    }
     // Browser runs use ChatGPT picker labels/aliases; API runs must keep API model ids intact.
     const resolvedModel = fixedEngine === "browser" ? browserModel : apiModel;
     const promptWithSuffix = userConfig?.promptSuffix && userConfig.promptSuffix.trim().length > 0

package/dist/src/cli/serveBrowserConfig.js

@@ -0,0 +1,24 @@
+import { resolveBrowserApprovalWait } from "../browser/config.js";
+import { parseRemoteChromeTarget } from "./browserConfig.js";
+import { applyBrowserDefaultsFromConfig } from "./browserDefaults.js";
+export function buildServeBrowserConfig(options, config) {
+    const flags = {
+        browserAttachRunning: options.browserAttachRunning,
+        remoteChrome: options.remoteChrome,
+        browserApprovalWait: options.browserApprovalWait ??
+            (process.env.ORACLE_BROWSER_APPROVAL_WAIT?.trim() || undefined),
+    };
+    const browser = config.browser;
+    applyBrowserDefaultsFromConfig(flags, {
+        browser: {
+            attachRunning: browser?.attachRunning,
+            remoteChrome: browser?.remoteChrome,
+            approvalWaitMs: browser?.approvalWaitMs,
+        },
+    }, (key) => (flags[key] === undefined ? undefined : "cli"));
+    return {
+        attachRunning: flags.browserAttachRunning ?? false,
+        remoteChrome: flags.remoteChrome ? parseRemoteChromeTarget(flags.remoteChrome) : null,
+        approvalWaitMs: resolveBrowserApprovalWait(flags.browserApprovalWait),
+    };
+}

package/dist/src/cli/sessionDisplay.js

@@ -6,13 +6,14 @@ import { formatFinishLine } from "../oracle/finishLine.js";
 import { sessionStore, wait } from "../sessionStore.js";
 import { formatTokenCount, formatTokenValue } from "../oracle/runUtils.js";
 import { resumeBrowserSession } from "../browser/reattach.js";
+import { retireRecoveredBrowserTarget } from "../browser/recoveryTarget.js";
 import { hasRecoverableChatGptConversation } from "../browser/reattachability.js";
 import { appendArtifacts, saveBrowserTranscriptArtifact, saveDeepResearchReportArtifact, } from "../browser/artifacts.js";
 import { estimateTokenCount } from "../browser/utils.js";
 import { formatSessionTableHeader, formatSessionTableRow, resolveSessionCost, } from "./sessionTable.js";
 import { abbreviateResponseId, buildResponseOwnerIndex, resolveSessionLineage, } from "./sessionLineage.js";
 import { formatSessionExecutionLabel } from "./sessionLifecycle.js";
-import { formatBrowserModelSelectionEvidence, formatSessionBrowserModelWithRequestedKey, resolveSessionBrowserModelDisplayName, } from "../browser/modelDisplay.js";
+import { formatBrowserModelSelectionEvidence, formatBrowserThinkingSelectionEvidence, formatSessionBrowserModelWithRequestedKey, resolveSessionBrowserModelDisplayName, } from "../browser/modelDisplay.js";
 const isTty = () => Boolean(process.stdout.isTTY);
 const dim = (text) => (isTty() ? kleur.dim(text) : text);
 export const MAX_RENDER_BYTES = 200_000;
@@ -88,11 +89,8 @@ async function writeReattachAnswer(sessionId, result, replaceExistingLog) {
         await fs.writeFile(paths.log, `[reattach] replaced incomplete Deep Research capture from existing Chrome tab\nAnswer:\n${body}\n`, "utf8");
         return;
     }
-    const logWriter = sessionStore.createLogWriter(sessionId);
-    logWriter.logLine("[reattach] captured assistant response from existing Chrome tab");
-    logWriter.logLine("Answer:");
-    logWriter.logLine(body);
-    logWriter.stream.end();
+    const paths = await sessionStore.getPaths(sessionId);
+    await fs.appendFile(paths.log, `[reattach] captured assistant response from existing Chrome tab\nAnswer:\n${body}\n`, "utf8");
 }
 async function saveReattachBrowserArtifacts(sessionId, metadata, result) {
     const body = result.answerMarkdown || result.answerText;
@@ -255,6 +253,7 @@ export async function attachSession(sessionId, options) {
                     config: metadata.browser?.config,
                     runtime,
                     modelSelection: metadata.browser?.modelSelection,
+                    thinkingSelection: metadata.browser?.thinkingSelection,
                     warnings: metadata.browser?.warnings,
                 },
                 artifacts,
@@ -263,6 +262,7 @@ export async function attachSession(sessionId, options) {
                 transport: undefined,
             });
             console.log(chalk.green("Reattach succeeded; session marked completed."));
+            await retireRecoveredBrowserTarget(sessionId, result.captureTarget, (line) => console.log(dim(line)));
             metadata = (await sessionStore.readSession(sessionId)) ?? metadata;
         }
         catch (error) {
@@ -603,7 +603,9 @@ export function formatUserErrorMetadata(metadata) {
 }
 export function formatBrowserEvidence(metadata) {
     const browser = metadata.browser;
-    if (!browser?.modelSelection && (!browser?.warnings || browser.warnings.length === 0)) {
+    if (!browser?.modelSelection &&
+        !browser?.thinkingSelection &&
+        (!browser?.warnings || browser.warnings.length === 0)) {
         return null;
     }
     const lines = [];
@@ -611,6 +613,10 @@ export function formatBrowserEvidence(metadata) {
     if (evidence) {
         lines.push(`model ${formatBrowserModelSelectionEvidence(evidence, metadata.model)}`);
     }
+    const thinkingEvidence = browser.thinkingSelection;
+    if (thinkingEvidence) {
+        lines.push(`effort ${formatBrowserThinkingSelectionEvidence(thinkingEvidence)}`);
+    }
     for (const warning of browser.warnings ?? []) {
         lines.push(`warning ${warning.code}: ${warning.message}`);
     }

package/dist/src/cli/sessionRunner.js

@@ -1,4 +1,5 @@
 import kleur from "kleur";
+import { constants as fsConstants } from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { runOracle, OracleResponseError, OracleTransportError, extractResponseMetadata, asOracleUserError, extractTextOutput, classifyProviderFailure, } from "../oracle.js";
@@ -21,8 +22,10 @@ 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 { retireRecoveredBrowserTarget } from "../browser/recoveryTarget.js";
 import { hasRecoverableChatGptConversation } from "../browser/reattachability.js";
 import { estimateTokenCount } from "../browser/utils.js";
+import { computeFileSha256, sanitizeArtifactFilename } from "../browser/artifacts.js";
 import { formatElapsed } from "../oracle/format.js";
 import { formatBrowserReattachGuidance } from "./reattachGuidance.js";
 const isTty = process.stdout.isTTY;
@@ -78,7 +81,13 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 cwd,
                 log,
             }, runnerDeps);
-            await writeAssistantOutput(runOptions.writeOutputPath, result.answerText ?? "", log);
+            const writtenOutputPath = await writeAssistantOutput(runOptions.writeOutputPath, result.answerText ?? "", log);
+            const outputArtifacts = await copyBrowserOutputArtifacts({
+                outputPath: writtenOutputPath,
+                savedFiles: runOptions.writeArtifacts ? result.savedFiles : undefined,
+                log,
+            });
+            const browserWarnings = [...(result.warnings ?? []), ...outputArtifacts.warnings];
             await sendSessionNotification({
                 sessionId: sessionMeta.id,
                 sessionName: sessionMeta.options?.slug ?? sessionMeta.id,
@@ -105,9 +114,10 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                     runtime: result.runtime,
                     archive: result.archive,
                     modelSelection: result.modelSelection,
-                    warnings: result.warnings,
+                    thinkingSelection: result.thinkingSelection,
+                    warnings: browserWarnings.length > 0 ? browserWarnings : undefined,
                 },
-                artifacts: mergeArtifacts(sessionMeta.artifacts, result.artifacts),
+                artifacts: mergeArtifacts(sessionMeta.artifacts, mergeArtifacts(result.artifacts, outputArtifacts.artifacts)),
                 response: undefined,
                 transport: undefined,
                 error: undefined,
@@ -848,6 +858,81 @@ function resolveSessionPath(sessionDir, targetPath) {
     }
     return path.join(sessionDir, targetPath);
 }
+async function copyBrowserOutputArtifacts(params) {
+    const artifacts = [];
+    const warnings = [];
+    if (!params.outputPath || !params.savedFiles?.length) {
+        return { artifacts, warnings };
+    }
+    const outputDir = path.dirname(params.outputPath);
+    for (const savedFile of params.savedFiles) {
+        const filename = sanitizeArtifactFilename(savedFile.filename ?? path.basename(savedFile.path), "artifact.bin");
+        let copied;
+        try {
+            copied = await copyFileWithoutOverwrite(savedFile.path, path.join(outputDir, filename));
+            const [stat, sha256] = await Promise.all([fs.stat(copied), computeFileSha256(copied)]);
+            if (savedFile.sizeBytes != null && stat.size !== savedFile.sizeBytes) {
+                throw new Error(`size mismatch (expected ${savedFile.sizeBytes}, received ${stat.size})`);
+            }
+            if (savedFile.sha256 && sha256 !== savedFile.sha256) {
+                throw new Error(`sha256 mismatch (expected ${savedFile.sha256}, received ${sha256})`);
+            }
+            const artifact = {
+                kind: "file",
+                path: copied,
+                label: `${savedFile.label ?? filename} (write-output)`,
+                mimeType: savedFile.mimeType,
+                sizeBytes: stat.size,
+                sourceUrl: savedFile.sourceUrl,
+                sha256,
+                validation: savedFile.validation,
+                transfer: { status: "not-needed" },
+                origin: { mode: "local" },
+            };
+            artifacts.push(artifact);
+            params.log(dim(`[browser] Saved write-output file artifact to ${copied} sha256=${sha256}`));
+        }
+        catch (error) {
+            if (copied) {
+                await fs.unlink(copied).catch(() => undefined);
+            }
+            const reason = error instanceof Error ? error.message : String(error);
+            const message = `Failed to copy saved file artifact ${savedFile.path} beside ${params.outputPath}: ${reason}`;
+            params.log(dim(`[browser] ${message}`));
+            warnings.push({
+                code: "browser-output-artifact-copy-failed",
+                severity: "warning",
+                message,
+                details: {
+                    sourcePath: savedFile.path,
+                    outputPath: params.outputPath,
+                    sha256: savedFile.sha256,
+                },
+            });
+        }
+    }
+    return { artifacts, warnings };
+}
+async function copyFileWithoutOverwrite(sourcePath, baseTargetPath) {
+    const ext = path.extname(baseTargetPath);
+    const stem = ext ? path.basename(baseTargetPath, ext) : path.basename(baseTargetPath);
+    const dir = path.dirname(baseTargetPath);
+    let suffix = 1;
+    for (;;) {
+        const targetPath = suffix === 1 ? baseTargetPath : path.join(dir, `${stem}-${suffix}${ext}`);
+        try {
+            await fs.copyFile(sourcePath, targetPath, fsConstants.COPYFILE_EXCL);
+            return targetPath;
+        }
+        catch (error) {
+            if (isErrorCode(error, "EEXIST")) {
+                suffix += 1;
+                continue;
+            }
+            throw error;
+        }
+    }
+}
 async function writeAssistantOutput(targetPath, content, log) {
     if (!targetPath)
         return;
@@ -955,11 +1040,8 @@ 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();
+            const paths = await sessionStore.getPaths(sessionMeta.id);
+            await fs.appendFile(paths.log, `[auto-reattach] captured assistant response on attempt ${attempt}\nAnswer:\n${answerText}\n`, "utf8");
             if (modelForStatus) {
                 await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
                     status: "completed",
@@ -1005,6 +1087,7 @@ 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) {
@@ -1057,11 +1140,11 @@ export function deriveModelOutputPath(basePath, model) {
     const suffix = ext.length > 0 ? `${stem}.${model}${ext}` : `${stem}.${model}`;
     return path.join(dir, suffix);
 }
+function isErrorCode(error, expected) {
+    return error instanceof Error && error.code === expected;
+}
 function isPermissionError(error) {
-    if (!(error instanceof Error))
-        return false;
-    const code = error.code;
-    return code === "EACCES" || code === "EPERM";
+    return isErrorCode(error, "EACCES") || isErrorCode(error, "EPERM");
 }
 function buildFallbackPath(original) {
     const ext = path.extname(original);

package/dist/src/config.js

@@ -135,6 +135,7 @@ function sanitizeProjectConfig(config) {
             "attachRunning",
             "timeoutMs",
             "inputTimeoutMs",
+            "approvalWaitMs",
             "attachmentTimeoutMs",
             "assistantRecheckDelayMs",
             "assistantRecheckTimeoutMs",

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

@@ -1,7 +1,9 @@
+import { randomUUID } from "node:crypto";
 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";
+import { fetchGeminiWebResource } from "./http.js";
+import { buildGeminiWebModelHeader, FALLBACK_GEMINI_WEB_MODEL, getGeminiWebModelSelection, } from "./models.js";
+const USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36";
 const MODEL_HEADER_NAME = "x-goog-ext-525001261-jspb";
 const GEMINI_APP_URL = "https://gemini.google.com/app";
 const GEMINI_STREAM_GENERATE_URL = "https://gemini.google.com/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate";
@@ -61,7 +63,7 @@ function buildCookieHeader(cookieMap) {
 }
 export async function fetchGeminiAccessToken(cookieMap, signal) {
     const cookieHeader = buildCookieHeader(cookieMap);
-    const res = await fetch(GEMINI_APP_URL, {
+    const res = await fetchGeminiWebResource(GEMINI_APP_URL, {
         redirect: "follow",
         signal,
         headers: {
@@ -112,7 +114,7 @@ function ensureFullSizeImageUrl(url) {
 async function fetchWithCookiePreservingRedirects(url, init, signal, maxRedirects = 10) {
     let current = url;
     for (let i = 0; i <= maxRedirects; i += 1) {
-        const res = await fetch(current, { ...init, redirect: "manual", signal });
+        const res = await fetchGeminiWebResource(current, { ...init, redirect: "manual", signal });
         if (res.status >= 300 && res.status < 400) {
             const location = res.headers.get("location");
             if (!location)
@@ -146,7 +148,7 @@ async function uploadGeminiFile(filePath, signal) {
     const mimeType = resolveGeminiUploadMimeType(absPath);
     const form = new FormData();
     form.append("file", new Blob([data], { type: mimeType }), fileName);
-    const res = await fetch(GEMINI_UPLOAD_URL, {
+    const res = await fetchGeminiWebResource(GEMINI_UPLOAD_URL, {
         method: "POST",
         redirect: "follow",
         signal,
@@ -162,18 +164,38 @@ async function uploadGeminiFile(filePath, signal) {
     }
     return { id: text, name: fileName, mimeType };
 }
-function buildGeminiFReqPayload(prompt, uploaded, chatMetadata) {
-    const promptPayload = uploaded.length > 0
-        ? [
-            prompt,
-            0,
-            null,
-            // Format: [[[fileId, 1, null, "mimeType"], "filename", ...]]
-            uploaded.map((file) => [[file.id, 1, null, file.mimeType], file.name]),
-        ]
-        : [prompt];
-    const innerList = [promptPayload, null, chatMetadata ?? null];
-    return JSON.stringify([null, JSON.stringify(innerList)]);
+function buildGeminiFReqPayload(prompt, uploaded, chatMetadata, model, requestId) {
+    const request = Array(97).fill(null);
+    request[0] = [
+        prompt,
+        0,
+        null,
+        uploaded.map((file) => [[file.id, 1, null, file.mimeType], file.name]),
+        null,
+        null,
+        0,
+    ];
+    request[1] = ["en"];
+    request[2] = chatMetadata ?? ["", "", "", null, null, null, null, null, null, ""];
+    request[6] = [1];
+    request[7] = 1;
+    request[10] = 1;
+    request[11] = 0;
+    request[17] = [[0]];
+    request[18] = 0;
+    request[27] = 1;
+    request[30] = [4];
+    request[41] = [1];
+    request[53] = 0;
+    request[59] = requestId;
+    request[61] = [];
+    request[68] = 2;
+    const selection = getGeminiWebModelSelection(model);
+    request[79] = selection.modelCode;
+    request[80] = selection.thinkingCode;
+    request[91] = 0;
+    request[96] = chatMetadata == null ? 1 : 0;
+    return JSON.stringify([null, JSON.stringify(request)]);
 }
 export function parseGeminiStreamGenerateResponse(rawText) {
     const responseJson = JSON.parse(trimGeminiJsonEnvelope(rawText));
@@ -274,11 +296,12 @@ export async function runGeminiWebOnce(input) {
         }
         uploaded.push(await uploadGeminiFile(file, input.signal));
     }
-    const fReq = buildGeminiFReqPayload(input.prompt, uploaded, input.chatMetadata ?? null);
+    const requestId = randomUUID().toUpperCase();
+    const fReq = buildGeminiFReqPayload(input.prompt, uploaded, input.chatMetadata ?? null, input.model, requestId);
     const params = new URLSearchParams();
     params.set("at", at);
     params.set("f.req", fReq);
-    const res = await fetch(GEMINI_STREAM_GENERATE_URL, {
+    const res = await fetchGeminiWebResource(GEMINI_STREAM_GENERATE_URL, {
         method: "POST",
         redirect: "follow",
         signal: input.signal,
@@ -290,6 +313,9 @@ export async function runGeminiWebOnce(input) {
             "user-agent": USER_AGENT,
             cookie: cookieHeader,
             [MODEL_HEADER_NAME]: buildGeminiWebModelHeader(input.model),
+            "x-goog-ext-73010989-jspb": "[0]",
+            "x-goog-ext-73010990-jspb": "[0]",
+            "x-goog-ext-525005358-jspb": JSON.stringify([requestId, 1]),
         },
         body: params.toString(),
     });
@@ -338,10 +364,30 @@ export async function runGeminiWebOnce(input) {
 export async function runGeminiWebWithFallback(input) {
     const attempt = await runGeminiWebOnce(input);
     if (isGeminiModelUnavailable(attempt.errorCode) && input.model !== FALLBACK_GEMINI_WEB_MODEL) {
+        if (input.allowModelFallback === false) {
+            throw new Error(`Requested Gemini web model ${input.model} is unavailable and model fallback is disabled.`);
+        }
         const fallback = await runGeminiWebOnce({ ...input, model: FALLBACK_GEMINI_WEB_MODEL });
-        return { ...fallback, effectiveModel: FALLBACK_GEMINI_WEB_MODEL };
+        return {
+            ...assertGeminiWebRunSucceeded(fallback),
+            effectiveModel: FALLBACK_GEMINI_WEB_MODEL,
+        };
+    }
+    return { ...assertGeminiWebRunSucceeded(attempt), effectiveModel: input.model };
+}
+function assertGeminiWebRunSucceeded(output) {
+    if (output.errorCode !== undefined) {
+        throw new Error(`Gemini web request failed with error code ${output.errorCode}.`);
+    }
+    if (output.errorMessage) {
+        throw new Error(`Gemini web request failed: ${output.errorMessage}`);
+    }
+    if (!output.text.trim() &&
+        output.images.length === 0 &&
+        extractGgdlUrls(output.rawResponseText).length === 0) {
+        throw new Error("Gemini web request ended without a response.");
     }
-    return { ...attempt, effectiveModel: input.model };
+    return output;
 }
 export async function saveFirstGeminiImageFromOutput(output, cookieMap, outputPath, signal) {
     const generatedOrWeb = output.images.find((img) => img.kind === "generated") ?? output.images[0];

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

@@ -325,6 +325,7 @@ export function createGeminiWebExecutor(geminiOptions) {
                             cookieMap: cookieResult.cookieMap,
                             chatMetadata: null,
                             signal: controller.signal,
+                            allowModelFallback: geminiOptions.allowModelFallback,
                         });
                         const editPrompt = `Use image generation tool to ${prompt}`;
                         const out = await runGeminiWebWithFallback({
@@ -334,6 +335,7 @@ export function createGeminiWebExecutor(geminiOptions) {
                             cookieMap: cookieResult.cookieMap,
                             chatMetadata: intro.metadata,
                             signal: controller.signal,
+                            allowModelFallback: geminiOptions.allowModelFallback,
                         });
                         response = {
                             text: out.text ?? null,
@@ -357,6 +359,7 @@ export function createGeminiWebExecutor(geminiOptions) {
                             cookieMap: cookieResult.cookieMap,
                             chatMetadata: null,
                             signal: controller.signal,
+                            allowModelFallback: geminiOptions.allowModelFallback,
                         });
                         response = {
                             text: out.text ?? null,
@@ -379,6 +382,7 @@ export function createGeminiWebExecutor(geminiOptions) {
                             cookieMap: cookieResult.cookieMap,
                             chatMetadata: null,
                             signal: controller.signal,
+                            allowModelFallback: geminiOptions.allowModelFallback,
                         });
                         response = {
                             text: out.text ?? null,

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

@@ -0,0 +1,15 @@
+export async function fetchGeminiWebResource(url, init = {}) {
+    try {
+        return await fetch(url, init);
+    }
+    catch (error) {
+        const cause = error instanceof Error ? error.cause : undefined;
+        if (cause &&
+            typeof cause === "object" &&
+            "code" in cause &&
+            cause.code === "UND_ERR_HEADERS_OVERFLOW") {
+            throw new Error("Gemini response headers exceed Node's configured limit. Start Oracle with NODE_OPTIONS=--max-http-header-size=65536 (preserving any existing Node options) and retry.", { cause: error });
+        }
+        throw error;
+    }
+}

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

@@ -6,29 +6,29 @@ const MODEL_SPECS = {
         hash: "1d44b34bcaa1c04d",
         modelCode: 6,
         thinkingCode: 1,
+        capacity: 2,
     },
     "gemini-3.5-flash": {
         hash: "56fdd199312815e2",
         modelCode: 1,
         thinkingCode: 1,
+        capacity: 2,
     },
     "gemini-3.1-pro": {
-        hash: "797f3d0293f288ad",
+        hash: "e6fa609c3fa255c0",
         modelCode: 3,
         thinkingCode: 1,
+        capacity: 2,
     },
     "gemini-3-pro-deep-think": {
-        hash: "797f3d0293f288ad",
-        modelCode: 3,
-        thinkingCode: 3,
+        hash: "e051ce1aa80aa576",
+        modelCode: 5,
+        thinkingCode: 2,
+        capacity: 2,
     },
 };
-let clientId;
-function getGeminiWebClientId() {
-    clientId ??= randomUUID().toUpperCase();
-    return clientId;
-}
-export function buildGeminiWebModelHeader(model, webClientId = getGeminiWebClientId()) {
+const clientId = randomUUID().toUpperCase();
+export function buildGeminiWebModelHeader(model, webClientId = clientId) {
     const spec = MODEL_SPECS[model];
     return JSON.stringify([
         1,
@@ -42,7 +42,7 @@ export function buildGeminiWebModelHeader(model, webClientId = getGeminiWebClien
         [4, 5, 6, 8],
         null,
         null,
-        3,
+        spec.capacity,
         null,
         null,
         spec.modelCode,
@@ -50,6 +50,10 @@ export function buildGeminiWebModelHeader(model, webClientId = getGeminiWebClien
         webClientId,
     ]);
 }
+export function getGeminiWebModelSelection(model) {
+    const { modelCode, thinkingCode } = MODEL_SPECS[model];
+    return { modelCode, thinkingCode };
+}
 export function resolveGeminiWebModel(desiredModel, log) {
     const desired = typeof desiredModel === "string" ? desiredModel.trim() : "";
     if (!desired)