@steipete/oracle 0.11.1 → 0.12.1

package/dist/src/cli/sessionRunner.js

@@ -1,7 +1,7 @@
 import kleur from "kleur";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { runOracle, OracleResponseError, OracleTransportError, extractResponseMetadata, asOracleUserError, extractTextOutput, } from "../oracle.js";
+import { runOracle, OracleResponseError, OracleTransportError, extractResponseMetadata, asOracleUserError, extractTextOutput, classifyProviderFailure, } from "../oracle.js";
 import { ensureSessionArtifacts, runBrowserSessionExecution, } from "../browser/sessionRunner.js";
 import { renderMarkdownAnsi } from "./markdownRenderer.js";
 import { formatResponseMetadata, formatTransportMetadata } from "./sessionDisplay.js";
@@ -21,6 +21,7 @@ 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 { hasRecoverableChatGptConversation } from "../browser/reattachability.js";
 import { estimateTokenCount } from "../browser/utils.js";
 import { formatElapsed } from "../oracle/format.js";
 const isTty = process.stdout.isTTY;
@@ -82,6 +83,8 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                     config: browserConfig,
                     runtime: result.runtime,
                     archive: result.archive,
+                    modelSelection: result.modelSelection,
+                    warnings: result.warnings,
                 },
                 artifacts: mergeArtifacts(sessionMeta.artifacts, result.artifacts),
                 response: undefined,
@@ -245,8 +248,13 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             });
             log(statusColor(line1));
             const hasFailure = summary.rejected.length > 0;
+            const allowPartial = runOptions.partialMode === "ok" && summary.fulfilled.length > 0;
+            if (hasFailure) {
+                const resultLabel = summary.fulfilled.length > 0 ? "partial success" : "failed";
+                log(statusColor(`Multi-model result: ${resultLabel}, ${summary.fulfilled.length}/${multiModels.length} succeeded`));
+            }
             await sessionStore.updateSession(sessionMeta.id, {
-                status: hasFailure ? "error" : "completed",
+                status: hasFailure ? (allowPartial ? "partial" : "error") : "completed",
                 completedAt: new Date().toISOString(),
                 usage: aggregateUsage,
                 elapsedMs: summary.elapsedMs,
@@ -273,15 +281,52 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                         savedOutputs.push({ model: entry.model, path: savedPath });
                     }
                 }
+                const sessionWithRuns = (await readSessionForManifest(sessionMeta.id)) ?? {
+                    ...sessionMeta,
+                    models: sessionMeta.models,
+                };
+                const runLogs = await collectMultiModelRunLogs(sessionMeta.id, sessionWithRuns.models, summary);
+                const manifestPath = await writeMultiModelOutputManifest({
+                    baseOutputPath: runOptions.writeOutputPath,
+                    sessionId: sessionMeta.id,
+                    status: hasFailure ? (allowPartial ? "partial" : "error") : "completed",
+                    summary,
+                    savedOutputs,
+                    modelRuns: sessionWithRuns.models,
+                    runLogs,
+                    runOptions,
+                    log,
+                });
                 if (savedOutputs.length > 0) {
                     log(dim("Saved outputs:"));
                     for (const item of savedOutputs) {
                         log(dim(`- ${item.model} -> ${item.path}`));
                     }
                 }
+                if (manifestPath) {
+                    log(dim(`Output manifest: ${manifestPath}`));
+                }
+                if (runLogs.length > 0) {
+                    log(dim(""));
+                    log(dim("Run logs:"));
+                    for (const item of runLogs) {
+                        log(dim(`- ${item.model} -> ${item.path}`));
+                    }
+                }
             }
             if (hasFailure) {
-                throw summary.rejected[0].reason;
+                log(dim("Failures:"));
+                for (const item of summary.rejected) {
+                    const providerContext = providerFailureContextForModel(item.model, runOptions);
+                    log(dim(`- ${item.model}: ${formatMultiModelFailure(item.reason, providerContext)}`));
+                    for (const line of formatMultiModelFailureDetails(item.reason, providerContext)) {
+                        log(dim(line));
+                    }
+                }
+            }
+            if (hasFailure && !allowPartial) {
+                const firstFailure = summary.rejected[0];
+                throw sanitizeMultiModelFailureForThrow(firstFailure.reason, providerFailureContextForModel(firstFailure.model, runOptions));
             }
             return;
         }
@@ -346,6 +391,40 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
         if (connectionLost && mode === "browser") {
             const runtime = userError.details
                 ?.runtime;
+            const recoverableRuntime = runtime ?? sessionMeta.browser?.runtime;
+            if (!hasRecoverableChatGptConversation(recoverableRuntime) &&
+                recoverableRuntime?.promptSubmitted !== true) {
+                log(dim("Chrome disconnected before a ChatGPT conversation was created; marking session error."));
+                if (modelForStatus) {
+                    await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
+                        status: "error",
+                        completedAt: new Date().toISOString(),
+                        response: { status: "error", incompleteReason: "chrome-disconnected" },
+                        error: {
+                            category: userError.category,
+                            message: userError.message,
+                            details: userError.details,
+                        },
+                    });
+                }
+                await sessionStore.updateSession(sessionMeta.id, {
+                    status: "error",
+                    completedAt: new Date().toISOString(),
+                    errorMessage: message,
+                    mode,
+                    browser: {
+                        config: browserConfig,
+                        runtime: recoverableRuntime,
+                    },
+                    response: { status: "error", incompleteReason: "chrome-disconnected" },
+                    error: {
+                        category: userError.category,
+                        message: userError.message,
+                        details: userError.details,
+                    },
+                });
+                throw error;
+            }
             log(dim("Chrome disconnected before completion; keeping session running for reattach."));
             if (modelForStatus) {
                 await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
@@ -483,6 +562,196 @@ function mergeArtifacts(existing, additions) {
 function formatError(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function providerFailureContextForModel(model, runOptions) {
+    return {
+        model,
+        providerMode: runOptions.provider,
+        azure: runOptions.azure,
+        baseUrl: runOptions.baseUrl,
+        apiKey: runOptions.apiKey,
+    };
+}
+function formatMultiModelFailure(error, context) {
+    const userError = asOracleUserError(error);
+    if (userError) {
+        return `${userError.category}, ${userError.message}`;
+    }
+    const providerFailure = classifyProviderFailure(error, context);
+    if (providerFailure) {
+        return providerFailure.label;
+    }
+    if (error instanceof OracleTransportError) {
+        return `${error.reason}, ${error.message}`;
+    }
+    if (error instanceof OracleResponseError) {
+        return error.message;
+    }
+    return formatError(error);
+}
+function formatMultiModelFailureDetails(error, context) {
+    const providerFailure = classifyProviderFailure(error, context);
+    if (!providerFailure) {
+        return [];
+    }
+    const lines = [];
+    if (providerFailure.keyEnv) {
+        lines.push(`  key: ${providerFailure.keyEnv}`);
+    }
+    lines.push(`  provider said: ${providerFailure.providerMessage}`);
+    lines.push(`  fix: ${providerFailure.fix}`);
+    return lines;
+}
+function sanitizeMultiModelFailureForThrow(error, context) {
+    const providerFailure = classifyProviderFailure(error, context);
+    if (!providerFailure) {
+        return error;
+    }
+    const modelPrefix = typeof context === "object" && context?.model ? `${context.model}: ` : "";
+    const message = `${modelPrefix}${providerFailure.label}: ${providerFailure.providerMessage}`;
+    if (!(error instanceof Error)) {
+        return new Error(message);
+    }
+    let sanitized;
+    if (error instanceof OracleTransportError) {
+        sanitized = new OracleTransportError(error.reason, message);
+    }
+    else if (error instanceof OracleResponseError) {
+        sanitized = new OracleResponseError(message, error.response);
+    }
+    else {
+        sanitized = new Error(message);
+        sanitized.name = error.name;
+    }
+    if (error.stack) {
+        const [, ...rest] = error.stack.split("\n");
+        sanitized.stack = [sanitized.name ? `${sanitized.name}: ${message}` : message, ...rest].join("\n");
+    }
+    return sanitized;
+}
+export function deriveOutputManifestPath(basePath) {
+    const ext = path.extname(basePath);
+    const stem = path.basename(basePath, ext);
+    const dir = path.dirname(basePath);
+    return path.join(dir, `${stem}.oracle.json`);
+}
+async function collectMultiModelRunLogs(sessionId, modelRuns, summary) {
+    const sessionDir = await resolveSessionDir(sessionId);
+    const logsByModel = new Map();
+    for (const run of modelRuns ?? []) {
+        if (run.log?.path) {
+            logsByModel.set(run.model, resolveSessionPath(sessionDir, run.log.path));
+        }
+    }
+    for (const entry of summary.fulfilled) {
+        if (!logsByModel.has(entry.model)) {
+            logsByModel.set(entry.model, entry.logPath);
+        }
+    }
+    return [...logsByModel.entries()].map(([model, logPath]) => ({ model, path: logPath }));
+}
+async function writeMultiModelOutputManifest({ baseOutputPath, sessionId, status, summary, savedOutputs, modelRuns, runLogs, runOptions, log, }) {
+    const manifestPath = deriveOutputManifestPath(baseOutputPath);
+    const normalizedTarget = path.resolve(manifestPath);
+    const normalizedSessionsDir = path.resolve(sessionStore.sessionsDir());
+    if (normalizedTarget === normalizedSessionsDir ||
+        normalizedTarget.startsWith(`${normalizedSessionsDir}${path.sep}`)) {
+        log(dim(`output manifest skipped: refusing to write inside session storage (${normalizedSessionsDir}).`));
+        return undefined;
+    }
+    const manifest = buildMultiModelOutputManifest({
+        baseOutputPath,
+        sessionId,
+        status,
+        summary,
+        savedOutputs,
+        modelRuns,
+        runLogs,
+        runOptions,
+    });
+    try {
+        await fs.mkdir(path.dirname(normalizedTarget), { recursive: true });
+        await fs.writeFile(normalizedTarget, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+        return normalizedTarget;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        log(dim(`output manifest failed (${reason}); session completed anyway.`));
+        return undefined;
+    }
+}
+function buildMultiModelOutputManifest({ baseOutputPath, sessionId, status, summary, savedOutputs, modelRuns, runLogs, runOptions, }) {
+    const outputByModel = new Map(savedOutputs.map((entry) => [entry.model, entry.path]));
+    const logsByModel = new Map(runLogs.map((entry) => [entry.model, entry.path]));
+    const runsByModel = new Map((modelRuns ?? []).map((run) => [run.model, run]));
+    const fulfilledByModel = new Map(summary.fulfilled.map((entry) => [entry.model, entry]));
+    const rejectedByModel = new Map(summary.rejected.map((entry) => [entry.model, entry.reason]));
+    const orderedModels = [
+        ...summary.fulfilled.map((entry) => entry.model),
+        ...summary.rejected.map((entry) => entry.model),
+    ];
+    return {
+        version: 1,
+        sessionId,
+        status,
+        outputBasePath: path.resolve(baseOutputPath),
+        createdAt: new Date().toISOString(),
+        models: orderedModels.map((model) => {
+            const run = runsByModel.get(model);
+            const fulfilled = fulfilledByModel.get(model);
+            const reason = rejectedByModel.get(model);
+            const userError = reason ? asOracleUserError(reason) : undefined;
+            const providerFailure = reason
+                ? classifyProviderFailure(reason, providerFailureContextForModel(model, runOptions))
+                : undefined;
+            return {
+                model,
+                status: fulfilled ? "completed" : reason ? "error" : (run?.status ?? "error"),
+                outputPath: outputByModel.get(model),
+                logPath: logsByModel.get(model),
+                errorCategory: run?.error?.category ?? userError?.category ?? providerFailure?.category,
+                errorMessage: run?.error?.message ??
+                    userError?.message ??
+                    providerFailure?.label ??
+                    (reason ? formatError(reason) : undefined),
+                elapsedMs: calculateModelElapsedMs(run),
+                usage: run?.usage ?? fulfilled?.usage,
+            };
+        }),
+    };
+}
+function calculateModelElapsedMs(run) {
+    if (!run?.startedAt || !run.completedAt) {
+        return undefined;
+    }
+    const startedMs = Date.parse(run.startedAt);
+    const completedMs = Date.parse(run.completedAt);
+    if (!Number.isFinite(startedMs) || !Number.isFinite(completedMs) || completedMs < startedMs) {
+        return undefined;
+    }
+    return completedMs - startedMs;
+}
+async function readSessionForManifest(sessionId) {
+    try {
+        return (await sessionStore.readSession(sessionId)) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveSessionDir(sessionId) {
+    try {
+        return (await sessionStore.getPaths(sessionId)).dir;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveSessionPath(sessionDir, targetPath) {
+    if (path.isAbsolute(targetPath) || !sessionDir) {
+        return targetPath;
+    }
+    return path.join(sessionDir, targetPath);
+}
 async function writeAssistantOutput(targetPath, content, log) {
     if (!targetPath)
         return;

package/dist/src/cli/sessionTable.js

@@ -2,6 +2,7 @@ import chalk from "chalk";
 import kleur from "kleur";
 import { MODEL_CONFIGS } from "../oracle.js";
 import { estimateUsdCost } from "tokentally";
+import { formatSessionExecutionLabel } from "./sessionLifecycle.js";
 const isRich = (rich) => rich ?? Boolean(process.stdout.isTTY && chalk.level > 0);
 const dim = (text, rich) => (rich ? kleur.dim(text) : text);
 export const STATUS_PAD = 9;
@@ -19,7 +20,7 @@ export function formatSessionTableRow(meta, options) {
     const status = colorStatus(meta.status ?? "unknown", rich);
     const modelLabel = (meta.model ?? "n/a").padEnd(MODEL_PAD);
     const model = rich ? chalk.white(modelLabel) : modelLabel;
-    const modeLabel = (meta.mode ?? meta.options?.mode ?? "api").padEnd(MODE_PAD);
+    const modeLabel = formatSessionExecutionLabel(meta).padEnd(MODE_PAD);
     const mode = rich ? chalk.gray(modeLabel) : modeLabel;
     const timestampLabel = formatTimestampAligned(meta.createdAt).padEnd(TIMESTAMP_PAD);
     const timestamp = rich ? chalk.gray(timestampLabel) : timestampLabel;

package/dist/src/duration.js

@@ -0,0 +1,47 @@
+export function parseDuration(input, fallback) {
+    if (!input) {
+        return fallback;
+    }
+    const trimmed = input.trim();
+    if (!trimmed) {
+        return fallback;
+    }
+    const lowercase = trimmed.toLowerCase();
+    if (/^[0-9]+$/.test(lowercase)) {
+        return Number(lowercase);
+    }
+    const normalized = lowercase.replace(/\s+/g, "");
+    const singleMatch = /^([0-9]+)(ms|s|m|h)$/i.exec(normalized);
+    if (singleMatch && singleMatch[0].length === normalized.length) {
+        const value = Number(singleMatch[1]);
+        return convertUnit(value, singleMatch[2]);
+    }
+    const multiDuration = /([0-9]+)(ms|h|m|s)/g;
+    let total = 0;
+    let lastIndex = 0;
+    let match = multiDuration.exec(normalized);
+    while (match !== null) {
+        total += convertUnit(Number(match[1]), match[2]);
+        lastIndex = multiDuration.lastIndex;
+        match = multiDuration.exec(normalized);
+    }
+    if (total > 0 && lastIndex === normalized.length) {
+        return total;
+    }
+    return fallback;
+}
+function convertUnit(value, unitRaw) {
+    const unit = unitRaw?.toLowerCase();
+    switch (unit) {
+        case "ms":
+            return value;
+        case "s":
+            return value * 1000;
+        case "m":
+            return value * 60_000;
+        case "h":
+            return value * 3_600_000;
+        default:
+            return value;
+    }
+}

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

@@ -60,6 +60,10 @@ const consultInputShape = {
         .boolean()
         .optional()
         .describe("Browser-only: bundle many files into a single upload (helps with upload limits)."),
+    browserBundleFormat: z
+        .enum(["text", "zip"])
+        .optional()
+        .describe('Browser-only: bundle upload format when browserBundleFiles is true or auto-bundling is needed. Defaults to "text"; "zip" preserves individual file names in one uploaded archive.'),
     browserThinkingTime: z
         .enum(["light", "standard", "extended", "heavy"])
         .optional()
@@ -140,6 +144,7 @@ const consultDryRunResolvedShape = z.object({
         researchMode: z.string().nullable().optional(),
         attachments: z.string().optional(),
         bundleFiles: z.boolean().optional(),
+        bundleFormat: z.enum(["text", "zip"]).optional(),
         keepBrowser: z.boolean().optional(),
         manualLogin: z.boolean().optional(),
         profileDir: z.string().nullable().optional(),
@@ -196,7 +201,9 @@ export function buildConsultBrowserConfig({ userConfig, env, runModel, inputMode
         ? mapModelToBrowserLabel(runModel)
         : resolveBrowserModelLabel(preferredLabel, runModel);
     const configuredUrl = configuredBrowser.chatgptUrl ?? configuredBrowser.url ?? CHATGPT_URL;
-    const manualLogin = hasProfileDir ? true : (configuredBrowser.manualLogin ?? false);
+    const manualLogin = hasProfileDir
+        ? true
+        : (configuredBrowser.manualLogin ?? process.platform === "win32");
     return {
         ...configuredBrowser,
         url: configuredUrl,
@@ -224,6 +231,12 @@ export function buildConsultDryRunResolved({ resolvedEngine, runOptions, browser
     }
     if (resolvedEngine === "browser") {
         guidance.push("Browser engine uses the signed-in ChatGPT profile; run dryRun:true before live use.");
+        if (browserConfig?.manualLogin) {
+            const profile = browserConfig.manualLoginProfileDir ?? "~/.oracle/browser-profile";
+            guidance.push(`Manual-login browser mode uses Oracle's private Chrome profile at ${profile}, separate from your normal Chrome profile.`);
+            guidance.push(`First-time setup: run oracle --engine browser --browser-manual-login --browser-keep-browser --browser-manual-login-profile-dir ${JSON.stringify(profile)} -p "HI", sign into ChatGPT in that window, then retry the consult.`);
+            guidance.push("If this profile is not signed in, non-setup MCP/browser runs fail fast instead of waiting for the full browser timeout.");
+        }
     }
     const desiredModel = browserConfig?.desiredModel ?? null;
     const thinkingTime = browserConfig?.thinkingTime ?? null;
@@ -251,6 +264,7 @@ export function buildConsultDryRunResolved({ resolvedEngine, runOptions, browser
                 researchMode: browserConfig?.researchMode ?? null,
                 attachments: runOptions.browserAttachments,
                 bundleFiles: runOptions.browserBundleFiles,
+                bundleFormat: runOptions.browserBundleFormat,
                 keepBrowser: browserConfig?.keepBrowser,
                 manualLogin: browserConfig?.manualLogin,
                 profileDir: browserConfig?.manualLoginProfileDir ?? null,
@@ -277,6 +291,7 @@ export function formatConsultDryRunResolved(details) {
         lines.push(`  browser research mode: ${details.browser.researchMode ?? "off"}`);
         lines.push(`  browser attachments: ${details.browser.attachments ?? "auto"}`);
         lines.push(`  browser bundle files: ${details.browser.bundleFiles ? "yes" : "no"}`);
+        lines.push(`  browser bundle format: ${details.browser.bundleFormat ?? "text"}`);
         lines.push(`  browser keep browser: ${details.browser.keepBrowser ? "yes" : "no"}`);
         lines.push(`  browser manual login: ${details.browser.manualLogin ? "yes" : "no"}`);
         if (details.browser.profileDir) {
@@ -295,7 +310,7 @@ export function formatConsultDryRunResolved(details) {
 export function registerConsultTool(server) {
     server.registerTool("consult", {
         title: "Run an oracle session",
-        description: 'Run an Oracle session (API or ChatGPT browser automation). Use `files` to attach project context. If `engine` is omitted, Oracle follows CLI defaults: config/ORACLE_ENGINE first, then API when OPENAI_API_KEY is set, otherwise browser. Browser GPT-5.5 Pro consults can take many minutes; use `dryRun:true` first when configuring an agent and inspect `sessions`/`oracle status` before retrying. For browser-based image/file uploads, set `browserAttachments:"always"`. Browser consults can include `browserFollowUps` for a multi-turn ChatGPT review in one conversation. Sessions are stored under `ORACLE_HOME_DIR` (shared with the CLI).',
+        description: 'Run an Oracle session (API or ChatGPT browser automation). Use `files` to attach project context. If `engine` is omitted, Oracle follows CLI defaults: config/ORACLE_ENGINE first, then API when OPENAI_API_KEY is set, otherwise browser. Browser GPT-5.5 Pro consults can take many minutes; use `dryRun:true` first when configuring an agent and inspect `sessions`/`oracle status` before retrying. Browser manual-login uses a private Oracle Chrome profile separate from the user\'s normal Chrome; dry-run output includes first-time setup guidance when that path is active. For browser-based image/file uploads, set `browserAttachments:"always"`. Browser consults can include `browserFollowUps` for a multi-turn ChatGPT review in one conversation. Sessions are stored under `ORACLE_HOME_DIR` (shared with the CLI).',
         // Cast to any to satisfy SDK typings across differing Zod versions.
         inputSchema: consultInputShape,
         outputSchema: consultOutputShape,
@@ -311,7 +326,7 @@ export function registerConsultTool(server) {
                 content: textContent(error instanceof Error ? error.message : String(error)),
             };
         }
-        const { prompt, files, model, models, engine, search, browserModelLabel, browserAttachments, browserBundleFiles, browserThinkingTime, browserModelStrategy, browserResearchMode, browserArchive, browserFollowUps, browserKeepBrowser, dryRun, slug, } = parsedInput;
+        const { prompt, files, model, models, engine, search, browserModelLabel, browserAttachments, browserBundleFiles, browserBundleFormat, browserThinkingTime, browserModelStrategy, browserResearchMode, browserArchive, browserFollowUps, browserKeepBrowser, dryRun, slug, } = parsedInput;
         const { config: userConfig } = await loadUserConfig();
         const { runOptions, resolvedEngine } = mapConsultToRunOptions({
             prompt,
@@ -322,6 +337,7 @@ export function registerConsultTool(server) {
             search,
             browserAttachments,
             browserBundleFiles,
+            browserBundleFormat,
             browserFollowUps,
             userConfig,
             env: process.env,

package/dist/src/mcp/types.js

@@ -11,6 +11,7 @@ export const consultInputSchema = z
     browserModelLabel: z.string().optional(),
     browserAttachments: z.enum(["auto", "never", "always"]).optional(),
     browserBundleFiles: z.boolean().optional(),
+    browserBundleFormat: z.enum(["text", "zip"]).optional(),
     browserThinkingTime: z.enum(["light", "standard", "extended", "heavy"]).optional(),
     browserModelStrategy: z.enum(["select", "current", "ignore"]).optional(),
     browserResearchMode: z.enum(["deep"]).optional(),

package/dist/src/mcp/utils.js

@@ -1,6 +1,6 @@
 import { resolveRunOptionsFromConfig } from "../cli/runOptions.js";
 import { Launcher } from "chrome-launcher";
-export function mapConsultToRunOptions({ prompt, files, model, models, engine, search, browserAttachments, browserBundleFiles, browserFollowUps, userConfig, env = process.env, }) {
+export function mapConsultToRunOptions({ prompt, files, model, models, engine, search, browserAttachments, browserBundleFiles, browserBundleFormat, browserFollowUps, userConfig, env = process.env, }) {
     // Normalize CLI-style inputs through the shared resolver so config/env defaults apply,
     // then overlay MCP-only overrides such as explicit search toggles.
     const mergedModels = Array.isArray(models) && models.length > 0
@@ -24,6 +24,9 @@ export function mapConsultToRunOptions({ prompt, files, model, models, engine, s
     if (typeof browserBundleFiles === "boolean") {
         result.runOptions.browserBundleFiles = browserBundleFiles;
     }
+    if (browserBundleFormat) {
+        result.runOptions.browserBundleFormat = browserBundleFormat;
+    }
     if (Array.isArray(browserFollowUps)) {
         result.runOptions.browserFollowUps = browserFollowUps
             .map((entry) => entry.trim())

package/dist/src/oracle/baseUrl.js

@@ -0,0 +1,17 @@
+const NATIVE_API_HOSTS = [
+    "api.openai.com",
+    "api.anthropic.com",
+    "generativelanguage.googleapis.com",
+    "api.x.ai",
+];
+export function isCustomBaseUrl(baseUrl) {
+    if (!baseUrl)
+        return false;
+    try {
+        const url = new URL(baseUrl);
+        return !NATIVE_API_HOSTS.some((host) => url.hostname === host || url.hostname.endsWith(`.${host}`));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/oracle/client.js

@@ -4,28 +4,7 @@ import { createRequire } from "node:module";
 import { createGeminiClient } from "./gemini.js";
 import { createClaudeClient } from "./claude.js";
 import { isOpenRouterBaseUrl } from "./modelResolver.js";
-/**
- * Known native API base URLs that should still use their dedicated SDKs.
- * Any other custom base URL is treated as an OpenAI-compatible proxy and
- * all models are routed through the chat/completions adapter.
- */
-const NATIVE_API_HOSTS = [
-    "api.openai.com",
-    "api.anthropic.com",
-    "generativelanguage.googleapis.com",
-    "api.x.ai",
-];
-export function isCustomBaseUrl(baseUrl) {
-    if (!baseUrl)
-        return false;
-    try {
-        const url = new URL(baseUrl);
-        return !NATIVE_API_HOSTS.some((host) => url.hostname === host || url.hostname.endsWith(`.${host}`));
-    }
-    catch {
-        return false;
-    }
-}
+import { isCustomBaseUrl } from "./baseUrl.js";
 export function buildAzureResponsesBaseUrl(endpoint) {
     return `${endpoint.replace(/\/+$/, "")}/openai/v1`;
 }

package/dist/src/oracle/config.js

@@ -1,7 +1,9 @@
-import { countTokens as countTokensGpt5 } from "gpt-tokenizer/model/gpt-5";
-import { countTokens as countTokensGpt5Pro } from "gpt-tokenizer/model/gpt-5-pro";
-import { countTokens as countTokensAnthropicRaw } from "@anthropic-ai/tokenizer";
+import { createRequire } from "node:module";
 import { stringifyTokenizerInput } from "./tokenStringifier.js";
+const require = createRequire(import.meta.url);
+let countTokensGpt5Impl;
+let countTokensGpt5ProImpl;
+let countTokensAnthropicImpl;
 export const DEFAULT_MODEL = "gpt-5.5-pro";
 export const PRO_MODELS = new Set([
     "gpt-5.5-pro",
@@ -12,7 +14,18 @@ export const PRO_MODELS = new Set([
     "claude-4.6-sonnet",
     "claude-4.1-opus",
 ]);
-const countTokensAnthropic = (input) => countTokensAnthropicRaw(stringifyTokenizerInput(input));
+const countTokensGpt5 = (input, options) => {
+    countTokensGpt5Impl ??= require("gpt-tokenizer/model/gpt-5").countTokens;
+    return countTokensGpt5Impl(input, options);
+};
+const countTokensGpt5Pro = (input, options) => {
+    countTokensGpt5ProImpl ??= require("gpt-tokenizer/model/gpt-5-pro").countTokens;
+    return countTokensGpt5ProImpl(input, options);
+};
+const countTokensAnthropic = (input) => {
+    countTokensAnthropicImpl ??= require("@anthropic-ai/tokenizer").countTokens;
+    return countTokensAnthropicImpl(stringifyTokenizerInput(input));
+};
 export const MODEL_CONFIGS = {
     "gpt-5.5-pro": {
         model: "gpt-5.5-pro",

package/dist/src/oracle/gemini.js

@@ -1,26 +1,6 @@
 import { GoogleGenAI, HarmCategory, HarmBlockThreshold, } from "@google/genai";
-const MODEL_ID_MAP = {
-    "gemini-3.1-pro": "gemini-3.1-pro-preview",
-    "gemini-3-pro": "gemini-3-pro-preview",
-    "gpt-5.5": "gpt-5.5",
-    "gpt-5.5-pro": "gpt-5.5-pro",
-    "gpt-5.4": "gpt-5.4",
-    "gpt-5.4-pro": "gpt-5.4-pro",
-    "gpt-5.1-pro": "gpt-5.1-pro",
-    "gpt-5-pro": "gpt-5-pro",
-    "gpt-5.1": "gpt-5.1",
-    "gpt-5.1-codex": "gpt-5.1-codex",
-    "gpt-5.2": "gpt-5.2",
-    "gpt-5.2-instant": "gpt-5.2-instant",
-    "gpt-5.2-pro": "gpt-5.2-pro",
-    "claude-4.6-sonnet": "claude-4.6-sonnet",
-    "claude-4.1-opus": "claude-4.1-opus",
-    "grok-4.1": "grok-4.1",
-};
-export function resolveGeminiModelId(modelName) {
-    // Map our logical Gemini names to the exact model ids expected by the SDK.
-    return MODEL_ID_MAP[modelName] ?? modelName;
-}
+import { resolveGeminiModelId } from "./geminiModels.js";
+export { resolveGeminiModelId } from "./geminiModels.js";
 export function createGeminiClient(apiKey, modelName = "gemini-3-pro", resolvedModelId) {
     const modelId = resolvedModelId ?? resolveGeminiModelId(modelName);
     const genAI = new GoogleGenAI({ apiKey });

package/dist/src/oracle/geminiModels.js

@@ -0,0 +1,21 @@
+const MODEL_ID_MAP = {
+    "gemini-3.1-pro": "gemini-3.1-pro-preview",
+    "gemini-3-pro": "gemini-3-pro-preview",
+    "gpt-5.5": "gpt-5.5",
+    "gpt-5.5-pro": "gpt-5.5-pro",
+    "gpt-5.4": "gpt-5.4",
+    "gpt-5.4-pro": "gpt-5.4-pro",
+    "gpt-5.1-pro": "gpt-5.1-pro",
+    "gpt-5-pro": "gpt-5-pro",
+    "gpt-5.1": "gpt-5.1",
+    "gpt-5.1-codex": "gpt-5.1-codex",
+    "gpt-5.2": "gpt-5.2",
+    "gpt-5.2-instant": "gpt-5.2-instant",
+    "gpt-5.2-pro": "gpt-5.2-pro",
+    "claude-4.6-sonnet": "claude-4.6-sonnet",
+    "claude-4.1-opus": "claude-4.1-opus",
+    "grok-4.1": "grok-4.1",
+};
+export function resolveGeminiModelId(modelName) {
+    return MODEL_ID_MAP[modelName] ?? modelName;
+}

package/dist/src/oracle/modelResolver.js

@@ -1,8 +1,14 @@
+import { createRequire } from "node:module";
 import { MODEL_CONFIGS, PRO_MODELS } from "./config.js";
-import { countTokens as countTokensGpt5Pro } from "gpt-tokenizer/model/gpt-5-pro";
 import { pricingFromUsdPerMillion } from "tokentally";
 const OPENROUTER_DEFAULT_BASE = "https://openrouter.ai/api/v1";
 const OPENROUTER_MODELS_ENDPOINT = "https://openrouter.ai/api/v1/models";
+const require = createRequire(import.meta.url);
+let countTokensGpt5ProImpl;
+const countTokensGpt5Pro = (input, options) => {
+    countTokensGpt5ProImpl ??= require("gpt-tokenizer/model/gpt-5-pro").countTokens;
+    return countTokensGpt5ProImpl(input, options);
+};
 export function isKnownModel(model) {
     return Object.hasOwn(MODEL_CONFIGS, model);
 }