@steipete/oracle 0.16.1 → 0.17.0

package/dist/src/cli/sessionDisplay.js

@@ -12,6 +12,7 @@ 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";
 const isTty = () => Boolean(process.stdout.isTTY);
 const dim = (text) => (isTty() ? kleur.dim(text) : text);
 export const MAX_RENDER_BYTES = 200_000;
@@ -185,6 +186,7 @@ export async function attachSession(sessionId, options) {
     const isVerbose = Boolean(process.env.ORACLE_VERBOSE_RENDER);
     const runtime = metadata.browser?.runtime;
     const controllerAlive = isProcessAlive(runtime?.controllerPid);
+    const workerAlive = isProcessAlive(metadata.lifecycle?.workerPid);
     const hasChromeDisconnect = metadata.response?.incompleteReason === "chrome-disconnected";
     const hasIncompleteCapture = metadata.response?.incompleteReason === "incomplete-capture";
     const statusAllowsReattach = metadata.status === "running" ||
@@ -204,6 +206,7 @@ export async function attachSession(sessionId, options) {
     const canReattach = (statusAllowsReattach || completedDeepResearchPlaceholder) &&
         metadata.mode === "browser" &&
         hasFallbackSessionInfo &&
+        !workerAlive &&
         (hasRecoverableConversation ||
             runtime?.promptSubmitted ||
             hasLiveChromeFallback ||
@@ -311,11 +314,17 @@ export async function attachSession(sessionId, options) {
                 const usage = run.usage
                     ? ` tok=${formatTokenCount(run.usage.outputTokens ?? 0)}/${formatTokenCount(run.usage.totalTokens ?? 0)}`
                     : "";
-                console.log(`- ${chalk.cyan(run.model)} — ${run.status}${usage}`);
+                const modelLabel = (metadata.mode ?? metadata.options?.mode) === "browser"
+                    ? formatSessionBrowserModelWithRequestedKey(metadata, run.model)
+                    : run.model;
+                console.log(`- ${chalk.cyan(modelLabel)} — ${run.status}${usage}`);
             }
         }
         else if (metadata.model) {
-            console.log(`Model: ${metadata.model}`);
+            const modelLabel = (metadata.mode ?? metadata.options?.mode) === "browser"
+                ? formatSessionBrowserModelWithRequestedKey(metadata)
+                : metadata.model;
+            console.log(`Model: ${modelLabel}`);
         }
         const browserEvidence = formatBrowserEvidence(metadata);
         if (browserEvidence) {
@@ -391,6 +400,9 @@ export async function attachSession(sessionId, options) {
         if (summary) {
             console.log(`\n${chalk.green.bold(summary)}`);
         }
+        if (options?.propagateFailure && metadata.status === "error") {
+            process.exitCode = 1;
+        }
         return;
     }
     if (wantsRender) {
@@ -493,6 +505,48 @@ export async function attachSession(sessionId, options) {
                     }
                 }
             }
+            if (options?.propagateFailure && latest.status === "error") {
+                process.exitCode = 1;
+            }
+            break;
+        }
+        const controllerPid = latest.lifecycle?.workerPid ?? latest.browser?.runtime?.controllerPid;
+        if (latest.lifecycle?.detached && controllerPid && !isProcessAlive(controllerPid)) {
+            const settled = await sessionStore.readSession(sessionId);
+            if (!settled) {
+                break;
+            }
+            if (settled.status === "completed" || settled.status === "partial") {
+                continue;
+            }
+            await printNew();
+            flushRemainder();
+            const message = settled.status === "error"
+                ? (settled.errorMessage ?? "Detached worker failed.")
+                : "Detached worker exited before the session reached a terminal state.";
+            const failure = {
+                category: "internal",
+                message,
+            };
+            if (settled.model) {
+                await sessionStore.updateModelRun(settled.id, settled.model, {
+                    status: "error",
+                    completedAt: new Date().toISOString(),
+                    response: { status: "incomplete", incompleteReason: "incomplete-capture" },
+                    error: failure,
+                });
+            }
+            await sessionStore.updateSession(settled.id, {
+                status: "error",
+                completedAt: new Date().toISOString(),
+                errorMessage: message,
+                response: { status: "incomplete", incompleteReason: "incomplete-capture" },
+                error: failure,
+            });
+            console.log(chalk.yellow(`${message} Reattach via: ${settled.lifecycle?.reattachCommand}`));
+            if (options?.propagateFailure) {
+                process.exitCode = 1;
+            }
             break;
         }
         await wait(1000);
@@ -555,11 +609,7 @@ export function formatBrowserEvidence(metadata) {
     const lines = [];
     const evidence = browser.modelSelection;
     if (evidence) {
-        const requested = evidence.requestedModel ?? "(none)";
-        const resolved = evidence.resolvedLabel ?? "(unavailable)";
-        const strategy = evidence.strategy ?? "(default)";
-        const verified = evidence.verified ? "yes" : "no";
-        lines.push(`model requested=${requested}; resolved=${resolved}; status=${evidence.status}; strategy=${strategy}; verified=${verified}`);
+        lines.push(`model ${formatBrowserModelSelectionEvidence(evidence, metadata.model)}`);
     }
     for (const warning of browser.warnings ?? []) {
         lines.push(`warning ${warning.code}: ${warning.message}`);
@@ -821,7 +871,9 @@ export function formatCompletionSummary(metadata, options = {}) {
     if (!metadata.usage || metadata.elapsedMs == null) {
         return null;
     }
-    const modeLabel = metadata.mode === "browser" ? `${metadata.model ?? "n/a"}[browser]` : (metadata.model ?? "n/a");
+    const modeLabel = (metadata.mode ?? metadata.options?.mode) === "browser"
+        ? `${resolveSessionBrowserModelDisplayName(metadata)}[browser]`
+        : (metadata.model ?? "n/a");
     const usage = metadata.usage;
     const cost = resolveSessionCost(metadata);
     const tokensDisplay = [

package/dist/src/cli/sessionLifecycle.js

@@ -1,9 +1,10 @@
-export function buildSessionLifecycle({ engine, detached, reattachCommand, }) {
+export function buildSessionLifecycle({ engine, detached, workerPid, reattachCommand, }) {
     return {
         engine,
         execution: detached ? "background" : "foreground",
         attached: !detached,
         detached,
+        workerPid,
         reattachCommand,
     };
 }

package/dist/src/cli/sessionRunner.js

@@ -78,6 +78,15 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 cwd,
                 log,
             }, runnerDeps);
+            await writeAssistantOutput(runOptions.writeOutputPath, result.answerText ?? "", log);
+            await sendSessionNotification({
+                sessionId: sessionMeta.id,
+                sessionName: sessionMeta.options?.slug ?? sessionMeta.id,
+                mode,
+                model: sessionMeta.model,
+                usage: result.usage,
+                characters: result.answerText?.length,
+            }, notificationSettings, log, result.answerText?.slice(0, 140));
             if (modelForStatus) {
                 await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
                     status: "completed",
@@ -103,15 +112,6 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 transport: undefined,
                 error: undefined,
             });
-            await writeAssistantOutput(runOptions.writeOutputPath, result.answerText ?? "", log);
-            await sendSessionNotification({
-                sessionId: sessionMeta.id,
-                sessionName: sessionMeta.options?.slug ?? sessionMeta.id,
-                mode,
-                model: sessionMeta.model,
-                usage: result.usage,
-                characters: result.answerText?.length,
-            }, notificationSettings, log, result.answerText?.slice(0, 140));
             return;
         }
         const multiModels = Array.isArray(runOptions.models) ? runOptions.models.filter(Boolean) : [];
@@ -362,16 +362,6 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
         if (result.mode !== "live") {
             throw new Error("Unexpected preview result while running a session.");
         }
-        await sessionStore.updateSession(sessionMeta.id, {
-            status: "completed",
-            completedAt: new Date().toISOString(),
-            usage: result.usage,
-            elapsedMs: result.elapsedMs,
-            errorMessage: undefined,
-            response: extractResponseMetadata(result.response),
-            transport: undefined,
-            error: undefined,
-        });
         if (modelForStatus && singleModelOverride == null) {
             await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
                 status: "completed",
@@ -389,6 +379,16 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             usage: result.usage,
             characters: answerText.length,
         }, notificationSettings, log, answerText.slice(0, 140));
+        await sessionStore.updateSession(sessionMeta.id, {
+            status: "completed",
+            completedAt: new Date().toISOString(),
+            usage: result.usage,
+            elapsedMs: result.elapsedMs,
+            errorMessage: undefined,
+            response: extractResponseMetadata(result.response),
+            transport: undefined,
+            error: undefined,
+        });
     }
     catch (error) {
         const message = formatError(error);
@@ -510,16 +510,60 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             const runtime = userError.details
                 ?.runtime;
             log(dim("Assistant response timed out; marking capture incomplete for reattach."));
+            const timeoutResponse = {
+                status: "incomplete",
+                incompleteReason: "incomplete-capture",
+            };
+            const timeoutError = {
+                category: userError.category,
+                message: userError.message,
+                details: userError.details,
+            };
+            const autoReattachIntervalMs = browserConfig?.autoReattachIntervalMs ?? 0;
+            const autoRuntime = runtime ?? currentBrowser?.runtime;
+            const willAutoReattach = autoReattachIntervalMs > 0 && Boolean(autoRuntime);
+            if (willAutoReattach) {
+                if (modelForStatus) {
+                    await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
+                        status: "running",
+                        completedAt: undefined,
+                        response: timeoutResponse,
+                        error: timeoutError,
+                    });
+                }
+                await sessionStore.updateSession(sessionMeta.id, {
+                    status: "running",
+                    completedAt: undefined,
+                    errorMessage: message,
+                    mode,
+                    browser: {
+                        ...currentBrowser,
+                        config: browserConfig,
+                        runtime: autoRuntime,
+                    },
+                    response: timeoutResponse,
+                    error: timeoutError,
+                });
+                const success = await autoReattachUntilComplete({
+                    sessionMeta,
+                    runtime: autoRuntime,
+                    browserConfig,
+                    browserMetadata: currentBrowser,
+                    runOptions,
+                    modelForStatus,
+                    notificationSettings,
+                    log,
+                });
+                if (success) {
+                    return;
+                }
+            }
             if (modelForStatus) {
                 await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
                     status: "error",
                     completedAt: new Date().toISOString(),
-                    response: { status: "incomplete", incompleteReason: "incomplete-capture" },
-                    error: {
-                        category: userError.category,
-                        message: userError.message,
-                        details: userError.details,
-                    },
+                    response: timeoutResponse,
+                    error: timeoutError,
                 });
             }
             await sessionStore.updateSession(sessionMeta.id, {
@@ -532,30 +576,9 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                     config: browserConfig,
                     runtime: runtime ?? currentBrowser?.runtime,
                 },
-                response: { status: "incomplete", incompleteReason: "incomplete-capture" },
-                error: {
-                    category: userError.category,
-                    message: userError.message,
-                    details: userError.details,
-                },
+                response: timeoutResponse,
+                error: timeoutError,
             });
-            const autoReattachIntervalMs = browserConfig?.autoReattachIntervalMs ?? 0;
-            if (autoReattachIntervalMs > 0) {
-                const autoRuntime = runtime ?? currentBrowser?.runtime;
-                const success = await autoReattachUntilComplete({
-                    sessionMeta,
-                    runtime: autoRuntime ?? undefined,
-                    browserConfig,
-                    browserMetadata: currentBrowser,
-                    runOptions,
-                    modelForStatus,
-                    notificationSettings,
-                    log,
-                });
-                if (success) {
-                    return;
-                }
-            }
             logBrowserReattachGuidance(runtime ?? currentBrowser?.runtime);
             return;
         }
@@ -911,6 +934,7 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
         }
         attempt += 1;
         log(dim(`Auto-reattach attempt ${attempt}...`));
+        let captureSucceeded = false;
         try {
             const reattachConfig = {
                 ...browserConfig,
@@ -919,6 +943,7 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
             const result = await resumeBrowserSession(runtime, reattachConfig, logger, {
                 promptPreview: sessionMeta.promptPreview,
             });
+            captureSucceeded = true;
             const answerText = result.answerMarkdown || result.answerText || "";
             const outputTokens = estimateTokenCount(answerText);
             const artifacts = await ensureSessionArtifacts({
@@ -947,6 +972,18 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
                     },
                 });
             }
+            await writeAssistantOutput(runOptions.writeOutputPath, answerText, log);
+            await sendSessionNotification({
+                sessionId: sessionMeta.id,
+                sessionName: sessionMeta.options?.slug ?? sessionMeta.id,
+                mode: sessionMeta.mode ?? "browser",
+                model: sessionMeta.model ?? runOptions.model,
+                usage: {
+                    inputTokens: 0,
+                    outputTokens,
+                },
+                characters: answerText.length,
+            }, notificationSettings, log, answerText.slice(0, 140));
             await sessionStore.updateSession(sessionMeta.id, {
                 status: "completed",
                 completedAt: new Date().toISOString(),
@@ -967,22 +1004,35 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
                 error: undefined,
                 transport: undefined,
             });
-            await writeAssistantOutput(runOptions.writeOutputPath, answerText, log);
-            await sendSessionNotification({
-                sessionId: sessionMeta.id,
-                sessionName: sessionMeta.options?.slug ?? sessionMeta.id,
-                mode: sessionMeta.mode ?? "browser",
-                model: sessionMeta.model ?? runOptions.model,
-                usage: {
-                    inputTokens: 0,
-                    outputTokens,
-                },
-                characters: answerText.length,
-            }, notificationSettings, log, answerText.slice(0, 140));
             log(kleur.green("Auto-reattach succeeded; session marked completed."));
             return true;
         }
         catch (error) {
+            if (captureSucceeded) {
+                const message = formatError(error);
+                if (modelForStatus) {
+                    await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
+                        status: "error",
+                        completedAt: new Date().toISOString(),
+                    });
+                }
+                await sessionStore.updateSession(sessionMeta.id, {
+                    status: "error",
+                    completedAt: new Date().toISOString(),
+                    errorMessage: message,
+                    browser: {
+                        ...browserMetadata,
+                        config: browserConfig,
+                        runtime,
+                    },
+                    response: { status: "error", incompleteReason: "incomplete-capture" },
+                    error: {
+                        category: "internal",
+                        message,
+                    },
+                });
+                throw error;
+            }
             const message = error instanceof Error ? error.message : String(error);
             log(dim(`Auto-reattach attempt ${attempt} failed: ${message}`));
         }

package/dist/src/cli/sessionTable.js

@@ -3,6 +3,7 @@ import kleur from "kleur";
 import { MODEL_CONFIGS } from "../oracle.js";
 import { estimateUsdCost } from "tokentally";
 import { formatSessionExecutionLabel } from "./sessionLifecycle.js";
+import { resolveSessionBrowserModelDisplayName } from "../browser/modelDisplay.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;
@@ -18,7 +19,10 @@ export function formatSessionTableHeader(rich) {
 export function formatSessionTableRow(meta, options) {
     const rich = isRich(options?.rich);
     const status = colorStatus(meta.status ?? "unknown", rich);
-    const modelLabel = (meta.model ?? "n/a").padEnd(MODEL_PAD);
+    const displayModel = (meta.mode ?? meta.options?.mode) === "browser"
+        ? resolveSessionBrowserModelDisplayName(meta)
+        : (meta.model ?? "n/a");
+    const modelLabel = displayModel.padEnd(MODEL_PAD);
     const model = rich ? chalk.white(modelLabel) : modelLabel;
     const modeLabel = formatSessionExecutionLabel(meta).padEnd(MODE_PAD);
     const mode = rich ? chalk.gray(modeLabel) : modeLabel;

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

@@ -15,6 +15,7 @@ import { resolveNotificationSettings } from "../notifier.js";
 import { loadUserConfig } from "../../config.js";
 import { resolveConfiguredMaxFileSizeBytes } from "../fileSize.js";
 import { formatTokenCount } from "../../oracle/runUtils.js";
+import { formatSessionBrowserModelWithRequestedKey, resolveSessionBrowserModelDisplayName, } from "../../browser/modelDisplay.js";
 const isTty = () => Boolean(process.stdout.isTTY && chalk.level > 0);
 const dim = (text) => (isTty() ? kleur.dim(text) : text);
 const RECENT_WINDOW_HOURS = 24;
@@ -157,7 +158,7 @@ async function showSessionDetail(sessionId) {
         console.clear();
         printSessionHeader(meta);
         if (meta.models && meta.models.length > 0) {
-            printModelSummaries(meta.models);
+            printModelSummaries(meta);
         }
         const prompt = await readStoredPrompt(sessionId);
         if (prompt) {
@@ -250,7 +251,10 @@ function printSessionHeader(meta) {
     console.log(`${chalk.white("Status:")} ${meta.status}`);
     console.log(`${chalk.white("Created:")} ${meta.createdAt}`);
     if (meta.model) {
-        console.log(`${chalk.white("Model:")} ${meta.model}`);
+        const modelLabel = (meta.mode ?? meta.options?.mode) === "browser"
+            ? resolveSessionBrowserModelDisplayName(meta)
+            : meta.model;
+        console.log(`${chalk.white("Model:")} ${modelLabel}`);
     }
     const mode = meta.mode ?? meta.options?.mode;
     if (mode) {
@@ -260,7 +264,8 @@ function printSessionHeader(meta) {
         console.log(chalk.red(`Error: ${meta.errorMessage}`));
     }
 }
-function printModelSummaries(models) {
+function printModelSummaries(meta) {
+    const models = meta.models ?? [];
     if (models.length === 0) {
         return;
     }
@@ -269,7 +274,10 @@ function printModelSummaries(models) {
         const usage = run.usage
             ? ` tok=${formatTokenCount(run.usage.outputTokens ?? 0)}/${formatTokenCount(run.usage.totalTokens ?? 0)}`
             : "";
-        console.log(` - ${chalk.cyan(run.model)} — ${run.status}${usage}`);
+        const modelLabel = (meta.mode ?? meta.options?.mode) === "browser"
+            ? formatSessionBrowserModelWithRequestedKey(meta, run.model)
+            : run.model;
+        console.log(` - ${chalk.cyan(modelLabel)} — ${run.status}${usage}`);
     }
     console.log("");
 }

package/dist/src/duration.js

@@ -21,6 +21,9 @@ export function parseDuration(input, fallback) {
     let lastIndex = 0;
     let match = multiDuration.exec(normalized);
     while (match !== null) {
+        if (match.index !== lastIndex) {
+            return fallback;
+        }
         total += convertUnit(Number(match[1]), match[2]);
         lastIndex = multiDuration.lastIndex;
         match = multiDuration.exec(normalized);

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

@@ -12,11 +12,29 @@ const GEMINI_UPLOAD_MIME_TYPES = {
     ".gif": "image/gif",
     ".jpeg": "image/jpeg",
     ".jpg": "image/jpeg",
+    ".mov": "video/quicktime",
+    ".mp4": "video/mp4",
     ".pdf": "application/pdf",
     ".png": "image/png",
     ".svg": "image/svg+xml",
+    ".webm": "video/webm",
     ".webp": "image/webp",
 };
+/**
+ * Resolve the MIME type Gemini should be told an upload carries.
+ *
+ * Gemini silently discards uploads it cannot type: the run still reports the file as
+ * attached, but the model never receives it and answers as though nothing was sent.
+ * Anything falling back to `application/octet-stream` is therefore invisible to the model.
+ *
+ * Only formats confirmed to work against the Gemini web upload endpoint are listed. The
+ * endpoint also gates on the file extension, not just the declared type — an `.m4v` byte
+ * for byte identical to a working `.mp4`, and declared `video/mp4`, is still dropped — so
+ * entries here cannot be extrapolated from what the Gemini API documents.
+ */
+export function resolveGeminiUploadMimeType(filePath) {
+    return (GEMINI_UPLOAD_MIME_TYPES[path.extname(filePath).toLowerCase()] ?? "application/octet-stream");
+}
 function getNestedValue(value, pathParts, fallback) {
     let current = value;
     for (const part of pathParts) {
@@ -125,7 +143,7 @@ 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 mimeType = resolveGeminiUploadMimeType(absPath);
     const form = new FormData();
     form.append("file", new Blob([data], { type: mimeType }), fileName);
     const res = await fetch(GEMINI_UPLOAD_URL, {

package/dist/src/oracle/modelResolver.js

@@ -192,7 +192,14 @@ async function resolveBaseModelConfig(model, options = {}) {
 export function isProModel(model) {
     return isKnownModel(model) && PRO_MODELS.has(model);
 }
-const VALID_REASONING_EFFORTS = ["low", "medium", "high", "xhigh"];
+const VALID_REASONING_EFFORTS = [
+    "none",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+];
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/dist/src/oracle/request.js

@@ -11,8 +11,15 @@ export function buildPrompt(basePrompt, files, cwd = process.cwd()) {
     const sectionText = formatFileSections(sections, { includeFileIndex: true });
     return `${basePrompt.trim()}\n\n${sectionText}`;
 }
-export function buildRequestBody({ modelConfig, systemPrompt, userPrompt, searchEnabled, maxOutputTokens, background, storeResponse, previousResponseId, }) {
+export function buildRequestBody({ modelConfig, reasoningEffort, reasoningMode, systemPrompt, userPrompt, searchEnabled, maxOutputTokens, background, storeResponse, previousResponseId, }) {
     const searchToolType = modelConfig.searchToolType ?? "web_search_preview";
+    const reasoning = modelConfig.reasoning || reasoningEffort || reasoningMode
+        ? {
+            ...(modelConfig.reasoning ?? {}),
+            ...(reasoningEffort ? { effort: reasoningEffort } : {}),
+            ...(reasoningMode ? { mode: reasoningMode } : {}),
+        }
+        : undefined;
     return {
         model: modelConfig.apiModel ?? modelConfig.model,
         previous_response_id: previousResponseId ? previousResponseId : undefined,
@@ -29,7 +36,7 @@ export function buildRequestBody({ modelConfig, systemPrompt, userPrompt, search
             },
         ],
         tools: searchEnabled ? [{ type: searchToolType }] : undefined,
-        reasoning: modelConfig.reasoning || undefined,
+        reasoning,
         max_output_tokens: maxOutputTokens,
         background: background ? true : undefined,
         store: storeResponse ? true : undefined,

package/dist/src/oracle/run.js

@@ -33,6 +33,9 @@ const dim = (text) => (isStdoutTty ? kleur.dim(text) : text);
 // Default timeout for non-pro API runs (fast models) — give them up to 120s.
 const DEFAULT_TIMEOUT_NON_PRO_MS = 120_000;
 const DEFAULT_TIMEOUT_PRO_MS = 60 * 60 * 1000;
+const GPT_5_6_API_MODELS = new Set(["gpt-5.6", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"]);
+const REASONING_EFFORTS = new Set(["none", "low", "medium", "high", "xhigh", "max"]);
+const REASONING_MODES = new Set(["standard", "pro"]);
 const defaultWait = (ms) => new Promise((resolve) => {
     setTimeout(resolve, ms);
 });
@@ -69,6 +72,33 @@ function runtimeKeySource({ route, providerMode, optionsApiKey, }) {
         return "XAI_API_KEY";
     return optionsApiKey ? "apiKey option" : route.keySource;
 }
+function validateReasoningOptions(options, route) {
+    const { reasoningEffort, reasoningMode } = options;
+    if (!reasoningEffort && !reasoningMode)
+        return;
+    if (reasoningEffort && !REASONING_EFFORTS.has(reasoningEffort)) {
+        throw new PromptValidationError(`Invalid reasoning effort "${reasoningEffort}". Expected none, low, medium, high, xhigh, or max.`, { model: options.model, reasoningEffort });
+    }
+    if (reasoningMode && !REASONING_MODES.has(reasoningMode)) {
+        throw new PromptValidationError(`Invalid reasoning mode "${reasoningMode}". Expected standard or pro.`, { model: options.model, reasoningMode });
+    }
+    if (!GPT_5_6_API_MODELS.has(options.model)) {
+        const option = reasoningMode
+            ? `Reasoning mode "${reasoningMode}"`
+            : `Reasoning effort "${reasoningEffort}"`;
+        const guidance = reasoningMode
+            ? `Use --model gpt-5.6-sol --reasoning-mode ${reasoningMode}.`
+            : `Use --model gpt-5.6-sol --reasoning-effort ${reasoningEffort}.`;
+        throw new PromptValidationError(`${option} is available only for GPT-5.6 API models. ${guidance}`, { model: options.model, reasoningEffort, reasoningMode });
+    }
+    if (reasoningMode &&
+        !route.isAzureOpenAI &&
+        (route.openRouterFallback ||
+            isOpenRouterBaseUrl(route.baseUrl) ||
+            isCustomBaseUrl(route.baseUrl))) {
+        throw new PromptValidationError("--reasoning-mode requires the OpenAI or Azure OpenAI Responses API; OpenRouter and custom --base-url routes use the Chat Completions adapter.", { model: options.model, reasoningMode });
+    }
+}
 export async function runOracle(options, deps = {}) {
     const { apiKey: optionsApiKey = options.apiKey, cwd = process.cwd(), fs: fsModule = createFsAdapter(fs), log = console.log, write: sinkWrite = (_text) => true, allowStdout = true, stdoutWrite: stdoutWriteDep, now = () => performance.now(), clientFactory = createDefaultClientFactory(), client, wait = defaultWait, } = deps;
     const stdoutWrite = allowStdout
@@ -100,6 +130,7 @@ export async function runOracle(options, deps = {}) {
     const { isAzureOpenAI, azureDeploymentName } = route;
     const baseUrl = route.baseUrl;
     const openRouterFallback = route.openRouterFallback;
+    validateReasoningOptions(options, route);
     const logVerbose = (message) => {
         if (options.verbose) {
             log(dim(`[verbose] ${message}`));
@@ -125,7 +156,7 @@ export async function runOracle(options, deps = {}) {
     const minPromptLength = Number.parseInt(process.env.ORACLE_MIN_PROMPT_CHARS ?? "10", 10);
     const promptLength = options.prompt?.trim().length ?? 0;
     // Enforce the short-prompt guardrail on pro-tier models because they're costly; cheaper models can run short prompts without blocking.
-    const isProTierModel = isProModel(options.model);
+    const isProTierModel = isProModel(options.model) || options.reasoningMode === "pro";
     if (isProTierModel && !Number.isNaN(minPromptLength) && promptLength < minPromptLength) {
         throw new PromptValidationError(`Prompt is too short (<${minPromptLength} chars). This was likely accidental; please provide more detail.`, { minPromptLength, promptLength });
     }
@@ -205,6 +236,8 @@ export async function runOracle(options, deps = {}) {
     }
     const requestBody = buildRequestBody({
         modelConfig,
+        reasoningEffort: options.reasoningEffort,
+        reasoningMode: options.reasoningMode,
         systemPrompt,
         userPrompt: promptWithFiles,
         searchEnabled,
@@ -249,6 +282,12 @@ export async function runOracle(options, deps = {}) {
         if (options.background && !supportsBackground) {
             log(dim("Background runs are not supported for this model; streaming in foreground instead."));
         }
+        if (options.reasoningMode) {
+            log(dim(`Reasoning mode: ${options.reasoningMode}`));
+        }
+        if (options.reasoningEffort) {
+            log(dim(`Reasoning effort: ${options.reasoningEffort}`));
+        }
         if (!options.suppressTips) {
             if (pendingNoFilesTip) {
                 log(dim(pendingNoFilesTip));
@@ -547,8 +586,9 @@ export async function runOracle(options, deps = {}) {
             },
         })?.totalUsd
         : undefined;
-    const effortLabel = modelConfig.reasoning?.effort;
-    const modelLabel = effortLabel ? `${modelConfig.model}[${effortLabel}]` : modelConfig.model;
+    const effortLabel = options.reasoningEffort ?? modelConfig.reasoning?.effort;
+    const reasoningLabel = [options.reasoningMode, effortLabel].filter(Boolean).join("/");
+    const modelLabel = reasoningLabel ? `${modelConfig.model}[${reasoningLabel}]` : modelConfig.model;
     const sessionIdContainsModel = typeof options.sessionId === "string" &&
         options.sessionId.toLowerCase().includes(modelConfig.model.toLowerCase());
     const tokensDisplay = [inputTokens, outputTokens, reasoningTokens, totalTokens]