@steipete/oracle 0.16.1 → 0.17.1

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]

package/dist/src/oracle/thinkingTime.js

@@ -1,10 +1,15 @@
-export const THINKING_TIME_LEVELS = ["light", "standard", "extended", "heavy"];
+export const THINKING_TIME_LEVELS = [
+    "light",
+    "standard",
+    "extended",
+    "extra-high",
+    "heavy",
+];
 export const THINKING_TIME_ALIASES = [
     "instant",
     "low",
     "medium",
     "high",
-    "extra-high",
     "extra high",
     "extrahigh",
     "xhigh",
@@ -29,10 +34,11 @@ export function normalizeThinkingTimeLevel(value) {
         case "extended":
         case "high":
             return "extended";
-        case "heavy":
         case "extra-high":
         case "extrahigh":
         case "xhigh":
+            return "extra-high";
+        case "heavy":
             return "heavy";
         default:
             return null;

package/dist/src/sessionManager.js

@@ -1,6 +1,7 @@
 import path from "node:path";
 import fs from "node:fs/promises";
 import { createWriteStream, mkdirSync } from "node:fs";
+import { randomUUID } from "node:crypto";
 import net from "node:net";
 import { DEFAULT_MODEL } from "./oracle/config.js";
 import { formatElapsed } from "./oracle/format.js";
@@ -57,6 +58,20 @@ function sessionDir(id) {
 function metaPath(id) {
     return path.join(sessionDir(id), METADATA_FILENAME);
 }
+async function writeSessionMetadataFile(sessionId, metadata) {
+    const targetPath = metaPath(sessionId);
+    const temporaryPath = `${targetPath}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        await fs.writeFile(temporaryPath, JSON.stringify(metadata, null, 2), {
+            encoding: "utf8",
+            mode: 0o600,
+        });
+        await fs.rename(temporaryPath, targetPath);
+    }
+    finally {
+        await fs.rm(temporaryPath, { force: true }).catch(() => undefined);
+    }
+}
 function requestPath(id) {
     return path.join(sessionDir(id), LEGACY_REQUEST_FILENAME);
 }
@@ -193,6 +208,8 @@ export async function initializeSession(options, cwd, notifications, baseSlugOve
             maxFileSizeBytes: options.maxFileSizeBytes,
             model: options.model,
             models: modelList,
+            reasoningEffort: options.reasoningEffort,
+            reasoningMode: options.reasoningMode,
             previousResponseId: options.previousResponseId,
             followupSessionId: options.followupSessionId,
             followupModel: options.followupModel,
@@ -235,7 +252,7 @@ export async function initializeSession(options, cwd, notifications, baseSlugOve
         },
     };
     await ensureDir(modelsDir(sessionId));
-    await fs.writeFile(metaPath(sessionId), JSON.stringify(metadata, null, 2), "utf8");
+    await writeSessionMetadataFile(sessionId, metadata);
     await Promise.all((modelList.length > 0 ? modelList : [metadata.model ?? DEFAULT_MODEL]).map(async (modelName) => {
         const jsonPath = modelJsonPath(sessionId, modelName);
         const logFilePath = modelLogPath(sessionId, modelName);
@@ -266,7 +283,7 @@ export async function updateSessionMetadata(sessionId, updates) {
         (await readLegacySessionMetadata(sessionId, { reconcile: false, persist: false })) ??
         { id: sessionId };
     const next = { ...existing, ...updates };
-    await fs.writeFile(metaPath(sessionId), JSON.stringify(next, null, 2), "utf8");
+    await writeSessionMetadataFile(sessionId, next);
     return next;
 }
 async function readModernSessionMetadata(sessionId, options) {
@@ -299,8 +316,26 @@ async function readRawSessionMetadata(sessionId) {
         (await readLegacySessionMetadata(sessionId, { reconcile: false, persist: false })));
 }
 async function reconcileSessionMetadata(meta, { persist }) {
-    const runtimeChecked = await markDeadBrowser(meta, { persist });
-    return await markZombie(runtimeChecked, { persist });
+    let current = meta;
+    const workerPid = current.lifecycle?.workerPid;
+    if (workerPid) {
+        if (isProcessAlive(workerPid)) {
+            return current;
+        }
+        current = (await readRawSessionMetadata(current.id)) ?? current;
+        if (current.status !== "running") {
+            return current;
+        }
+        if (current.lifecycle?.workerPid && isProcessAlive(current.lifecycle.workerPid)) {
+            return current;
+        }
+    }
+    const runtimeChecked = await markDeadBrowser(current);
+    const reconciled = await markZombie(runtimeChecked);
+    if (persist && reconciled !== current) {
+        await writeSessionMetadataFile(current.id, reconciled);
+    }
+    return reconciled;
 }
 function isSessionMetadataRecord(value) {
     return Boolean(value && typeof value.id === "string" && value.status);
@@ -479,7 +514,7 @@ export async function getSessionPaths(sessionId) {
     }
     return { dir, metadata, log, request };
 }
-async function markZombie(meta, { persist }) {
+async function markZombie(meta) {
     if (!(await isZombie(meta))) {
         return meta;
     }
@@ -506,12 +541,9 @@ async function markZombie(meta, { persist }) {
         errorMessage: `Session marked as zombie (> ${formatElapsed(maxAgeMs)} stale)`,
         completedAt: new Date().toISOString(),
     };
-    if (persist) {
-        await fs.writeFile(metaPath(meta.id), JSON.stringify(updated, null, 2), "utf8");
-    }
     return updated;
 }
-async function markDeadBrowser(meta, { persist }) {
+async function markDeadBrowser(meta) {
     if (meta.status !== "running" || meta.mode !== "browser") {
         return meta;
     }
@@ -544,9 +576,6 @@ async function markDeadBrowser(meta, { persist }) {
         completedAt: new Date().toISOString(),
         response,
     };
-    if (persist) {
-        await fs.writeFile(metaPath(meta.id), JSON.stringify(updated, null, 2), "utf8");
-    }
     return updated;
 }
 async function isZombie(meta) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steipete/oracle",
-  "version": "0.16.1",
+  "version": "0.17.1",
   "description": "CLI wrapper around OpenAI Responses API with GPT-5.6 Sol, GPT-5.6, GPT-5.5 Pro, GPT-5.5, GPT-5.4, GPT-5.2, GPT-5.1, and GPT-5.1 Codex high reasoning modes.",
   "keywords": [],
   "homepage": "https://askoracle.sh",
@@ -58,11 +58,11 @@
   },
   "dependencies": {
     "@anthropic-ai/tokenizer": "^0.0.4",
-    "@google/genai": "^2.13.0",
+    "@google/genai": "^2.15.0",
     "@google/generative-ai": "^0.24.1",
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "@steipete/sweet-cookie": "^0.4.0",
-    "chalk": "^5.6.2",
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "@steipete/sweet-cookie": "^0.4.1",
+    "chalk": "^6.0.0",
     "chrome-launcher": "^1.2.1",
     "chrome-remote-interface": "^0.34.0",
     "clipboardy": "^5.3.2",
@@ -73,28 +73,28 @@
     "inquirer": "14.0.2",
     "json5": "^2.2.3",
     "kleur": "^4.1.5",
-    "markdansi": "0.3.2",
-    "openai": "^6.48.0",
+    "markdansi": "0.3.3",
+    "openai": "^7.4.0",
     "osc-progress": "^0.3.2",
     "qs": "^6.15.3",
-    "shiki": "^4.3.1",
+    "shiki": "^4.4.2",
     "toasted-notifier": "^10.1.0",
-    "tokentally": "^0.1.2",
+    "tokentally": "^0.1.3",
     "zod": "^4.4.3"
   },
   "devDependencies": {
     "@anthropic-ai/tokenizer": "^0.0.4",
     "@types/chrome-remote-interface": "^0.34.0",
     "@types/inquirer": "^9.0.10",
-    "@types/node": "^26.1.1",
+    "@types/node": "^26.1.2",
     "@vitest/coverage-v8": "4.1.10",
-    "devtools-protocol": "0.0.1666840",
-    "es-toolkit": "^1.49.0",
+    "devtools-protocol": "0.0.1673900",
+    "es-toolkit": "^1.50.0",
     "esbuild": "^0.28.1",
-    "oxfmt": "0.60.0",
-    "oxlint": "^1.75.0",
-    "puppeteer-core": "^25.3.0",
-    "tsx": "^4.23.1",
+    "oxfmt": "0.62.0",
+    "oxlint": "^1.77.0",
+    "puppeteer-core": "^25.5.0",
+    "tsx": "^4.23.7",
     "typescript": "^7.0.2",
     "vitest": "^4.1.10"
   },
@@ -109,5 +109,5 @@
   "engines": {
     "node": ">=24"
   },
-  "packageManager": "pnpm@10.33.2"
+  "packageManager": "pnpm@10.34.5"
 }