@steipete/oracle 0.8.6 → 0.9.0

package/dist/src/cli/options.js

@@ -152,11 +152,20 @@ export function parseDurationOption(value, label) {
     }
     return parsed;
 }
+function isGeminiDeepThinkAlias(normalized) {
+    return ((normalized.includes('gemini') && normalized.includes('deep')) ||
+        normalized.includes('deep-think') ||
+        normalized.includes('deep_think') ||
+        normalized.includes('deepthink'));
+}
 export function resolveApiModel(modelValue) {
     const normalized = normalizeModelOption(modelValue).toLowerCase();
     if (normalized in MODEL_CONFIGS) {
         return normalized;
     }
+    if (normalized.includes('/')) {
+        return normalized;
+    }
     if (normalized.includes('grok')) {
         return 'grok-4.1';
     }
@@ -166,6 +175,12 @@ export function resolveApiModel(modelValue) {
     if (normalized.includes('claude') && normalized.includes('opus')) {
         return 'claude-4.1-opus';
     }
+    if (normalized.includes('5.4') && normalized.includes('pro')) {
+        return 'gpt-5.4-pro';
+    }
+    if (normalized.includes('5.4')) {
+        return 'gpt-5.4';
+    }
     if (normalized === 'claude' || normalized === 'sonnet' || /(^|\b)sonnet(\b|$)/.test(normalized)) {
         return 'claude-4.5-sonnet';
     }
@@ -190,11 +205,17 @@ export function resolveApiModel(modelValue) {
         }
         return 'gpt-5.1-codex';
     }
+    if (isGeminiDeepThinkAlias(normalized)) {
+        throw new InvalidArgumentError('Gemini Deep Think is browser-only today. Use --engine browser --model gemini-3-deep-think.');
+    }
     if (normalized.includes('gemini')) {
+        if (normalized.includes('3.1') || normalized.includes('3_1')) {
+            return 'gemini-3.1-pro';
+        }
         return 'gemini-3-pro';
     }
     if (normalized.includes('pro')) {
-        return 'gpt-5.2-pro';
+        return DEFAULT_MODEL;
     }
     // Passthrough for custom/OpenRouter model IDs.
     return normalized;
@@ -207,6 +228,9 @@ export function inferModelFromLabel(modelValue) {
     if (normalized in MODEL_CONFIGS) {
         return normalized;
     }
+    if (normalized.includes('/')) {
+        return normalized;
+    }
     if (normalized.includes('grok')) {
         return 'grok-4.1';
     }
@@ -219,12 +243,24 @@ export function inferModelFromLabel(modelValue) {
     if (normalized.includes('codex')) {
         return 'gpt-5.1-codex';
     }
+    if (isGeminiDeepThinkAlias(normalized)) {
+        return 'gemini-3-pro-deep-think';
+    }
     if (normalized.includes('gemini')) {
+        if (normalized.includes('3.1') || normalized.includes('3_1')) {
+            return 'gemini-3.1-pro';
+        }
         return 'gemini-3-pro';
     }
     if (normalized.includes('classic')) {
         return 'gpt-5-pro';
     }
+    if ((normalized.includes('5.4') || normalized.includes('5_4')) && normalized.includes('pro')) {
+        return 'gpt-5.4-pro';
+    }
+    if (normalized.includes('5.4') || normalized.includes('5_4')) {
+        return 'gpt-5.4';
+    }
     if ((normalized.includes('5.2') || normalized.includes('5_2')) && normalized.includes('pro')) {
         return 'gpt-5.2-pro';
     }
@@ -241,14 +277,15 @@ export function inferModelFromLabel(modelValue) {
     if (normalized.includes('gpt-5') &&
         normalized.includes('pro') &&
         !normalized.includes('5.1') &&
-        !normalized.includes('5.2')) {
+        !normalized.includes('5.2') &&
+        !normalized.includes('5.4')) {
         return 'gpt-5-pro';
     }
     if ((normalized.includes('5.1') || normalized.includes('5_1')) && normalized.includes('pro')) {
         return 'gpt-5.1-pro';
     }
     if (normalized.includes('pro')) {
-        return 'gpt-5.2-pro';
+        return DEFAULT_MODEL;
     }
     if (normalized.includes('5.1') || normalized.includes('5_1')) {
         return 'gpt-5.1';

package/dist/src/cli/runOptions.js

@@ -4,6 +4,7 @@ import { normalizeModelOption, inferModelFromLabel, resolveApiModel, normalizeBa
 import { resolveGeminiModelId } from '../oracle/gemini.js';
 import { PromptValidationError } from '../oracle/errors.js';
 import { normalizeChatGptModelForBrowser } from './browserConfig.js';
+import { resolveConfiguredMaxFileSizeBytes } from './fileSize.js';
 export function resolveRunOptionsFromConfig({ prompt, files = [], model, models, engine, userConfig, env = process.env, }) {
     const resolvedEngine = resolveEngineWithConfig({ engine, configEngine: userConfig?.engine, env });
     const browserRequested = engine === 'browser';
@@ -14,27 +15,33 @@ export function resolveRunOptionsFromConfig({ prompt, files = [], model, models,
     const inferredModel = resolvedEngine === 'browser' && normalizedRequestedModels.length === 0
         ? inferModelFromLabel(cliModelArg)
         : resolveApiModel(cliModelArg);
-    // Browser engine maps Pro/legacy aliases to the latest ChatGPT picker targets (GPT-5.2 / GPT-5.2 Pro).
+    // Browser engine maps Pro/legacy aliases to the latest ChatGPT picker targets (GPT-5.4 / GPT-5.4 Pro).
     const resolvedModel = resolvedEngine === 'browser' ? normalizeChatGptModelForBrowser(inferredModel) : inferredModel;
     const isCodex = resolvedModel.startsWith('gpt-5.1-codex');
     const isClaude = resolvedModel.startsWith('claude');
     const isGrok = resolvedModel.startsWith('grok');
+    const isGeminiApiOnly = resolvedModel === 'gemini-3.1-pro';
     const engineWasBrowser = resolvedEngine === 'browser';
     const allModels = normalizedRequestedModels.length > 0
         ? Array.from(new Set(normalizedRequestedModels.map((entry) => resolveApiModel(entry))))
         : [resolvedModel];
+    const includesGeminiApiOnly = allModels.some((m) => m === 'gemini-3.1-pro');
+    if ((browserRequested || browserConfigured) && includesGeminiApiOnly) {
+        throw new PromptValidationError('gemini-3.1-pro is API-only today. Use --engine api or switch to gemini-3-pro for Gemini web.', { engine: 'browser', models: allModels });
+    }
     const isBrowserCompatible = (m) => m.startsWith('gpt-') || m.startsWith('gemini');
     const hasNonBrowserCompatibleTarget = (browserRequested || browserConfigured) && allModels.some((m) => !isBrowserCompatible(m));
     if (hasNonBrowserCompatibleTarget) {
         throw new PromptValidationError('Browser engine only supports GPT and Gemini models. Re-run with --engine api for Grok, Claude, or other models.', { engine: 'browser', models: allModels });
     }
-    const engineCoercedToApi = engineWasBrowser && (isCodex || isClaude || isGrok);
-    const fixedEngine = isCodex || isClaude || isGrok || normalizedRequestedModels.length > 0 ? 'api' : resolvedEngine;
+    const engineCoercedToApi = engineWasBrowser && (isCodex || isClaude || isGrok || isGeminiApiOnly);
+    const fixedEngine = isCodex || isClaude || isGrok || isGeminiApiOnly || normalizedRequestedModels.length > 0 ? 'api' : resolvedEngine;
     const promptWithSuffix = userConfig?.promptSuffix && userConfig.promptSuffix.trim().length > 0
         ? `${prompt.trim()}\n${userConfig.promptSuffix}`
         : prompt;
     const search = userConfig?.search !== 'off';
     const heartbeatIntervalMs = userConfig?.heartbeatSeconds !== undefined ? userConfig.heartbeatSeconds * 1000 : 30_000;
+    const maxFileSizeBytes = resolveConfiguredMaxFileSizeBytes(userConfig, env);
     const baseUrl = normalizeBaseUrl(userConfig?.apiBaseUrl ??
         (isClaude ? env.ANTHROPIC_BASE_URL : isGrok ? env.XAI_BASE_URL : env.OPENAI_BASE_URL));
     const uniqueMultiModels = normalizedRequestedModels.length > 0 ? allModels : [];
@@ -49,6 +56,7 @@ export function resolveRunOptionsFromConfig({ prompt, files = [], model, models,
         model: chosenModel,
         models: uniqueMultiModels.length > 0 ? uniqueMultiModels : undefined,
         file: files ?? [],
+        maxFileSizeBytes,
         search,
         heartbeatIntervalMs,
         filesReport: userConfig?.filesReport,

package/dist/src/cli/sessionDisplay.js

@@ -7,6 +7,7 @@ import { formatTokenCount, formatTokenValue } from '../oracle/runUtils.js';
 import { resumeBrowserSession } from '../browser/reattach.js';
 import { estimateTokenCount } from '../browser/utils.js';
 import { formatSessionTableHeader, formatSessionTableRow, resolveSessionCost } from './sessionTable.js';
+import { abbreviateResponseId, buildResponseOwnerIndex, resolveSessionLineage, } from './sessionLineage.js';
 const isTty = () => Boolean(process.stdout.isTTY);
 const dim = (text) => (isTty() ? kleur.dim(text) : text);
 export const MAX_RENDER_BYTES = 200_000;
@@ -34,6 +35,7 @@ export async function showStatus({ hours, includeAll, limit, showExamples = fals
     const { entries, truncated, total } = sessionStore.filterSessions(metas, { hours, includeAll, limit });
     const filteredEntries = modelFilter ? entries.filter((entry) => matchesModel(entry, modelFilter)) : entries;
     const richTty = process.stdout.isTTY && chalk.level > 0;
+    const responseOwners = buildResponseOwnerIndex(metas);
     if (!filteredEntries.length) {
         console.log(CLEANUP_TIP);
         if (showExamples) {
@@ -43,8 +45,15 @@ export async function showStatus({ hours, includeAll, limit, showExamples = fals
     }
     console.log(chalk.bold('Recent Sessions'));
     console.log(formatSessionTableHeader(richTty));
-    for (const entry of filteredEntries) {
-        console.log(formatSessionTableRow(entry, { rich: richTty }));
+    const treeRows = buildStatusTreeRows(filteredEntries, responseOwners);
+    for (const row of treeRows) {
+        const line = formatSessionTableRow(row.entry, { rich: richTty, displaySlug: row.displaySlug });
+        const detachedParent = row.detachedParentLabel != null
+            ? richTty
+                ? chalk.gray(` <- ${row.detachedParentLabel}`)
+                : ` <- ${row.detachedParentLabel}`
+            : '';
+        console.log(`${line}${detachedParent}`);
     }
     if (truncated) {
         const sessionsDir = sessionStore.sessionsDir();
@@ -148,6 +157,10 @@ export async function attachSession(sessionId, options) {
         if (reattachLine) {
             console.log(chalk.blue(reattachLine));
         }
+        const chainLine = await buildSessionChainLine(metadata);
+        if (chainLine) {
+            console.log(dim(`Chain: ${chainLine}`));
+        }
         console.log(`Created: ${metadata.createdAt}`);
         console.log(`Status: ${metadata.status}`);
         if (metadata.models && metadata.models.length > 0) {
@@ -446,6 +459,82 @@ function matchesModel(entry, filter) {
     const models = entry.models?.map((model) => model.model.toLowerCase()) ?? (entry.model ? [entry.model.toLowerCase()] : []);
     return models.includes(normalized);
 }
+function buildStatusTreeRows(entries, responseOwners) {
+    const entryById = new Map(entries.map((entry) => [entry.id, entry]));
+    const orderIndex = new Map(entries.map((entry, index) => [entry.id, index]));
+    const lineageById = new Map();
+    const childMap = new Map();
+    for (const entry of entries) {
+        const lineage = resolveSessionLineage(entry, responseOwners);
+        lineageById.set(entry.id, lineage);
+        const parentId = lineage?.parentSessionId;
+        if (parentId && parentId !== entry.id && entryById.has(parentId)) {
+            const siblings = childMap.get(parentId) ?? [];
+            siblings.push(entry);
+            childMap.set(parentId, siblings);
+        }
+    }
+    for (const siblings of childMap.values()) {
+        siblings.sort((a, b) => (orderIndex.get(a.id) ?? 0) - (orderIndex.get(b.id) ?? 0));
+    }
+    const rows = [];
+    const visited = new Set();
+    const walkChild = (entry, ancestorHasMore, isLast) => {
+        if (visited.has(entry.id)) {
+            return;
+        }
+        visited.add(entry.id);
+        const children = childMap.get(entry.id) ?? [];
+        const nodeBranch = isLast ? '└─ ' : '├─ ';
+        const prefix = `${ancestorHasMore.map((hasMore) => (hasMore ? '│  ' : '   ')).join('')}${nodeBranch}`;
+        rows.push({ entry, displaySlug: `${prefix}${entry.id}` });
+        children.forEach((child, index) => {
+            walkChild(child, [...ancestorHasMore, !isLast], index === children.length - 1);
+        });
+    };
+    const walkRoot = (entry) => {
+        if (visited.has(entry.id)) {
+            return;
+        }
+        visited.add(entry.id);
+        const lineage = lineageById.get(entry.id);
+        const hiddenParent = lineage?.parentSessionId && !entryById.has(lineage.parentSessionId)
+            ? `${lineage.parentSessionId} (${abbreviateResponseId(lineage.parentResponseId)})`
+            : undefined;
+        const children = childMap.get(entry.id) ?? [];
+        rows.push({ entry, displaySlug: entry.id, detachedParentLabel: hiddenParent });
+        children.forEach((child, index) => {
+            walkChild(child, [], index === children.length - 1);
+        });
+    };
+    const roots = entries.filter((entry) => {
+        const parentId = lineageById.get(entry.id)?.parentSessionId;
+        return !(parentId && parentId !== entry.id && entryById.has(parentId));
+    });
+    roots.forEach((entry) => {
+        walkRoot(entry);
+    });
+    entries.forEach((entry) => {
+        walkRoot(entry);
+    });
+    return rows;
+}
+async function buildSessionChainLine(metadata) {
+    const lineageWithoutLookup = resolveSessionLineage(metadata);
+    if (!lineageWithoutLookup) {
+        return `root -> ${metadata.id}`;
+    }
+    if (lineageWithoutLookup.parentSessionId) {
+        return `${lineageWithoutLookup.parentSessionId} (${abbreviateResponseId(lineageWithoutLookup.parentResponseId)}) -> ${metadata.id}`;
+    }
+    const sessions = await sessionStore.listSessions().catch(() => []);
+    const responseOwners = buildResponseOwnerIndex(sessions);
+    const lineage = resolveSessionLineage(metadata, responseOwners) ?? lineageWithoutLookup;
+    if (lineage.parentSessionId) {
+        return `${lineage.parentSessionId} (${abbreviateResponseId(lineage.parentResponseId)}) -> ${metadata.id}`;
+    }
+    return `${abbreviateResponseId(lineage.parentResponseId)} -> ${metadata.id}`;
+}
 async function buildSessionLogForDisplay(sessionId, fallbackMeta, modelFilter) {
     const normalizedFilter = modelFilter?.trim().toLowerCase();
     const freshMetadata = (await sessionStore.readSession(sessionId)) ?? fallbackMeta;

package/dist/src/cli/sessionLineage.js

@@ -0,0 +1,56 @@
+function readResponseId(record) {
+    if (!record)
+        return null;
+    const candidate = typeof record.responseId === 'string' ? record.responseId : typeof record.id === 'string' ? record.id : null;
+    if (!candidate || !candidate.startsWith('resp_')) {
+        return null;
+    }
+    return candidate;
+}
+export function collectSessionResponseIds(meta) {
+    const ids = new Set();
+    const rootResponse = readResponseId(meta.response);
+    if (rootResponse) {
+        ids.add(rootResponse);
+    }
+    const runs = Array.isArray(meta.models) ? meta.models : [];
+    for (const run of runs) {
+        const runResponse = readResponseId(run.response);
+        if (runResponse) {
+            ids.add(runResponse);
+        }
+    }
+    return [...ids];
+}
+export function buildResponseOwnerIndex(sessions) {
+    const byResponse = new Map();
+    for (const session of sessions) {
+        for (const responseId of collectSessionResponseIds(session)) {
+            if (!byResponse.has(responseId)) {
+                byResponse.set(responseId, session.id);
+            }
+        }
+    }
+    return byResponse;
+}
+export function resolveSessionLineage(meta, responseOwners) {
+    const previous = meta.options?.previousResponseId?.trim();
+    if (!previous) {
+        return null;
+    }
+    let parentSessionId = meta.options?.followupSessionId?.trim();
+    if (!parentSessionId && responseOwners) {
+        parentSessionId = responseOwners.get(previous);
+    }
+    if (parentSessionId === meta.id) {
+        parentSessionId = undefined;
+    }
+    return { parentResponseId: previous, parentSessionId };
+}
+export function abbreviateResponseId(responseId, max = 18) {
+    if (responseId.length <= max) {
+        return responseId;
+    }
+    const head = Math.max(8, max - 7);
+    return `${responseId.slice(0, head)}...${responseId.slice(-4)}`;
+}

package/dist/src/cli/sessionRunner.js

@@ -101,7 +101,10 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 baseUrl: runOptions.baseUrl,
                 openRouterApiKey: process.env.OPENROUTER_API_KEY,
             });
-            const files = await readFiles(runOptions.file ?? [], { cwd });
+            const files = await readFiles(runOptions.file ?? [], {
+                cwd,
+                maxFileSizeBytes: runOptions.maxFileSizeBytes,
+            });
             const promptWithFiles = buildPrompt(runOptions.prompt, files, cwd);
             const requestBody = buildRequestBody({
                 modelConfig,
@@ -322,6 +325,8 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
         const userError = asOracleUserError(error);
         const connectionLost = userError?.category === 'browser-automation' && userError.details?.stage === 'connection-lost';
         const assistantTimeout = userError?.category === 'browser-automation' && userError.details?.stage === 'assistant-timeout';
+        const cloudflareChallenge = userError?.category === 'browser-automation' &&
+            userError.details?.stage === 'cloudflare-challenge';
         if (connectionLost && mode === 'browser') {
             const runtime = userError.details?.runtime;
             log(dim('Chrome disconnected before completion; keeping session running for reattach.'));
@@ -381,6 +386,13 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             log(dim(`Reattach later with: oracle session ${sessionMeta.id}`));
             return;
         }
+        if (cloudflareChallenge && mode === 'browser') {
+            const details = userError.details;
+            log(dim('Cloudflare challenge detected; browser left running so you can complete the check.'));
+            if (details?.reuseProfileHint) {
+                log(dim(`Reuse this browser profile with: ${details.reuseProfileHint}`));
+            }
+        }
         if (userError) {
             log(dim(`User error (${userError.category}): ${userError.message}`));
         }
@@ -394,12 +406,18 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
         if (transportLine) {
             log(dim(`Transport: ${transportLine}`));
         }
+        const browserRuntime = mode === 'browser' ? userError?.details?.runtime : undefined;
         await sessionStore.updateSession(sessionMeta.id, {
             status: 'error',
             completedAt: new Date().toISOString(),
             errorMessage: message,
             mode,
-            browser: browserConfig ? { config: browserConfig } : undefined,
+            browser: browserConfig
+                ? {
+                    config: browserConfig,
+                    runtime: browserRuntime ?? undefined,
+                }
+                : undefined,
             response: responseMetadata,
             transport: transportMetadata,
             error: userError

package/dist/src/cli/sessionTable.js

@@ -29,7 +29,8 @@ export function formatSessionTableRow(meta, options) {
     const costValue = resolveSessionCost(meta);
     const costRaw = costValue != null ? formatCostTable(costValue) : `${''.padStart(COST_PAD - 1)}-`;
     const cost = rich ? chalk.gray(costRaw) : costRaw;
-    const slug = rich ? chalk.cyan(meta.id) : meta.id;
+    const slugValue = options?.displaySlug ?? meta.id;
+    const slug = rich ? chalk.cyan(slugValue) : slugValue;
     return `${status} ${model} ${mode} ${timestamp} ${chars} ${cost}  ${slug}`;
 }
 export function resolveSessionCost(meta) {

package/dist/src/cli/tui/index.js

@@ -13,6 +13,7 @@ import { formatSessionTableHeader, formatSessionTableRow } from '../sessionTable
 import { buildBrowserConfig, resolveBrowserModelLabel } from '../browserConfig.js';
 import { resolveNotificationSettings } from '../notifier.js';
 import { loadUserConfig } from '../../config.js';
+import { resolveConfiguredMaxFileSizeBytes } from '../fileSize.js';
 import { formatTokenCount } from '../../oracle/runUtils.js';
 const isTty = () => Boolean(process.stdout.isTTY && chalk.level > 0);
 const dim = (text) => (isTty() ? kleur.dim(text) : text);
@@ -374,6 +375,7 @@ async function askOracleFlow(version, userConfig) {
         prompt: promptWithSuffix,
         model: answers.model,
         file: answers.files,
+        maxFileSizeBytes: resolveConfiguredMaxFileSizeBytes(userConfig, process.env),
         models: normalizedMultiModels.length > 1 ? normalizedMultiModels : undefined,
         slug: answers.slug,
         filesReport: false,

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

@@ -0,0 +1,76 @@
+import path from 'node:path';
+import os from 'node:os';
+import { mkdir } from 'node:fs/promises';
+import { launchChrome, connectWithNewTab, closeTab } from '../browser/chromeLifecycle.js';
+import { resolveBrowserConfig } from '../browser/config.js';
+import { readDevToolsPort, writeDevToolsActivePort, writeChromePid, cleanupStaleProfileState, verifyDevToolsReachable, } from '../browser/profileState.js';
+export async function openGeminiBrowserSession(input) {
+    const { browserConfig, keepBrowserDefault, purpose, log } = input;
+    const profileDir = browserConfig?.manualLoginProfileDir
+        ?? path.join(os.homedir(), '.oracle', 'browser-profile');
+    await mkdir(profileDir, { recursive: true });
+    const resolvedConfig = resolveBrowserConfig({
+        ...browserConfig,
+        manualLogin: true,
+        manualLoginProfileDir: profileDir,
+        keepBrowser: browserConfig?.keepBrowser ?? keepBrowserDefault,
+    });
+    const keepBrowser = Boolean(resolvedConfig.keepBrowser);
+    let port = await readDevToolsPort(profileDir);
+    let launchedChrome = null;
+    let chromeWasLaunched = false;
+    if (port) {
+        const probe = await verifyDevToolsReachable({ port });
+        if (!probe.ok) {
+            log?.(`[gemini-web] Stale DevTools port ${port}; launching fresh Chrome for ${purpose}.`);
+            await cleanupStaleProfileState(profileDir, log, { lockRemovalMode: 'if_oracle_pid_dead' });
+            port = null;
+        }
+    }
+    if (!port) {
+        log?.(`[gemini-web] Launching Chrome for ${purpose}.`);
+        launchedChrome = await launchChrome(resolvedConfig, profileDir, log ?? (() => { }));
+        port = launchedChrome.port;
+        chromeWasLaunched = true;
+        await writeDevToolsActivePort(profileDir, port);
+        if (launchedChrome.pid) {
+            await writeChromePid(profileDir, launchedChrome.pid);
+        }
+    }
+    else {
+        log?.(`[gemini-web] Reusing Chrome on port ${port} for ${purpose}.`);
+    }
+    const connection = await connectWithNewTab(port, log ?? (() => { }), undefined);
+    const client = connection.client;
+    const targetId = connection.targetId;
+    const close = async () => {
+        if (keepBrowser) {
+            try {
+                await client.close();
+            }
+            catch { /* ignore */ }
+            return;
+        }
+        if (targetId && port) {
+            await closeTab(port, targetId, log ?? (() => { })).catch(() => undefined);
+        }
+        try {
+            await client.close();
+        }
+        catch { /* ignore */ }
+        if (chromeWasLaunched && launchedChrome) {
+            try {
+                launchedChrome.kill();
+            }
+            catch { /* ignore */ }
+            await cleanupStaleProfileState(profileDir, log, { lockRemovalMode: 'never' }).catch(() => undefined);
+        }
+    };
+    return {
+        profileDir,
+        port,
+        client,
+        targetId: targetId ?? undefined,
+        close,
+    };
+}

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

@@ -4,6 +4,7 @@ const USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36
 const MODEL_HEADER_NAME = 'x-goog-ext-525001261-jspb';
 const MODEL_HEADERS = {
     'gemini-3-pro': '[1,null,null,null,"9d8ca3786ebdfbea",null,null,0,[4]]',
+    'gemini-3-pro-deep-think': '[1,null,null,null,"e6fa609c3fa255c0",null,null,0,[4],null,null,3]',
     'gemini-2.5-pro': '[1,null,null,null,"4af6c7f5da75d65d",null,null,0,[4]]',
     'gemini-2.5-flash': '[1,null,null,null,"9ec249fc9ad08861",null,null,0,[4]]',
 };
@@ -11,6 +12,16 @@ const GEMINI_APP_URL = 'https://gemini.google.com/app';
 const GEMINI_STREAM_GENERATE_URL = 'https://gemini.google.com/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate';
 const GEMINI_UPLOAD_URL = 'https://content-push.googleapis.com/upload';
 const GEMINI_UPLOAD_PUSH_ID = 'feeds/mcudyrk2a4khkz';
+const GEMINI_UPLOAD_MIME_TYPES = {
+    '.bmp': 'image/bmp',
+    '.gif': 'image/gif',
+    '.jpeg': 'image/jpeg',
+    '.jpg': 'image/jpeg',
+    '.pdf': 'application/pdf',
+    '.png': 'image/png',
+    '.svg': 'image/svg+xml',
+    '.webp': 'image/webp',
+};
 function getNestedValue(value, pathParts, fallback) {
     let current = value;
     for (const part of pathParts) {
@@ -119,8 +130,9 @@ async function uploadGeminiFile(filePath, signal) {
     const absPath = path.resolve(process.cwd(), filePath);
     const data = await readFile(absPath);
     const fileName = path.basename(absPath);
+    const mimeType = GEMINI_UPLOAD_MIME_TYPES[path.extname(absPath).toLowerCase()] ?? 'application/octet-stream';
     const form = new FormData();
-    form.append('file', new Blob([data]), fileName);
+    form.append('file', new Blob([data], { type: mimeType }), fileName);
     const res = await fetch(GEMINI_UPLOAD_URL, {
         method: 'POST',
         redirect: 'follow',
@@ -135,7 +147,7 @@ async function uploadGeminiFile(filePath, signal) {
     if (!res.ok) {
         throw new Error(`File upload failed: ${res.status} ${res.statusText} (${text.slice(0, 200)})`);
     }
-    return { id: text, name: fileName };
+    return { id: text, name: fileName, mimeType };
 }
 function buildGeminiFReqPayload(prompt, uploaded, chatMetadata) {
     const promptPayload = uploaded.length > 0
@@ -143,9 +155,8 @@ function buildGeminiFReqPayload(prompt, uploaded, chatMetadata) {
             prompt,
             0,
             null,
-            // Matches gemini-webapi payload format: [[[fileId, 1]]] for a single attachment.
-            // Keep it extensible for multiple uploads by emitting one [[id, 1]] entry per file.
-            uploaded.map((file) => [[file.id, 1]]),
+            // Format: [[[fileId, 1, null, "mimeType"], "filename", ...]]
+            uploaded.map((file) => [[file.id, 1, null, file.mimeType], file.name]),
         ]
         : [prompt];
     const innerList = [promptPayload, null, chatMetadata ?? null];

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,18 @@
+export function selectGeminiExecutionMode(input) {
+    const reasons = [];
+    if (input.model !== 'gemini-3-pro-deep-think') {
+        return { mode: 'http', reasons: ['model'] };
+    }
+    if (input.attachmentPaths.length > 0) {
+        reasons.push('attachments');
+    }
+    if (input.generateImagePath) {
+        reasons.push('image-generation');
+    }
+    if (input.editImagePath) {
+        reasons.push('image-edit');
+    }
+    return reasons.length === 0
+        ? { mode: 'dom', reasons: [] }
+        : { mode: 'http', reasons };
+}