@steipete/oracle 0.4.0

package/dist/src/cli/notifier.js

@@ -0,0 +1,300 @@
+import notifier from 'toasted-notifier';
+import { spawn } from 'node:child_process';
+import { formatUSD, formatNumber } from '../oracle/format.js';
+import { MODEL_CONFIGS } from '../oracle/config.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+const ORACLE_EMOJI = '🧿';
+export function resolveNotificationSettings({ cliNotify, cliNotifySound, env, config, }) {
+    const defaultEnabled = !(bool(env.CI) || bool(env.SSH_CONNECTION) || muteByConfig(env, config));
+    const envNotify = parseToggle(env.ORACLE_NOTIFY);
+    const envSound = parseToggle(env.ORACLE_NOTIFY_SOUND);
+    const enabled = cliNotify ?? envNotify ?? config?.enabled ?? defaultEnabled;
+    const sound = cliNotifySound ?? envSound ?? config?.sound ?? false;
+    return { enabled, sound };
+}
+export function deriveNotificationSettingsFromMetadata(metadata, env, config) {
+    if (metadata?.notifications) {
+        return metadata.notifications;
+    }
+    return resolveNotificationSettings({ cliNotify: undefined, cliNotifySound: undefined, env, config });
+}
+export async function sendSessionNotification(payload, settings, log, answerPreview) {
+    if (!settings.enabled || isTestEnv(process.env)) {
+        return;
+    }
+    const title = `Oracle${ORACLE_EMOJI} finished`;
+    const message = buildMessage(payload, sanitizePreview(answerPreview));
+    try {
+        if (await tryMacNativeNotifier(title, message, settings)) {
+            return;
+        }
+        if (!(await shouldSkipToastedNotifier())) {
+            // Fallback to toasted-notifier (cross-platform). macAppIconOption() is only honored on macOS.
+            await notifier.notify({
+                title,
+                message,
+                sound: settings.sound,
+            });
+            return;
+        }
+    }
+    catch (error) {
+        if (isMacExecError(error)) {
+            const repaired = await repairMacNotifier(log);
+            if (repaired) {
+                try {
+                    await notifier.notify({ title, message, sound: settings.sound, ...(macAppIconOption()) });
+                    return;
+                }
+                catch (retryError) {
+                    const reason = describeNotifierError(retryError);
+                    log(`(notify skipped after retry: ${reason})`);
+                    return;
+                }
+            }
+        }
+        if (isMacBadCpuError(error)) {
+            const reason = describeNotifierError(error);
+            log(`(notify skipped: ${reason})`);
+            return;
+        }
+        const reason = describeNotifierError(error);
+        log(`(notify skipped: ${reason})`);
+    }
+    // Last-resort macOS fallback: AppleScript alert (simple, noisy, but works when helpers are blocked).
+    if (process.platform === 'darwin') {
+        try {
+            await sendOsascriptAlert(title, message, log);
+            return;
+        }
+        catch (scriptError) {
+            const reason = describeNotifierError(scriptError);
+            log(`(notify skipped: osascript fallback failed: ${reason})`);
+        }
+    }
+}
+function buildMessage(payload, answerPreview) {
+    const parts = [];
+    const sessionLabel = payload.sessionName || payload.sessionId;
+    parts.push(sessionLabel);
+    // Show cost only for API runs.
+    if (payload.mode === 'api') {
+        const cost = payload.costUsd ?? inferCost(payload);
+        if (cost !== undefined) {
+            // Round to $0.00 for a concise toast.
+            parts.push(formatUSD(Number(cost.toFixed(2))));
+        }
+    }
+    if (payload.characters != null) {
+        parts.push(`${formatNumber(payload.characters)} chars`);
+    }
+    if (answerPreview) {
+        parts.push(answerPreview);
+    }
+    return parts.join(' · ');
+}
+function sanitizePreview(preview) {
+    if (!preview)
+        return undefined;
+    let text = preview;
+    // Strip code fences and inline code markers.
+    text = text.replace(/```[\s\S]*?```/g, ' ');
+    text = text.replace(/`([^`]+)`/g, '$1');
+    // Convert markdown links and images to their visible text.
+    text = text.replace(/!\[([^\]]*)\]\([^)]+\)/g, '$1');
+    text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');
+    // Drop bold/italic markers.
+    text = text.replace(/(\*\*|__|\*|_)/g, '');
+    // Remove headings / list markers / blockquotes.
+    text = text.replace(/^\s*#+\s*/gm, '');
+    text = text.replace(/^\s*[-*+]\s+/gm, '');
+    text = text.replace(/^\s*>\s+/gm, '');
+    // Collapse whitespace and trim.
+    text = text.replace(/\s+/g, ' ').trim();
+    // Limit length to keep notifications short.
+    const max = 200;
+    if (text.length > max) {
+        text = `${text.slice(0, max - 1)}…`;
+    }
+    return text;
+}
+// Exposed for unit tests only.
+export const testHelpers = { sanitizePreview };
+function inferCost(payload) {
+    const model = payload.model;
+    const usage = payload.usage;
+    if (!model || !usage)
+        return undefined;
+    const config = MODEL_CONFIGS[model];
+    if (!config?.pricing)
+        return undefined;
+    return (usage.inputTokens * config.pricing.inputPerToken +
+        usage.outputTokens * config.pricing.outputPerToken);
+}
+function parseToggle(value) {
+    if (value == null)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (['1', 'true', 'yes', 'on'].includes(normalized))
+        return true;
+    if (['0', 'false', 'no', 'off'].includes(normalized))
+        return false;
+    return undefined;
+}
+function bool(value) {
+    return Boolean(value && String(value).length > 0);
+}
+function isMacExecError(error) {
+    return Boolean(process.platform === 'darwin' &&
+        error &&
+        typeof error === 'object' &&
+        'code' in error &&
+        error.code === 'EACCES');
+}
+function isMacBadCpuError(error) {
+    return Boolean(process.platform === 'darwin' &&
+        error &&
+        typeof error === 'object' &&
+        'errno' in error &&
+        error.errno === -86);
+}
+async function repairMacNotifier(log) {
+    const binPath = macNotifierPath();
+    if (!binPath)
+        return false;
+    try {
+        await fs.chmod(binPath, 0o755);
+        return true;
+    }
+    catch (chmodError) {
+        const reason = chmodError instanceof Error ? chmodError.message : String(chmodError);
+        log(`(notify repair failed: ${reason} — try: xattr -dr com.apple.quarantine "${path.dirname(binPath)}")`);
+        return false;
+    }
+}
+function macNotifierPath() {
+    if (process.platform !== 'darwin')
+        return null;
+    try {
+        const req = createRequire(import.meta.url);
+        const modPath = req.resolve('toasted-notifier');
+        const base = path.dirname(modPath);
+        return path.join(base, 'vendor', 'mac.noindex', 'terminal-notifier.app', 'Contents', 'MacOS', 'terminal-notifier');
+    }
+    catch {
+        return null;
+    }
+}
+async function shouldSkipToastedNotifier() {
+    if (process.platform !== 'darwin')
+        return false;
+    // On Apple Silicon without Rosetta, prefer the native helper and skip x86-only fallback.
+    const arch = process.arch;
+    if (arch !== 'arm64')
+        return false;
+    return !(await hasRosetta());
+}
+async function hasRosetta() {
+    return new Promise((resolve) => {
+        const child = spawn('pkgutil', ['--files', 'com.apple.pkg.RosettaUpdateAuto'], { stdio: 'ignore' });
+        child.on('exit', (code) => resolve(code === 0));
+        child.on('error', () => resolve(false));
+    });
+}
+async function sendOsascriptAlert(title, message, _log) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('osascript', ['-e', `display notification "${escapeAppleScript(message)}" with title "${escapeAppleScript(title)}"`], {
+            stdio: 'ignore',
+        });
+        child.on('exit', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`osascript exited with code ${code ?? -1}`));
+            }
+        });
+        child.on('error', reject);
+    });
+}
+function escapeAppleScript(value) {
+    return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+function macAppIconOption() {
+    if (process.platform !== 'darwin')
+        return {};
+    const iconPaths = [
+        path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../assets-oracle-icon.png'),
+        path.resolve(process.cwd(), 'assets-oracle-icon.png'),
+    ];
+    for (const candidate of iconPaths) {
+        if (candidate && fsExistsSync(candidate)) {
+            return { appIcon: candidate };
+        }
+    }
+    return {};
+}
+function fsExistsSync(target) {
+    try {
+        return Boolean(require('node:fs').statSync(target));
+    }
+    catch {
+        return false;
+    }
+}
+async function tryMacNativeNotifier(title, message, settings) {
+    const binary = macNativeNotifierPath();
+    if (!binary)
+        return false;
+    return new Promise((resolve) => {
+        const child = spawn(binary, [title, message, settings.sound ? 'Glass' : ''], {
+            stdio: 'ignore',
+        });
+        child.on('error', () => resolve(false));
+        child.on('exit', (code) => resolve(code === 0));
+    });
+}
+function macNativeNotifierPath() {
+    if (process.platform !== 'darwin')
+        return null;
+    const candidates = [
+        path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../vendor/oracle-notifier/OracleNotifier.app/Contents/MacOS/OracleNotifier'),
+        path.resolve(process.cwd(), 'vendor/oracle-notifier/OracleNotifier.app/Contents/MacOS/OracleNotifier'),
+    ];
+    for (const candidate of candidates) {
+        if (fsExistsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function muteByConfig(env, config) {
+    if (!config?.muteIn)
+        return false;
+    return ((config.muteIn.includes('CI') && bool(env.CI)) ||
+        (config.muteIn.includes('SSH') && bool(env.SSH_CONNECTION)));
+}
+function isTestEnv(env) {
+    return (env.ORACLE_DISABLE_NOTIFICATIONS === '1' ||
+        env.NODE_ENV === 'test' ||
+        Boolean(env.VITEST || env.VITEST_WORKER_ID || env.JEST_WORKER_ID));
+}
+function describeNotifierError(error) {
+    if (error && typeof error === 'object') {
+        const err = error;
+        if (typeof err.errno === 'number' || typeof err.code === 'string') {
+            const errno = typeof err.errno === 'number' ? err.errno : undefined;
+            // macOS returns errno -86 for “Bad CPU type in executable” (e.g., wrong arch or quarantined binary).
+            if (errno === -86) {
+                return 'notifier binary failed to launch (Bad CPU type/quarantine); try xattr -dr com.apple.quarantine vendor/oracle-notifier && ./vendor/oracle-notifier/build-notifier.sh';
+            }
+        }
+        if (typeof err.message === 'string') {
+            return err.message;
+        }
+    }
+    return typeof error === 'string' ? error : String(error);
+}

package/dist/src/cli/options.js

@@ -0,0 +1,193 @@
+import { InvalidArgumentError } from 'commander';
+import { DEFAULT_MODEL, MODEL_CONFIGS } from '../oracle.js';
+export function collectPaths(value, previous = []) {
+    if (!value) {
+        return previous;
+    }
+    const nextValues = Array.isArray(value) ? value : [value];
+    return previous.concat(nextValues.flatMap((entry) => entry.split(',')).map((entry) => entry.trim()).filter(Boolean));
+}
+/**
+ * Merge all path-like CLI inputs (file/include aliases) into a single list, preserving order.
+ */
+export function mergePathLikeOptions(file, include, filesAlias, pathAlias, pathsAlias) {
+    const withFile = collectPaths(file, []);
+    const withInclude = collectPaths(include, withFile);
+    const withFilesAlias = collectPaths(filesAlias, withInclude);
+    const withPathAlias = collectPaths(pathAlias, withFilesAlias);
+    return collectPaths(pathsAlias, withPathAlias);
+}
+export function collectModelList(value, previous = []) {
+    if (!value) {
+        return previous;
+    }
+    const entries = value
+        .split(',')
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+    return previous.concat(entries);
+}
+export function parseFloatOption(value) {
+    const parsed = Number.parseFloat(value);
+    if (Number.isNaN(parsed)) {
+        throw new InvalidArgumentError('Value must be a number.');
+    }
+    return parsed;
+}
+export function parseIntOption(value) {
+    if (value == null) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isNaN(parsed)) {
+        throw new InvalidArgumentError('Value must be an integer.');
+    }
+    return parsed;
+}
+export function parseHeartbeatOption(value) {
+    if (value == null) {
+        return 30;
+    }
+    if (typeof value === 'number') {
+        if (Number.isNaN(value) || value < 0) {
+            throw new InvalidArgumentError('Heartbeat interval must be zero or a positive number.');
+        }
+        return value;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized.length === 0) {
+        return 30;
+    }
+    if (normalized === 'false' || normalized === 'off') {
+        return 0;
+    }
+    const parsed = Number.parseFloat(normalized);
+    if (Number.isNaN(parsed) || parsed < 0) {
+        throw new InvalidArgumentError('Heartbeat interval must be zero or a positive number.');
+    }
+    return parsed;
+}
+export function usesDefaultStatusFilters(cmd) {
+    const hoursSource = cmd.getOptionValueSource?.('hours') ?? 'default';
+    const limitSource = cmd.getOptionValueSource?.('limit') ?? 'default';
+    const allSource = cmd.getOptionValueSource?.('all') ?? 'default';
+    return hoursSource === 'default' && limitSource === 'default' && allSource === 'default';
+}
+export function resolvePreviewMode(value) {
+    if (typeof value === 'string' && value.length > 0) {
+        return value;
+    }
+    if (value === true) {
+        return 'summary';
+    }
+    return undefined;
+}
+export function parseSearchOption(value) {
+    const normalized = value.trim().toLowerCase();
+    if (['on', 'true', '1', 'yes'].includes(normalized)) {
+        return true;
+    }
+    if (['off', 'false', '0', 'no'].includes(normalized)) {
+        return false;
+    }
+    throw new InvalidArgumentError('Search mode must be "on" or "off".');
+}
+export function normalizeModelOption(value) {
+    return (value ?? '').trim();
+}
+export function normalizeBaseUrl(value) {
+    const trimmed = value?.trim();
+    return trimmed?.length ? trimmed : undefined;
+}
+export function parseTimeoutOption(value) {
+    if (value == null)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'auto')
+        return 'auto';
+    const parsed = Number.parseFloat(normalized);
+    if (Number.isNaN(parsed) || parsed <= 0) {
+        throw new InvalidArgumentError('Timeout must be a positive number of seconds or "auto".');
+    }
+    return parsed;
+}
+export function resolveApiModel(modelValue) {
+    const normalized = normalizeModelOption(modelValue).toLowerCase();
+    if (normalized in MODEL_CONFIGS) {
+        return normalized;
+    }
+    if (normalized.includes('claude') && normalized.includes('sonnet')) {
+        return 'claude-4.5-sonnet';
+    }
+    if (normalized.includes('claude') && normalized.includes('opus')) {
+        return 'claude-4.1-opus';
+    }
+    if (normalized === 'claude' || normalized === 'sonnet' || /(^|\b)sonnet(\b|$)/.test(normalized)) {
+        return 'claude-4.5-sonnet';
+    }
+    if (normalized === 'opus' || normalized === 'claude-4.1') {
+        return 'claude-4.1-opus';
+    }
+    if (normalized.includes('5.0') || normalized === 'gpt-5-pro' || normalized === 'gpt-5') {
+        return 'gpt-5-pro';
+    }
+    if (normalized.includes('5-pro') && !normalized.includes('5.1')) {
+        return 'gpt-5-pro';
+    }
+    if (normalized.includes('5.1') && normalized.includes('pro')) {
+        return 'gpt-5.1-pro';
+    }
+    if (normalized.includes('codex')) {
+        if (normalized.includes('max')) {
+            throw new InvalidArgumentError('gpt-5.1-codex-max is not available yet. OpenAI has not released the API.');
+        }
+        return 'gpt-5.1-codex';
+    }
+    if (normalized.includes('gemini')) {
+        return 'gemini-3-pro';
+    }
+    throw new InvalidArgumentError(`Unsupported model "${modelValue}". Choose one of: ${Object.keys(MODEL_CONFIGS).join(', ')}`);
+}
+export function inferModelFromLabel(modelValue) {
+    const normalized = normalizeModelOption(modelValue).toLowerCase();
+    if (!normalized) {
+        return DEFAULT_MODEL;
+    }
+    if (normalized in MODEL_CONFIGS) {
+        return normalized;
+    }
+    if (normalized.includes('claude') && normalized.includes('sonnet')) {
+        return 'claude-4.5-sonnet';
+    }
+    if (normalized.includes('claude') && normalized.includes('opus')) {
+        return 'claude-4.1-opus';
+    }
+    if (normalized.includes('5.0') || normalized.includes('5-pro')) {
+        return 'gpt-5-pro';
+    }
+    if (normalized.includes('gpt-5') && normalized.includes('pro') && !normalized.includes('5.1')) {
+        return 'gpt-5-pro';
+    }
+    if (normalized.includes('codex')) {
+        return 'gpt-5.1-codex';
+    }
+    if (normalized.includes('gemini')) {
+        return 'gemini-3-pro';
+    }
+    if (normalized.includes('classic')) {
+        return 'gpt-5.1-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.1-pro';
+    }
+    if (normalized.includes('5.1') || normalized.includes('5_1')) {
+        return 'gpt-5.1';
+    }
+    if (normalized.includes('instant') || normalized.includes('thinking') || normalized.includes('fast')) {
+        return 'gpt-5.1';
+    }
+    return 'gpt-5.1';
+}

package/dist/src/cli/oscUtils.js

@@ -0,0 +1,20 @@
+// Utilities for handling OSC progress codes embedded in stored logs.
+const OSC_PROGRESS_PREFIX = '\u001b]9;4;';
+const OSC_END = '\u001b\\';
+/**
+ * Optionally removes OSC 9;4 progress sequences (used by Ghostty/WezTerm to show progress bars).
+ * Keep them when replaying to a real TTY; strip when piping to non-TTY outputs.
+ */
+export function sanitizeOscProgress(text, keepOsc) {
+    if (keepOsc) {
+        return text;
+    }
+    let current = text;
+    while (current.includes(OSC_PROGRESS_PREFIX)) {
+        const start = current.indexOf(OSC_PROGRESS_PREFIX);
+        const end = current.indexOf(OSC_END, start + OSC_PROGRESS_PREFIX.length);
+        const cutEnd = end === -1 ? start + OSC_PROGRESS_PREFIX.length : end + OSC_END.length;
+        current = `${current.slice(0, start)}${current.slice(cutEnd)}`;
+    }
+    return current;
+}

package/dist/src/cli/promptRequirement.js

@@ -0,0 +1,17 @@
+/**
+ * Determine whether the CLI should enforce a prompt requirement based on raw args and options.
+ */
+export function shouldRequirePrompt(rawArgs, options) {
+    if (rawArgs.length === 0) {
+        return !options.prompt;
+    }
+    const firstArg = rawArgs[0];
+    const bypassPrompt = Boolean(options.session ||
+        options.execSession ||
+        options.status ||
+        options.debugHelp ||
+        firstArg === 'status' ||
+        firstArg === 'session');
+    const requiresPrompt = options.renderMarkdown || Boolean(options.preview) || Boolean(options.dryRun) || !bypassPrompt;
+    return requiresPrompt && !options.prompt;
+}

package/dist/src/cli/renderFlags.js

@@ -0,0 +1,9 @@
+export function resolveRenderFlag(render, renderMarkdown) {
+    return Boolean(renderMarkdown || render);
+}
+export function resolveRenderPlain(renderPlain, render, renderMarkdown) {
+    // Explicit plain render wins when any render flag is set; otherwise false.
+    if (!renderPlain)
+        return false;
+    return Boolean(renderMarkdown || render || renderPlain);
+}

package/dist/src/cli/renderOutput.js

@@ -0,0 +1,26 @@
+import { ensureShikiReady, renderMarkdownAnsi } from './markdownRenderer.js';
+export function shouldRenderRich(options = {}) {
+    return options.richTty ?? Boolean(process.stdout.isTTY);
+}
+/**
+ * Format markdown for CLI output. Uses our ANSI renderer + syntax highlighting
+ * when running in a rich TTY; otherwise returns the raw markdown to avoid
+ * escape codes in redirected output.
+ */
+export async function formatRenderedMarkdown(markdown, options = {}) {
+    const richTty = shouldRenderRich(options);
+    if (!richTty)
+        return markdown;
+    try {
+        await ensureShikiReady();
+    }
+    catch {
+        // If Shiki fails to init (missing terminals/themes), fall back to plain output gracefully.
+    }
+    try {
+        return renderMarkdownAnsi(markdown);
+    }
+    catch {
+        return markdown;
+    }
+}

package/dist/src/cli/rootAlias.js

@@ -0,0 +1,30 @@
+import { attachSession, showStatus } from './sessionDisplay.js';
+const defaultDeps = {
+    attachSession,
+    showStatus,
+};
+export async function handleStatusFlag(options, deps = defaultDeps) {
+    if (!options.status) {
+        return false;
+    }
+    if (options.session) {
+        await deps.attachSession(options.session);
+        return true;
+    }
+    await deps.showStatus({ hours: 24, includeAll: false, limit: 100, showExamples: true });
+    return true;
+}
+const defaultSessionDeps = {
+    attachSession,
+};
+/**
+ * Hidden root-level alias to attach to a stored session (`--session <id>`).
+ * Returns true when the alias was handled so callers can short-circuit.
+ */
+export async function handleSessionAlias(options, deps = defaultSessionDeps) {
+    if (!options.session) {
+        return false;
+    }
+    await deps.attachSession(options.session);
+    return true;
+}

package/dist/src/cli/runOptions.js

@@ -0,0 +1,62 @@
+import { DEFAULT_MODEL, MODEL_CONFIGS } from '../oracle.js';
+import { resolveEngine } from './engine.js';
+import { normalizeModelOption, inferModelFromLabel, resolveApiModel, normalizeBaseUrl } from './options.js';
+import { resolveGeminiModelId } from '../oracle/gemini.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';
+    const requestedModelList = Array.isArray(models) ? models : [];
+    const normalizedRequestedModels = requestedModelList.map((entry) => normalizeModelOption(entry)).filter(Boolean);
+    const cliModelArg = normalizeModelOption(model ?? userConfig?.model) || DEFAULT_MODEL;
+    const resolvedModel = resolvedEngine === 'browser' && normalizedRequestedModels.length === 0
+        ? inferModelFromLabel(cliModelArg)
+        : resolveApiModel(cliModelArg);
+    const isGemini = resolvedModel.startsWith('gemini');
+    const isCodex = resolvedModel.startsWith('gpt-5.1-codex');
+    const isClaude = resolvedModel.startsWith('claude');
+    const engineCoercedToApi = (isGemini || isCodex || isClaude) && browserRequested;
+    // When Gemini, Claude, or Codex is selected, always force API engine (overrides config/env auto browser).
+    const fixedEngine = isGemini || isCodex || isClaude || 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 baseUrl = normalizeBaseUrl(userConfig?.apiBaseUrl ?? (isClaude ? env.ANTHROPIC_BASE_URL : env.OPENAI_BASE_URL));
+    const uniqueMultiModels = normalizedRequestedModels.length > 0
+        ? Array.from(new Set(normalizedRequestedModels.map((entry) => resolveApiModel(entry))))
+        : [];
+    const includesCodexMultiModel = uniqueMultiModels.some((entry) => entry.startsWith('gpt-5.1-codex'));
+    if (includesCodexMultiModel && browserRequested) {
+        // Silent coerce; multi-model still forces API.
+    }
+    const chosenModel = uniqueMultiModels[0] ?? resolvedModel;
+    const effectiveModelId = resolveEffectiveModelId(chosenModel);
+    const runOptions = {
+        prompt: promptWithSuffix,
+        model: chosenModel,
+        models: uniqueMultiModels.length > 0 ? uniqueMultiModels : undefined,
+        file: files ?? [],
+        search,
+        heartbeatIntervalMs,
+        filesReport: userConfig?.filesReport,
+        background: userConfig?.background,
+        baseUrl,
+        effectiveModelId,
+    };
+    return { runOptions, resolvedEngine: fixedEngine, engineCoercedToApi };
+}
+function resolveEngineWithConfig({ engine, configEngine, env, }) {
+    if (engine)
+        return engine;
+    if (configEngine)
+        return configEngine;
+    return resolveEngine({ engine: undefined, env });
+}
+function resolveEffectiveModelId(model) {
+    if (model.startsWith('gemini')) {
+        return resolveGeminiModelId(model);
+    }
+    const config = MODEL_CONFIGS[model];
+    return config?.apiModel ?? model;
+}