@steipete/oracle 0.17.3 → 0.19.0

package/dist/src/cli/sessionDisplay.js

@@ -12,7 +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";
+import { formatBrowserModelSelectionEvidence, formatBrowserThinkingSelectionEvidence, 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;
@@ -255,6 +255,7 @@ export async function attachSession(sessionId, options) {
                     config: metadata.browser?.config,
                     runtime,
                     modelSelection: metadata.browser?.modelSelection,
+                    thinkingSelection: metadata.browser?.thinkingSelection,
                     warnings: metadata.browser?.warnings,
                 },
                 artifacts,
@@ -603,7 +604,9 @@ export function formatUserErrorMetadata(metadata) {
 }
 export function formatBrowserEvidence(metadata) {
     const browser = metadata.browser;
-    if (!browser?.modelSelection && (!browser?.warnings || browser.warnings.length === 0)) {
+    if (!browser?.modelSelection &&
+        !browser?.thinkingSelection &&
+        (!browser?.warnings || browser.warnings.length === 0)) {
         return null;
     }
     const lines = [];
@@ -611,6 +614,10 @@ export function formatBrowserEvidence(metadata) {
     if (evidence) {
         lines.push(`model ${formatBrowserModelSelectionEvidence(evidence, metadata.model)}`);
     }
+    const thinkingEvidence = browser.thinkingSelection;
+    if (thinkingEvidence) {
+        lines.push(`effort ${formatBrowserThinkingSelectionEvidence(thinkingEvidence)}`);
+    }
     for (const warning of browser.warnings ?? []) {
         lines.push(`warning ${warning.code}: ${warning.message}`);
     }

package/dist/src/cli/sessionRunner.js

@@ -1,4 +1,5 @@
 import kleur from "kleur";
+import { constants as fsConstants } from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { runOracle, OracleResponseError, OracleTransportError, extractResponseMetadata, asOracleUserError, extractTextOutput, classifyProviderFailure, } from "../oracle.js";
@@ -23,6 +24,7 @@ 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 { computeFileSha256, sanitizeArtifactFilename } from "../browser/artifacts.js";
 import { formatElapsed } from "../oracle/format.js";
 import { formatBrowserReattachGuidance } from "./reattachGuidance.js";
 const isTty = process.stdout.isTTY;
@@ -78,7 +80,13 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 cwd,
                 log,
             }, runnerDeps);
-            await writeAssistantOutput(runOptions.writeOutputPath, result.answerText ?? "", log);
+            const writtenOutputPath = await writeAssistantOutput(runOptions.writeOutputPath, result.answerText ?? "", log);
+            const outputArtifacts = await copyBrowserOutputArtifacts({
+                outputPath: writtenOutputPath,
+                savedFiles: runOptions.writeArtifacts ? result.savedFiles : undefined,
+                log,
+            });
+            const browserWarnings = [...(result.warnings ?? []), ...outputArtifacts.warnings];
             await sendSessionNotification({
                 sessionId: sessionMeta.id,
                 sessionName: sessionMeta.options?.slug ?? sessionMeta.id,
@@ -105,9 +113,10 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                     runtime: result.runtime,
                     archive: result.archive,
                     modelSelection: result.modelSelection,
-                    warnings: result.warnings,
+                    thinkingSelection: result.thinkingSelection,
+                    warnings: browserWarnings.length > 0 ? browserWarnings : undefined,
                 },
-                artifacts: mergeArtifacts(sessionMeta.artifacts, result.artifacts),
+                artifacts: mergeArtifacts(sessionMeta.artifacts, mergeArtifacts(result.artifacts, outputArtifacts.artifacts)),
                 response: undefined,
                 transport: undefined,
                 error: undefined,
@@ -848,6 +857,81 @@ function resolveSessionPath(sessionDir, targetPath) {
     }
     return path.join(sessionDir, targetPath);
 }
+async function copyBrowserOutputArtifacts(params) {
+    const artifacts = [];
+    const warnings = [];
+    if (!params.outputPath || !params.savedFiles?.length) {
+        return { artifacts, warnings };
+    }
+    const outputDir = path.dirname(params.outputPath);
+    for (const savedFile of params.savedFiles) {
+        const filename = sanitizeArtifactFilename(savedFile.filename ?? path.basename(savedFile.path), "artifact.bin");
+        let copied;
+        try {
+            copied = await copyFileWithoutOverwrite(savedFile.path, path.join(outputDir, filename));
+            const [stat, sha256] = await Promise.all([fs.stat(copied), computeFileSha256(copied)]);
+            if (savedFile.sizeBytes != null && stat.size !== savedFile.sizeBytes) {
+                throw new Error(`size mismatch (expected ${savedFile.sizeBytes}, received ${stat.size})`);
+            }
+            if (savedFile.sha256 && sha256 !== savedFile.sha256) {
+                throw new Error(`sha256 mismatch (expected ${savedFile.sha256}, received ${sha256})`);
+            }
+            const artifact = {
+                kind: "file",
+                path: copied,
+                label: `${savedFile.label ?? filename} (write-output)`,
+                mimeType: savedFile.mimeType,
+                sizeBytes: stat.size,
+                sourceUrl: savedFile.sourceUrl,
+                sha256,
+                validation: savedFile.validation,
+                transfer: { status: "not-needed" },
+                origin: { mode: "local" },
+            };
+            artifacts.push(artifact);
+            params.log(dim(`[browser] Saved write-output file artifact to ${copied} sha256=${sha256}`));
+        }
+        catch (error) {
+            if (copied) {
+                await fs.unlink(copied).catch(() => undefined);
+            }
+            const reason = error instanceof Error ? error.message : String(error);
+            const message = `Failed to copy saved file artifact ${savedFile.path} beside ${params.outputPath}: ${reason}`;
+            params.log(dim(`[browser] ${message}`));
+            warnings.push({
+                code: "browser-output-artifact-copy-failed",
+                severity: "warning",
+                message,
+                details: {
+                    sourcePath: savedFile.path,
+                    outputPath: params.outputPath,
+                    sha256: savedFile.sha256,
+                },
+            });
+        }
+    }
+    return { artifacts, warnings };
+}
+async function copyFileWithoutOverwrite(sourcePath, baseTargetPath) {
+    const ext = path.extname(baseTargetPath);
+    const stem = ext ? path.basename(baseTargetPath, ext) : path.basename(baseTargetPath);
+    const dir = path.dirname(baseTargetPath);
+    let suffix = 1;
+    for (;;) {
+        const targetPath = suffix === 1 ? baseTargetPath : path.join(dir, `${stem}-${suffix}${ext}`);
+        try {
+            await fs.copyFile(sourcePath, targetPath, fsConstants.COPYFILE_EXCL);
+            return targetPath;
+        }
+        catch (error) {
+            if (isErrorCode(error, "EEXIST")) {
+                suffix += 1;
+                continue;
+            }
+            throw error;
+        }
+    }
+}
 async function writeAssistantOutput(targetPath, content, log) {
     if (!targetPath)
         return;
@@ -1057,11 +1141,11 @@ export function deriveModelOutputPath(basePath, model) {
     const suffix = ext.length > 0 ? `${stem}.${model}${ext}` : `${stem}.${model}`;
     return path.join(dir, suffix);
 }
+function isErrorCode(error, expected) {
+    return error instanceof Error && error.code === expected;
+}
 function isPermissionError(error) {
-    if (!(error instanceof Error))
-        return false;
-    const code = error.code;
-    return code === "EACCES" || code === "EPERM";
+    return isErrorCode(error, "EACCES") || isErrorCode(error, "EPERM");
 }
 function buildFallbackPath(original) {
     const ext = path.extname(original);

package/dist/src/config.js

@@ -135,6 +135,7 @@ function sanitizeProjectConfig(config) {
             "attachRunning",
             "timeoutMs",
             "inputTimeoutMs",
+            "approvalWaitMs",
             "attachmentTimeoutMs",
             "assistantRecheckDelayMs",
             "assistantRecheckTimeoutMs",

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

@@ -1,7 +1,9 @@
+import { randomUUID } from "node:crypto";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { buildGeminiWebModelHeader, FALLBACK_GEMINI_WEB_MODEL, } from "./models.js";
-const USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+import { fetchGeminiWebResource } from "./http.js";
+import { buildGeminiWebModelHeader, FALLBACK_GEMINI_WEB_MODEL, getGeminiWebModelSelection, } from "./models.js";
+const USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36";
 const MODEL_HEADER_NAME = "x-goog-ext-525001261-jspb";
 const GEMINI_APP_URL = "https://gemini.google.com/app";
 const GEMINI_STREAM_GENERATE_URL = "https://gemini.google.com/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate";
@@ -61,7 +63,7 @@ function buildCookieHeader(cookieMap) {
 }
 export async function fetchGeminiAccessToken(cookieMap, signal) {
     const cookieHeader = buildCookieHeader(cookieMap);
-    const res = await fetch(GEMINI_APP_URL, {
+    const res = await fetchGeminiWebResource(GEMINI_APP_URL, {
         redirect: "follow",
         signal,
         headers: {
@@ -112,7 +114,7 @@ function ensureFullSizeImageUrl(url) {
 async function fetchWithCookiePreservingRedirects(url, init, signal, maxRedirects = 10) {
     let current = url;
     for (let i = 0; i <= maxRedirects; i += 1) {
-        const res = await fetch(current, { ...init, redirect: "manual", signal });
+        const res = await fetchGeminiWebResource(current, { ...init, redirect: "manual", signal });
         if (res.status >= 300 && res.status < 400) {
             const location = res.headers.get("location");
             if (!location)
@@ -146,7 +148,7 @@ async function uploadGeminiFile(filePath, signal) {
     const mimeType = resolveGeminiUploadMimeType(absPath);
     const form = new FormData();
     form.append("file", new Blob([data], { type: mimeType }), fileName);
-    const res = await fetch(GEMINI_UPLOAD_URL, {
+    const res = await fetchGeminiWebResource(GEMINI_UPLOAD_URL, {
         method: "POST",
         redirect: "follow",
         signal,
@@ -162,18 +164,38 @@ async function uploadGeminiFile(filePath, signal) {
     }
     return { id: text, name: fileName, mimeType };
 }
-function buildGeminiFReqPayload(prompt, uploaded, chatMetadata) {
-    const promptPayload = uploaded.length > 0
-        ? [
-            prompt,
-            0,
-            null,
-            // Format: [[[fileId, 1, null, "mimeType"], "filename", ...]]
-            uploaded.map((file) => [[file.id, 1, null, file.mimeType], file.name]),
-        ]
-        : [prompt];
-    const innerList = [promptPayload, null, chatMetadata ?? null];
-    return JSON.stringify([null, JSON.stringify(innerList)]);
+function buildGeminiFReqPayload(prompt, uploaded, chatMetadata, model, requestId) {
+    const request = Array(97).fill(null);
+    request[0] = [
+        prompt,
+        0,
+        null,
+        uploaded.map((file) => [[file.id, 1, null, file.mimeType], file.name]),
+        null,
+        null,
+        0,
+    ];
+    request[1] = ["en"];
+    request[2] = chatMetadata ?? ["", "", "", null, null, null, null, null, null, ""];
+    request[6] = [1];
+    request[7] = 1;
+    request[10] = 1;
+    request[11] = 0;
+    request[17] = [[0]];
+    request[18] = 0;
+    request[27] = 1;
+    request[30] = [4];
+    request[41] = [1];
+    request[53] = 0;
+    request[59] = requestId;
+    request[61] = [];
+    request[68] = 2;
+    const selection = getGeminiWebModelSelection(model);
+    request[79] = selection.modelCode;
+    request[80] = selection.thinkingCode;
+    request[91] = 0;
+    request[96] = chatMetadata == null ? 1 : 0;
+    return JSON.stringify([null, JSON.stringify(request)]);
 }
 export function parseGeminiStreamGenerateResponse(rawText) {
     const responseJson = JSON.parse(trimGeminiJsonEnvelope(rawText));
@@ -274,11 +296,12 @@ export async function runGeminiWebOnce(input) {
         }
         uploaded.push(await uploadGeminiFile(file, input.signal));
     }
-    const fReq = buildGeminiFReqPayload(input.prompt, uploaded, input.chatMetadata ?? null);
+    const requestId = randomUUID().toUpperCase();
+    const fReq = buildGeminiFReqPayload(input.prompt, uploaded, input.chatMetadata ?? null, input.model, requestId);
     const params = new URLSearchParams();
     params.set("at", at);
     params.set("f.req", fReq);
-    const res = await fetch(GEMINI_STREAM_GENERATE_URL, {
+    const res = await fetchGeminiWebResource(GEMINI_STREAM_GENERATE_URL, {
         method: "POST",
         redirect: "follow",
         signal: input.signal,
@@ -290,6 +313,9 @@ export async function runGeminiWebOnce(input) {
             "user-agent": USER_AGENT,
             cookie: cookieHeader,
             [MODEL_HEADER_NAME]: buildGeminiWebModelHeader(input.model),
+            "x-goog-ext-73010989-jspb": "[0]",
+            "x-goog-ext-73010990-jspb": "[0]",
+            "x-goog-ext-525005358-jspb": JSON.stringify([requestId, 1]),
         },
         body: params.toString(),
     });
@@ -338,10 +364,30 @@ export async function runGeminiWebOnce(input) {
 export async function runGeminiWebWithFallback(input) {
     const attempt = await runGeminiWebOnce(input);
     if (isGeminiModelUnavailable(attempt.errorCode) && input.model !== FALLBACK_GEMINI_WEB_MODEL) {
+        if (input.allowModelFallback === false) {
+            throw new Error(`Requested Gemini web model ${input.model} is unavailable and model fallback is disabled.`);
+        }
         const fallback = await runGeminiWebOnce({ ...input, model: FALLBACK_GEMINI_WEB_MODEL });
-        return { ...fallback, effectiveModel: FALLBACK_GEMINI_WEB_MODEL };
+        return {
+            ...assertGeminiWebRunSucceeded(fallback),
+            effectiveModel: FALLBACK_GEMINI_WEB_MODEL,
+        };
+    }
+    return { ...assertGeminiWebRunSucceeded(attempt), effectiveModel: input.model };
+}
+function assertGeminiWebRunSucceeded(output) {
+    if (output.errorCode !== undefined) {
+        throw new Error(`Gemini web request failed with error code ${output.errorCode}.`);
+    }
+    if (output.errorMessage) {
+        throw new Error(`Gemini web request failed: ${output.errorMessage}`);
+    }
+    if (!output.text.trim() &&
+        output.images.length === 0 &&
+        extractGgdlUrls(output.rawResponseText).length === 0) {
+        throw new Error("Gemini web request ended without a response.");
     }
-    return { ...attempt, effectiveModel: input.model };
+    return output;
 }
 export async function saveFirstGeminiImageFromOutput(output, cookieMap, outputPath, signal) {
     const generatedOrWeb = output.images.find((img) => img.kind === "generated") ?? output.images[0];

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

@@ -325,6 +325,7 @@ export function createGeminiWebExecutor(geminiOptions) {
                             cookieMap: cookieResult.cookieMap,
                             chatMetadata: null,
                             signal: controller.signal,
+                            allowModelFallback: geminiOptions.allowModelFallback,
                         });
                         const editPrompt = `Use image generation tool to ${prompt}`;
                         const out = await runGeminiWebWithFallback({
@@ -334,6 +335,7 @@ export function createGeminiWebExecutor(geminiOptions) {
                             cookieMap: cookieResult.cookieMap,
                             chatMetadata: intro.metadata,
                             signal: controller.signal,
+                            allowModelFallback: geminiOptions.allowModelFallback,
                         });
                         response = {
                             text: out.text ?? null,
@@ -357,6 +359,7 @@ export function createGeminiWebExecutor(geminiOptions) {
                             cookieMap: cookieResult.cookieMap,
                             chatMetadata: null,
                             signal: controller.signal,
+                            allowModelFallback: geminiOptions.allowModelFallback,
                         });
                         response = {
                             text: out.text ?? null,
@@ -379,6 +382,7 @@ export function createGeminiWebExecutor(geminiOptions) {
                             cookieMap: cookieResult.cookieMap,
                             chatMetadata: null,
                             signal: controller.signal,
+                            allowModelFallback: geminiOptions.allowModelFallback,
                         });
                         response = {
                             text: out.text ?? null,

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

@@ -0,0 +1,15 @@
+export async function fetchGeminiWebResource(url, init = {}) {
+    try {
+        return await fetch(url, init);
+    }
+    catch (error) {
+        const cause = error instanceof Error ? error.cause : undefined;
+        if (cause &&
+            typeof cause === "object" &&
+            "code" in cause &&
+            cause.code === "UND_ERR_HEADERS_OVERFLOW") {
+            throw new Error("Gemini response headers exceed Node's configured limit. Start Oracle with NODE_OPTIONS=--max-http-header-size=65536 (preserving any existing Node options) and retry.", { cause: error });
+        }
+        throw error;
+    }
+}

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

@@ -6,29 +6,29 @@ const MODEL_SPECS = {
         hash: "1d44b34bcaa1c04d",
         modelCode: 6,
         thinkingCode: 1,
+        capacity: 2,
     },
     "gemini-3.5-flash": {
         hash: "56fdd199312815e2",
         modelCode: 1,
         thinkingCode: 1,
+        capacity: 2,
     },
     "gemini-3.1-pro": {
-        hash: "797f3d0293f288ad",
+        hash: "e6fa609c3fa255c0",
         modelCode: 3,
         thinkingCode: 1,
+        capacity: 2,
     },
     "gemini-3-pro-deep-think": {
-        hash: "797f3d0293f288ad",
-        modelCode: 3,
-        thinkingCode: 3,
+        hash: "e051ce1aa80aa576",
+        modelCode: 5,
+        thinkingCode: 2,
+        capacity: 2,
     },
 };
-let clientId;
-function getGeminiWebClientId() {
-    clientId ??= randomUUID().toUpperCase();
-    return clientId;
-}
-export function buildGeminiWebModelHeader(model, webClientId = getGeminiWebClientId()) {
+const clientId = randomUUID().toUpperCase();
+export function buildGeminiWebModelHeader(model, webClientId = clientId) {
     const spec = MODEL_SPECS[model];
     return JSON.stringify([
         1,
@@ -42,7 +42,7 @@ export function buildGeminiWebModelHeader(model, webClientId = getGeminiWebClien
         [4, 5, 6, 8],
         null,
         null,
-        3,
+        spec.capacity,
         null,
         null,
         spec.modelCode,
@@ -50,6 +50,10 @@ export function buildGeminiWebModelHeader(model, webClientId = getGeminiWebClien
         webClientId,
     ]);
 }
+export function getGeminiWebModelSelection(model) {
+    const { modelCode, thinkingCode } = MODEL_SPECS[model];
+    return { modelCode, thinkingCode };
+}
 export function resolveGeminiWebModel(desiredModel, log) {
     const desired = typeof desiredModel === "string" ? desiredModel.trim() : "";
     if (!desired)

package/dist/src/mcp/server.js

@@ -2,15 +2,16 @@
 import "dotenv/config";
 import process from "node:process";
 import { pathToFileURL } from "node:url";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { McpServer } from "@modelcontextprotocol/server";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
 import { getCliVersion } from "../version.js";
 import { registerChatGptImageTool } from "./tools/chatgptImage.js";
 import { registerConsultTool } from "./tools/consult.js";
 import { registerProjectSourcesTool } from "./tools/projectSources.js";
 import { registerSessionsTool } from "./tools/sessions.js";
+import { registerWaitTool } from "./tools/wait.js";
 import { registerSessionResources } from "./tools/sessionResources.js";
-export async function startMcpServer() {
+export function createMcpServer() {
     const server = new McpServer({
         name: "oracle-mcp",
         version: getCliVersion(),
@@ -23,19 +24,15 @@ export async function startMcpServer() {
     registerChatGptImageTool(server);
     registerProjectSourcesTool(server);
     registerSessionsTool(server);
+    registerWaitTool(server);
     registerSessionResources(server);
-    const transport = new StdioServerTransport();
-    transport.onerror = (error) => {
-        console.error("MCP transport error:", error);
-    };
-    const closed = new Promise((resolve) => {
-        transport.onclose = () => {
-            resolve();
-        };
+    return server;
+}
+export async function startMcpServer() {
+    serveStdio(createMcpServer, {
+        legacy: "serve",
+        onerror: (error) => console.error("MCP transport error:", error),
     });
-    // Keep the process alive until the client closes the transport.
-    await server.connect(transport);
-    await closed;
 }
 export function shouldStartMcpServerFromModule(moduleUrl = import.meta.url, argv1 = process.argv[1]) {
     return argv1 ? moduleUrl === pathToFileURL(argv1).href : false;

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

@@ -101,9 +101,9 @@ export function registerChatGptImageTool(server) {
     server.registerTool("chatgpt_image", {
         title: "Generate an image with ChatGPT",
         description: "Agent-friendly wrapper for ChatGPT browser image generation. It selects browser mode, enables the image-aware wait/download path, uploads reference files when provided, and returns saved image paths in structuredContent.images.",
-        inputSchema: chatGptImageInputShape,
-        outputSchema: chatGptImageOutputShape,
-    }, async (input) => {
+        inputSchema: z.object(chatGptImageInputShape),
+        outputSchema: z.object(chatGptImageOutputShape),
+    }, async (input, context) => {
         const textContent = (text) => [{ type: "text", text }];
         let parsed;
         try {
@@ -116,7 +116,7 @@ export function registerChatGptImageTool(server) {
             };
         }
         const consultInput = buildChatGptImageConsultInput(parsed);
-        const result = await runConsultTool(consultInput, { server: server.server });
+        const result = await runConsultTool(consultInput, { log: context.mcpReq.log });
         if (result.isError || !result.structuredContent) {
             return result;
         }