@steipete/oracle 0.12.1 → 0.14.0

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { getCliVersion } from "../../version.js";
-import { LoggingMessageNotificationParamsSchema } from "@modelcontextprotocol/sdk/types.js";
+import { LoggingMessageNotificationParamsSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { ensureBrowserAvailable, mapConsultToRunOptions } from "../utils.js";
 import { sessionStore } from "../../sessionStore.js";
 import { resolveRemoteServiceConfig } from "../../remote/remoteServiceConfig.js";
@@ -88,6 +88,14 @@ const consultInputShape = {
         .boolean()
         .optional()
         .describe("Browser-only: keep Chrome running after completion (useful for debugging)."),
+    generateImage: z
+        .string()
+        .optional()
+        .describe("Browser-only: save generated image(s) to this file path. For ChatGPT browser mode this enables the image-aware wait/download path used by CLI --generate-image."),
+    outputPath: z
+        .string()
+        .optional()
+        .describe("Browser-only image output fallback path, mirroring the CLI --output option for image operations."),
     dryRun: z
         .boolean()
         .optional()
@@ -130,6 +138,20 @@ const consultModelSummaryShape = z.object({
         .optional(),
     logPath: z.string().optional(),
 });
+const consultArtifactSummaryShape = z.object({
+    kind: z.enum(["transcript", "deep-research-report", "image", "file"]),
+    path: z.string(),
+    label: z.string().optional(),
+    mimeType: z.string().optional(),
+    sizeBytes: z.number().optional(),
+});
+const consultImageSummaryShape = consultArtifactSummaryShape.extend({
+    kind: z.literal("image"),
+    alt: z.string().optional(),
+    width: z.number().optional(),
+    height: z.number().optional(),
+    fileId: z.string().optional(),
+});
 const consultDryRunResolvedShape = z.object({
     resolvedEngine: z.enum(["api", "browser"]),
     model: z.string(),
@@ -149,17 +171,20 @@ const consultDryRunResolvedShape = z.object({
         manualLogin: z.boolean().optional(),
         profileDir: z.string().nullable().optional(),
         chatgptUrl: z.string().nullable().optional(),
+        imageOutputPath: z.string().nullable().optional(),
     })
         .optional(),
     guidance: z.array(z.string()),
 });
-const consultOutputShape = {
+export const consultOutputShape = {
     sessionId: z.string().optional(),
     status: z.string(),
     output: z.string(),
     dryRun: z.boolean().optional(),
     resolved: consultDryRunResolvedShape.optional(),
     models: z.array(consultModelSummaryShape).optional(),
+    artifacts: z.array(consultArtifactSummaryShape).optional(),
+    images: z.array(consultImageSummaryShape).optional(),
 };
 export function summarizeModelRunsForConsult(runs) {
     if (!runs || runs.length === 0) {
@@ -191,6 +216,43 @@ export function summarizeModelRunsForConsult(runs) {
         };
     });
 }
+function optionalString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function optionalNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+export function summarizeArtifactsForConsult(artifacts) {
+    if (!artifacts || artifacts.length === 0) {
+        return undefined;
+    }
+    return artifacts.map((artifact) => ({
+        kind: artifact.kind,
+        path: artifact.path,
+        label: artifact.label,
+        mimeType: artifact.mimeType,
+        sizeBytes: artifact.sizeBytes,
+    }));
+}
+export function summarizeImageArtifactsForConsult(artifacts) {
+    const images = (artifacts ?? [])
+        .filter((artifact) => artifact.kind === "image")
+        .map((artifact) => {
+        const image = artifact;
+        return {
+            kind: "image",
+            path: artifact.path,
+            label: artifact.label,
+            mimeType: artifact.mimeType,
+            sizeBytes: artifact.sizeBytes,
+            alt: optionalString(image.alt),
+            width: optionalNumber(image.width),
+            height: optionalNumber(image.height),
+            fileId: optionalString(image.fileId),
+        };
+    });
+    return images.length > 0 ? images : undefined;
+}
 export function buildConsultBrowserConfig({ userConfig, env, runModel, inputModel, browserModelLabel, browserThinkingTime, browserModelStrategy, browserResearchMode, browserArchive, browserKeepBrowser, }) {
     const configuredBrowser = userConfig.browser ?? {};
     const envProfileDir = (env.ORACLE_BROWSER_PROFILE_DIR ?? "").trim();
@@ -250,6 +312,10 @@ export function buildConsultDryRunResolved({ resolvedEngine, runOptions, browser
     if (followUpCount > 0) {
         guidance.push("This is a multi-turn browser consult; all follow-ups stay in one ChatGPT conversation.");
     }
+    const imageOutputPath = runOptions.generateImage ?? runOptions.outputPath ?? null;
+    if (resolvedEngine === "browser" && imageOutputPath) {
+        guidance.push("ChatGPT generated images will use the image-aware wait/download path and return saved files in structuredContent.images.");
+    }
     return {
         resolvedEngine,
         model: runOptions.model,
@@ -269,6 +335,7 @@ export function buildConsultDryRunResolved({ resolvedEngine, runOptions, browser
                 manualLogin: browserConfig?.manualLogin,
                 profileDir: browserConfig?.manualLoginProfileDir ?? null,
                 chatgptUrl,
+                imageOutputPath,
             }
             : undefined,
         guidance,
@@ -300,6 +367,9 @@ export function formatConsultDryRunResolved(details) {
         if (details.browser.chatgptUrl) {
             lines.push(`  ChatGPT URL: ${details.browser.chatgptUrl}`);
         }
+        if (details.browser.imageOutputPath) {
+            lines.push(`  image output: ${details.browser.imageOutputPath}`);
+        }
     }
     lines.push(`  follow-ups: ${details.followUpCount}`);
     for (const guidance of details.guidance) {
@@ -307,28 +377,24 @@ export function formatConsultDryRunResolved(details) {
     }
     return lines;
 }
-export function registerConsultTool(server) {
-    server.registerTool("consult", {
-        title: "Run an oracle session",
-        description: 'Run an Oracle session (API or ChatGPT browser automation). Use `files` to attach project context. If `engine` is omitted, Oracle follows CLI defaults: config/ORACLE_ENGINE first, then API when OPENAI_API_KEY is set, otherwise browser. Browser GPT-5.5 Pro consults can take many minutes; use `dryRun:true` first when configuring an agent and inspect `sessions`/`oracle status` before retrying. Browser manual-login uses a private Oracle Chrome profile separate from the user\'s normal Chrome; dry-run output includes first-time setup guidance when that path is active. For browser-based image/file uploads, set `browserAttachments:"always"`. Browser consults can include `browserFollowUps` for a multi-turn ChatGPT review in one conversation. Sessions are stored under `ORACLE_HOME_DIR` (shared with the CLI).',
-        // Cast to any to satisfy SDK typings across differing Zod versions.
-        inputSchema: consultInputShape,
-        outputSchema: consultOutputShape,
-    }, async (input) => {
-        const textContent = (text) => [{ type: "text", text }];
-        let parsedInput;
-        try {
-            parsedInput = applyConsultPreset(consultInputSchema.parse(input));
-        }
-        catch (error) {
-            return {
-                isError: true,
-                content: textContent(error instanceof Error ? error.message : String(error)),
-            };
-        }
-        const { prompt, files, model, models, engine, search, browserModelLabel, browserAttachments, browserBundleFiles, browserBundleFormat, browserThinkingTime, browserModelStrategy, browserResearchMode, browserArchive, browserFollowUps, browserKeepBrowser, dryRun, slug, } = parsedInput;
-        const { config: userConfig } = await loadUserConfig();
-        const { runOptions, resolvedEngine } = mapConsultToRunOptions({
+export async function runConsultTool(input, { server }) {
+    const textContent = (text) => [{ type: "text", text }];
+    let parsedInput;
+    try {
+        parsedInput = applyConsultPreset(consultInputSchema.parse(input));
+    }
+    catch (error) {
+        return {
+            isError: true,
+            content: textContent(error instanceof Error ? error.message : String(error)),
+        };
+    }
+    const { prompt, files, model, models, engine, search, browserModelLabel, browserAttachments, browserBundleFiles, browserBundleFormat, browserThinkingTime, browserModelStrategy, browserResearchMode, browserArchive, browserFollowUps, browserKeepBrowser, generateImage, outputPath, dryRun, slug, } = parsedInput;
+    const { config: userConfig } = await loadUserConfig();
+    let runOptions;
+    let resolvedEngine;
+    try {
+        ({ runOptions, resolvedEngine } = mapConsultToRunOptions({
             prompt,
             files: files ?? [],
             model,
@@ -339,160 +405,188 @@ export function registerConsultTool(server) {
             browserBundleFiles,
             browserBundleFormat,
             browserFollowUps,
+            generateImage,
+            outputPath,
             userConfig,
             env: process.env,
+        }));
+    }
+    catch (error) {
+        return {
+            isError: true,
+            content: textContent(error instanceof Error ? error.message : String(error)),
+        };
+    }
+    const cwd = process.cwd();
+    const sendLog = (text, level = "info") => server
+        .sendLoggingMessage(LoggingMessageNotificationParamsSchema.parse({
+        level,
+        data: { text, bytes: Buffer.byteLength(text, "utf8") },
+    }))
+        .catch(() => { });
+    const resolvedRemote = resolveRemoteServiceConfig({ userConfig, env: process.env });
+    const imageOutputPath = runOptions.generateImage ?? runOptions.outputPath;
+    if (resolvedEngine === "browser" && resolvedRemote.host && imageOutputPath) {
+        return {
+            isError: true,
+            content: textContent("ChatGPT image output is not supported with a remote browser service: generated files are not transferred back to the MCP caller. Unset ORACLE_REMOTE_HOST to generate images locally, or omit generateImage/outputPath."),
+        };
+    }
+    let browserConfig;
+    if (resolvedEngine === "browser") {
+        browserConfig = buildConsultBrowserConfig({
+            userConfig,
+            env: process.env,
+            runModel: runOptions.model,
+            inputModel: model,
+            browserModelLabel,
+            browserThinkingTime,
+            browserModelStrategy,
+            browserResearchMode,
+            browserArchive,
+            browserKeepBrowser,
         });
-        const cwd = process.cwd();
-        const sendLog = (text, level = "info") => server.server
-            .sendLoggingMessage(LoggingMessageNotificationParamsSchema.parse({
-            level,
-            data: { text, bytes: Buffer.byteLength(text, "utf8") },
-        }))
-            .catch(() => { });
-        const resolvedRemote = resolveRemoteServiceConfig({ userConfig, env: process.env });
-        let browserConfig;
-        if (resolvedEngine === "browser") {
-            browserConfig = buildConsultBrowserConfig({
-                userConfig,
-                env: process.env,
-                runModel: runOptions.model,
-                inputModel: model,
-                browserModelLabel,
-                browserThinkingTime,
-                browserModelStrategy,
-                browserResearchMode,
-                browserArchive,
-                browserKeepBrowser,
-            });
-        }
-        if (dryRun) {
-            const lines = [];
-            const log = (line) => {
-                lines.push(line);
-                sendLog(line);
-            };
-            const resolved = buildConsultDryRunResolved({
-                resolvedEngine,
-                runOptions,
-                browserConfig,
-            });
-            await runDryRunSummary({
-                engine: resolvedEngine,
-                runOptions,
-                cwd,
-                version: getCliVersion(),
-                log,
-                browserConfig,
-            });
-            for (const line of formatConsultDryRunResolved(resolved)) {
-                log(line);
-            }
-            const output = lines.join("\n").trim();
-            return {
-                content: textContent(output),
-                structuredContent: {
-                    status: "dry-run",
-                    output,
-                    dryRun: true,
-                    resolved,
-                },
-            };
-        }
-        const browserGuard = ensureBrowserAvailable(resolvedEngine, {
-            remoteHost: resolvedRemote.host,
+    }
+    if (dryRun) {
+        const lines = [];
+        const log = (line) => {
+            lines.push(line);
+            sendLog(line);
+        };
+        const resolved = buildConsultDryRunResolved({
+            resolvedEngine,
+            runOptions,
+            browserConfig,
         });
-        if (resolvedEngine === "browser" && browserGuard) {
+        await runDryRunSummary({
+            engine: resolvedEngine,
+            runOptions,
+            cwd,
+            version: getCliVersion(),
+            log,
+            browserConfig,
+        });
+        for (const line of formatConsultDryRunResolved(resolved)) {
+            log(line);
+        }
+        const output = lines.join("\n").trim();
+        return {
+            content: textContent(output),
+            structuredContent: {
+                status: "dry-run",
+                output,
+                dryRun: true,
+                resolved,
+            },
+        };
+    }
+    const browserGuard = ensureBrowserAvailable(resolvedEngine, {
+        remoteHost: resolvedRemote.host,
+    });
+    if (resolvedEngine === "browser" && browserGuard) {
+        return {
+            isError: true,
+            content: textContent(browserGuard),
+        };
+    }
+    let browserDeps;
+    if (resolvedEngine === "browser" && resolvedRemote.host) {
+        if (!resolvedRemote.token) {
             return {
                 isError: true,
-                content: textContent(browserGuard),
+                content: textContent(`Remote host configured (${resolvedRemote.host}) but remote token is missing. Run \`oracle bridge client --connect <...>\` or set ORACLE_REMOTE_TOKEN.`),
             };
         }
-        let browserDeps;
-        if (resolvedEngine === "browser" && resolvedRemote.host) {
-            if (!resolvedRemote.token) {
-                return {
-                    isError: true,
-                    content: textContent(`Remote host configured (${resolvedRemote.host}) but remote token is missing. Run \`oracle bridge client --connect <...>\` or set ORACLE_REMOTE_TOKEN.`),
-                };
-            }
-            browserDeps = {
-                executeBrowser: createRemoteBrowserExecutor({
-                    host: resolvedRemote.host,
-                    token: resolvedRemote.token,
-                }),
-            };
+        browserDeps = {
+            executeBrowser: createRemoteBrowserExecutor({
+                host: resolvedRemote.host,
+                token: resolvedRemote.token,
+            }),
+        };
+    }
+    const notifications = resolveNotificationSettings({
+        cliNotify: undefined,
+        cliNotifySound: undefined,
+        env: process.env,
+        config: userConfig.notify,
+    });
+    const sessionMeta = await sessionStore.createSession({
+        ...runOptions,
+        mode: resolvedEngine,
+        slug,
+        browserConfig,
+        waitPreference: true,
+    }, cwd, notifications);
+    const logWriter = sessionStore.createLogWriter(sessionMeta.id);
+    // Stream logs to both the session log and MCP logging notifications, but avoid buffering in memory
+    const log = (line) => {
+        logWriter.logLine(line);
+        if (line !== undefined) {
+            sendLog(line);
         }
-        const notifications = resolveNotificationSettings({
-            cliNotify: undefined,
-            cliNotifySound: undefined,
-            env: process.env,
-            config: userConfig.notify,
-        });
-        const sessionMeta = await sessionStore.createSession({
-            ...runOptions,
+    };
+    const write = (chunk) => {
+        logWriter.writeChunk(chunk);
+        sendLog(chunk, "debug");
+        return true;
+    };
+    try {
+        await performSessionRun({
+            sessionMeta,
+            runOptions,
             mode: resolvedEngine,
-            slug,
             browserConfig,
-            waitPreference: true,
-        }, cwd, notifications);
-        const logWriter = sessionStore.createLogWriter(sessionMeta.id);
-        // Stream logs to both the session log and MCP logging notifications, but avoid buffering in memory
-        const log = (line) => {
-            logWriter.logLine(line);
-            if (line !== undefined) {
-                sendLog(line);
-            }
+            cwd,
+            log,
+            write,
+            version: getCliVersion(),
+            notifications,
+            muteStdout: true,
+            browserDeps,
+        });
+    }
+    catch (error) {
+        log(`Run failed: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            isError: true,
+            content: textContent(`Session ${sessionMeta.id} failed: ${error instanceof Error ? error.message : String(error)}`),
+        };
+    }
+    finally {
+        logWriter.stream.end();
+    }
+    try {
+        const finalMeta = (await sessionStore.readSession(sessionMeta.id)) ?? sessionMeta;
+        const summary = `Session ${sessionMeta.id} (${finalMeta.status})`;
+        const logTail = await readSessionLogTail(sessionMeta.id, 4000);
+        const modelsSummary = summarizeModelRunsForConsult(finalMeta.models);
+        const artifacts = summarizeArtifactsForConsult(finalMeta.artifacts);
+        const images = summarizeImageArtifactsForConsult(finalMeta.artifacts);
+        return {
+            content: textContent([summary, logTail || "(log empty)"].join("\n").trim()),
+            structuredContent: {
+                sessionId: sessionMeta.id,
+                status: finalMeta.status,
+                output: logTail ?? "",
+                models: modelsSummary,
+                artifacts,
+                images,
+            },
         };
-        const write = (chunk) => {
-            logWriter.writeChunk(chunk);
-            sendLog(chunk, "debug");
-            return true;
+    }
+    catch (error) {
+        return {
+            isError: true,
+            content: textContent(`Session completed but metadata fetch failed: ${error instanceof Error ? error.message : String(error)}`),
         };
-        try {
-            await performSessionRun({
-                sessionMeta,
-                runOptions,
-                mode: resolvedEngine,
-                browserConfig,
-                cwd,
-                log,
-                write,
-                version: getCliVersion(),
-                notifications,
-                muteStdout: true,
-                browserDeps,
-            });
-        }
-        catch (error) {
-            log(`Run failed: ${error instanceof Error ? error.message : String(error)}`);
-            return {
-                isError: true,
-                content: textContent(`Session ${sessionMeta.id} failed: ${error instanceof Error ? error.message : String(error)}`),
-            };
-        }
-        finally {
-            logWriter.stream.end();
-        }
-        try {
-            const finalMeta = (await sessionStore.readSession(sessionMeta.id)) ?? sessionMeta;
-            const summary = `Session ${sessionMeta.id} (${finalMeta.status})`;
-            const logTail = await readSessionLogTail(sessionMeta.id, 4000);
-            const modelsSummary = summarizeModelRunsForConsult(finalMeta.models);
-            return {
-                content: textContent([summary, logTail || "(log empty)"].join("\n").trim()),
-                structuredContent: {
-                    sessionId: sessionMeta.id,
-                    status: finalMeta.status,
-                    output: logTail ?? "",
-                    models: modelsSummary,
-                },
-            };
-        }
-        catch (error) {
-            return {
-                isError: true,
-                content: textContent(`Session completed but metadata fetch failed: ${error instanceof Error ? error.message : String(error)}`),
-            };
-        }
-    });
+    }
+}
+export function registerConsultTool(server) {
+    server.registerTool("consult", {
+        title: "Run an oracle session",
+        description: 'Run an Oracle session (API or ChatGPT browser automation). Use `files` to attach project context. If `engine` is omitted, Oracle follows CLI defaults: config/ORACLE_ENGINE first, then API when OPENAI_API_KEY is set, otherwise browser. Browser GPT-5.5 Pro consults can take many minutes; use `dryRun:true` first when configuring an agent and inspect `sessions`/`oracle status` before retrying. Browser manual-login uses a private Oracle Chrome profile separate from the user\'s normal Chrome; dry-run output includes first-time setup guidance when that path is active. For browser-based image/file uploads, set `browserAttachments:"always"`. For ChatGPT image generation, set `generateImage` to enable the same image wait/download path as CLI --generate-image and read returned paths from `images`. Browser consults can include `browserFollowUps` for a multi-turn ChatGPT review in one conversation. Sessions are stored under `ORACLE_HOME_DIR` (shared with the CLI).',
+        // Cast to any to satisfy SDK typings across differing Zod versions.
+        inputSchema: consultInputShape,
+        outputSchema: consultOutputShape,
+    }, async (input) => runConsultTool(input, { server: server.server }));
 }

package/dist/src/mcp/types.js

@@ -18,6 +18,8 @@ export const consultInputSchema = z
     browserArchive: z.enum(["auto", "always", "never"]).optional(),
     browserFollowUps: z.array(z.string()).optional(),
     browserKeepBrowser: z.boolean().optional(),
+    generateImage: z.string().optional(),
+    outputPath: z.string().optional(),
     dryRun: z.boolean().optional(),
     search: z.boolean().optional(),
     slug: z.string().optional(),

package/dist/src/mcp/utils.js

@@ -1,6 +1,80 @@
+import fs from "node:fs";
+import path from "node:path";
 import { resolveRunOptionsFromConfig } from "../cli/runOptions.js";
+import { getOracleHomeDir } from "../oracleHome.js";
 import { Launcher } from "chrome-launcher";
-export function mapConsultToRunOptions({ prompt, files, model, models, engine, search, browserAttachments, browserBundleFiles, browserBundleFormat, browserFollowUps, userConfig, env = process.env, }) {
+const ALLOW_EXTERNAL_OUTPUT_ENV = "ORACLE_MCP_ALLOW_EXTERNAL_OUTPUT";
+const MCP_OUTPUT_DIRNAME = "generated";
+/**
+ * Whether MCP callers may write generated images outside the dedicated Oracle
+ * output directory. Off by default: MCP clients are less trusted than CLI users.
+ */
+export function isExternalMcpOutputAllowed(env = process.env) {
+    const raw = env[ALLOW_EXTERNAL_OUTPUT_ENV]?.trim().toLowerCase();
+    return raw === "1" || raw === "true" || raw === "yes" || raw === "on";
+}
+/**
+ * Resolve `target` through symlinks for the portion that exists on disk, then
+ * re-append the not-yet-created remainder. A lexical `path.resolve` is not
+ * enough: a symlinked parent under the Oracle home (e.g. `~/.oracle/generated`
+ * -> `/tmp/evil`) would pass a string-prefix check while the actual write lands
+ * outside the boundary. realpath-ing the deepest existing ancestor closes that.
+ */
+function resolveThroughSymlinks(target) {
+    const resolved = path.resolve(target);
+    let current = resolved;
+    const tail = [];
+    // Bounded by the number of path segments; dirname() converges to the root.
+    for (;;) {
+        try {
+            const real = fs.realpathSync(current);
+            return tail.length ? path.join(real, ...tail) : real;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+            try {
+                if (fs.lstatSync(current).isSymbolicLink()) {
+                    throw new Error(`MCP output path contains an unresolved symlink: ${current}`);
+                }
+            }
+            catch (lstatError) {
+                if (lstatError.code !== "ENOENT") {
+                    throw lstatError;
+                }
+            }
+            const parent = path.dirname(current);
+            if (parent === current) {
+                return resolved;
+            }
+            tail.unshift(path.basename(current));
+            current = parent;
+        }
+    }
+}
+/**
+ * Constrain an MCP-supplied output path to ORACLE_HOME_DIR/generated and return
+ * its canonical absolute form. This keeps agent writes away from Oracle config,
+ * session metadata, and browser profile state. Existing symlinks are resolved
+ * before the boundary check. Set ORACLE_MCP_ALLOW_EXTERNAL_OUTPUT to opt into
+ * arbitrary output paths as an explicit operator decision.
+ */
+export function resolveMcpOutputPath(requestedPath, field, env = process.env) {
+    const resolved = path.resolve(requestedPath);
+    if (isExternalMcpOutputAllowed(env)) {
+        return resolved;
+    }
+    const oracleHome = resolveThroughSymlinks(getOracleHomeDir());
+    const root = path.join(oracleHome, MCP_OUTPUT_DIRNAME);
+    const realTarget = resolveThroughSymlinks(resolved);
+    if (realTarget.startsWith(`${root}${path.sep}`)) {
+        return realTarget;
+    }
+    throw new Error(`MCP "${field}" must resolve under the generated output directory (${root}); got "${realTarget}". ` +
+        `Use a path under that directory, or set ${ALLOW_EXTERNAL_OUTPUT_ENV}=1 to allow external output paths.`);
+}
+export function mapConsultToRunOptions({ prompt, files, model, models, engine, search, browserAttachments, browserBundleFiles, browserBundleFormat, browserFollowUps, generateImage, outputPath, userConfig, env = process.env, }) {
     // Normalize CLI-style inputs through the shared resolver so config/env defaults apply,
     // then overlay MCP-only overrides such as explicit search toggles.
     const mergedModels = Array.isArray(models) && models.length > 0
@@ -32,6 +106,18 @@ export function mapConsultToRunOptions({ prompt, files, model, models, engine, s
             .map((entry) => entry.trim())
             .filter(Boolean);
     }
+    const imageOutputPath = generateImage?.trim();
+    if (imageOutputPath) {
+        result.runOptions.generateImage = resolveMcpOutputPath(imageOutputPath, "generateImage", env);
+    }
+    const secondaryOutputPath = outputPath?.trim();
+    if (secondaryOutputPath) {
+        result.runOptions.outputPath = resolveMcpOutputPath(secondaryOutputPath, "outputPath", env);
+    }
+    if (result.resolvedEngine !== "browser" &&
+        (result.runOptions.generateImage || result.runOptions.outputPath)) {
+        throw new Error('MCP image output requires engine:"browser".');
+    }
     return result;
 }
 export function ensureBrowserAvailable(engine, options) {

package/dist/src/oracle/config.js

@@ -164,6 +164,32 @@ export const MODEL_CONFIGS = {
         supportsBackground: false,
         supportsSearch: true,
     },
+    "gemini-3.5-flash": {
+        model: "gemini-3.5-flash",
+        provider: "google",
+        tokenizer: countTokensGpt5Pro,
+        inputLimit: 1_048_576,
+        pricing: {
+            inputPerToken: 1.5 / 1_000_000,
+            outputPerToken: 9 / 1_000_000,
+        },
+        reasoning: null,
+        supportsBackground: false,
+        supportsSearch: true,
+    },
+    "gemini-3.1-flash-lite": {
+        model: "gemini-3.1-flash-lite",
+        provider: "google",
+        tokenizer: countTokensGpt5Pro,
+        inputLimit: 1_048_576,
+        pricing: {
+            inputPerToken: 0.25 / 1_000_000,
+            outputPerToken: 1.5 / 1_000_000,
+        },
+        reasoning: null,
+        supportsBackground: false,
+        supportsSearch: true,
+    },
     "gemini-3-pro": {
         model: "gemini-3-pro",
         provider: "google",
@@ -223,6 +249,6 @@ export const MODEL_CONFIGS = {
 };
 export const DEFAULT_SYSTEM_PROMPT = [
     "You are Oracle, a focused one-shot problem solver.",
-    "Emphasize direct answers and cite any files referenced.",
+    "Emphasize direct answers and cite referenced files as path:line or path:line-line when line numbers are available.",
 ].join(" ");
 export const TOKENIZER_OPTIONS = { allowedSpecial: "all" };