@steipete/oracle 0.18.0 → 0.20.0

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;
         }

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

@@ -1,11 +1,10 @@
 import { z } from "zod";
 import { getCliVersion } from "../../version.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";
 import { createRemoteBrowserExecutor } from "../../remote/client.js";
-async function readSessionLogTail(sessionId, maxBytes) {
+export async function readSessionLogTail(sessionId, maxBytes) {
     try {
         const log = await sessionStore.readLog(sessionId);
         if (log.length <= maxBytes) {
@@ -26,7 +25,9 @@ import { loadUserConfig } from "../../config.js";
 import { resolveNotificationSettings } from "../../cli/notifier.js";
 import { mapModelToBrowserLabel, resolveBrowserModelLabel, resolveDefaultBrowserThinkingTime, } from "../../cli/browserConfig.js";
 import { normalizeThinkingTimeLevel } from "../../oracle/thinkingTime.js";
-// Use raw shapes so the MCP SDK (with its bundled Zod) wraps them and emits valid JSON Schema.
+import { launchDetachedSession } from "../../cli/detachedSession.js";
+import { buildSessionLifecycle } from "../../cli/sessionLifecycle.js";
+// Shared fields are composed into explicit schemas when registering tools.
 const consultInputShape = {
     preset: z
         .enum(CONSULT_PRESETS)
@@ -60,11 +61,11 @@ const consultInputShape = {
     browserBundleFiles: z
         .boolean()
         .optional()
-        .describe("Browser-only: bundle many files into a single upload (helps with upload limits)."),
+        .describe("Browser-only: force one upload bundle; auto/zip includes all resolved files. Multiple text/source uploads already bundle by default (flattened text unless ZIP is selected)."),
     browserBundleFormat: z
         .enum(["auto", "text", "zip"])
         .optional()
-        .describe('Browser-only: bundle upload format when browserBundleFiles is true or auto-bundling is needed. Defaults to "auto"; "auto" uses ZIP when bundled inputs include raw/binary files.'),
+        .describe('Browser-only: bundle upload format. Defaults to "auto", which keeps flattened text for text-only uploads and uses ZIP when raw files are present; "zip" forces a byte-preserving archive.'),
     browserThinkingTime: browserThinkingTimeRawSchema
         .optional()
         .describe("Browser-only: set ChatGPT thinking time when supported by the chosen model."),
@@ -73,9 +74,9 @@ const consultInputShape = {
         .optional()
         .describe("Browser-only: model picker strategy. Mirrors the CLI --browser-model-strategy flag."),
     browserResearchMode: z
-        .enum(["deep"])
+        .enum(["search", "deep"])
         .optional()
-        .describe("Browser-only: activate ChatGPT Deep Research mode for broad web research."),
+        .describe("Browser-only: explicitly select ChatGPT Web Search or Deep Research."),
     browserArchive: z
         .enum(["auto", "always", "never"])
         .optional()
@@ -96,6 +97,10 @@ const consultInputShape = {
         .string()
         .optional()
         .describe("Browser-only image output fallback path, mirroring the CLI --output option for image operations."),
+    waitForCompletion: z
+        .boolean()
+        .optional()
+        .describe("When false, start the Oracle run in a detached worker and return its sessionId immediately. Use the wait tool to block for completion without agent-side polling. Defaults to true for compatibility."),
     dryRun: z
         .boolean()
         .optional()
@@ -109,7 +114,7 @@ const consultInputShape = {
         .optional()
         .describe("Optional human-friendly session id (used for later `oracle sessions` lookups)."),
 };
-const consultModelSummaryShape = z.object({
+export const consultModelSummaryShape = z.object({
     model: z.string(),
     status: z.string(),
     startedAt: z.string().optional(),
@@ -138,14 +143,14 @@ const consultModelSummaryShape = z.object({
         .optional(),
     logPath: z.string().optional(),
 });
-const consultArtifactSummaryShape = z.object({
+export 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({
+export const consultImageSummaryShape = consultArtifactSummaryShape.extend({
     kind: z.literal("image"),
     alt: z.string().optional(),
     width: z.number().optional(),
@@ -185,6 +190,7 @@ export const consultOutputShape = {
     models: z.array(consultModelSummaryShape).optional(),
     artifacts: z.array(consultArtifactSummaryShape).optional(),
     images: z.array(consultImageSummaryShape).optional(),
+    detached: z.boolean().optional(),
 };
 export function summarizeModelRunsForConsult(runs) {
     if (!runs || runs.length === 0) {
@@ -387,7 +393,7 @@ export function formatConsultDryRunResolved(details) {
     }
     return lines;
 }
-export async function runConsultTool(input, { server }) {
+export async function runConsultTool(input, { log: requestLog, launchDetached = launchDetachedSession, }) {
     const textContent = (text) => [{ type: "text", text }];
     let parsedInput;
     try {
@@ -399,7 +405,7 @@ export async function runConsultTool(input, { server }) {
             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 { prompt, files, model, models, engine, search, browserModelLabel, browserAttachments, browserBundleFiles, browserBundleFormat, browserThinkingTime, browserModelStrategy, browserResearchMode, browserArchive, browserFollowUps, browserKeepBrowser, generateImage, outputPath, waitForCompletion = true, dryRun, slug, } = parsedInput;
     const { config: userConfig } = await loadUserConfig();
     let runOptions;
     let resolvedEngine;
@@ -428,12 +434,7 @@ export async function runConsultTool(input, { server }) {
         };
     }
     const cwd = process.cwd();
-    const sendLog = (text, level = "info") => server
-        .sendLoggingMessage(LoggingMessageNotificationParamsSchema.parse({
-        level,
-        data: { text, bytes: Buffer.byteLength(text, "utf8") },
-    }))
-        .catch(() => { });
+    const sendLog = (text, level = "info") => requestLog(level, { 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) {
@@ -490,6 +491,18 @@ export async function runConsultTool(input, { server }) {
             },
         };
     }
+    if (!waitForCompletion && resolvedEngine === "browser" && resolvedRemote.host) {
+        return {
+            isError: true,
+            content: textContent("Detached MCP consults are not supported with a remote browser service yet. Keep waitForCompletion:true for this run."),
+        };
+    }
+    if (!waitForCompletion && process.env.ORACLE_NO_DETACH === "1") {
+        return {
+            isError: true,
+            content: textContent("Detached MCP consults are disabled by ORACLE_NO_DETACH=1. Remove it or keep waitForCompletion:true."),
+        };
+    }
     const browserGuard = ensureBrowserAvailable(resolvedEngine, {
         remoteHost: resolvedRemote.host,
     });
@@ -525,8 +538,58 @@ export async function runConsultTool(input, { server }) {
         mode: resolvedEngine,
         slug,
         browserConfig,
-        waitPreference: true,
+        waitPreference: waitForCompletion,
     }, cwd, notifications);
+    if (!waitForCompletion) {
+        try {
+            await launchDetached({
+                sessionId: sessionMeta.id,
+                prepare: async (workerPid) => {
+                    const lifecycle = buildSessionLifecycle({
+                        engine: resolvedEngine,
+                        detached: true,
+                        workerPid,
+                        reattachCommand: `oracle session ${sessionMeta.id}`,
+                    });
+                    await sessionStore.updateSession(sessionMeta.id, {
+                        status: "running",
+                        startedAt: new Date().toISOString(),
+                        lifecycle,
+                    });
+                },
+            });
+            const started = (await sessionStore.readSession(sessionMeta.id)) ?? sessionMeta;
+            const summary = `Session ${sessionMeta.id} (${started.status}; detached)`;
+            return {
+                content: textContent(`${summary}\nUse the wait tool with id=${JSON.stringify(sessionMeta.id)} to wait without polling.`),
+                structuredContent: {
+                    sessionId: sessionMeta.id,
+                    status: started.status,
+                    output: "",
+                    models: summarizeModelRunsForConsult(started.models),
+                    artifacts: summarizeArtifactsForConsult(started.artifacts),
+                    images: summarizeImageArtifactsForConsult(started.artifacts),
+                    detached: true,
+                },
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            await sessionStore
+                .updateSession(sessionMeta.id, {
+                status: "error",
+                completedAt: new Date().toISOString(),
+                errorMessage: message,
+                response: { status: "error" },
+                error: { category: "internal", message },
+            })
+                .catch(() => undefined);
+            return {
+                isError: true,
+                content: textContent(`Unable to start detached session ${sessionMeta.id}: ${message}`),
+            };
+        }
+    }
     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) => {
@@ -594,9 +657,8 @@ export async function runConsultTool(input, { server }) {
 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 }));
+        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; set `waitForCompletion:false` to return a durable sessionId immediately, then use `wait` to block without agent-side polling. 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).',
+        inputSchema: z.object(consultInputShape),
+        outputSchema: z.object(consultOutputShape),
+    }, async (input, context) => runConsultTool(input, { log: context.mcpReq.log }));
 }

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

@@ -56,9 +56,9 @@ export function registerProjectSourcesTool(server) {
     server.registerTool("project_sources", {
         title: "Manage ChatGPT Project Sources",
         description: "List or append files to a ChatGPT Project's persistent Sources tab. This is useful for Developer Mode workflows where chats do not share memory, but explicit project sources provide shared context. Destructive delete/replace/sync operations are intentionally not included in v1.",
-        inputSchema: projectSourcesInputShape,
-        outputSchema: projectSourcesOutputShape,
-    }, async (input) => {
+        inputSchema: z.object(projectSourcesInputShape),
+        outputSchema: z.object(projectSourcesOutputShape),
+    }, async (input, context) => {
         const textContent = (text) => [{ type: "text", text }];
         let parsed;
         try {
@@ -107,9 +107,7 @@ export function registerProjectSourcesTool(server) {
             dryRun: parsed.dryRun,
             config: browserConfig,
             log: (message) => {
-                server.server
-                    .sendLoggingMessage({ level: "info", data: { text: message } })
-                    .catch(() => undefined);
+                context.mcpReq.log("info", { text: message }).catch(() => undefined);
             },
         });
         const output = result.status === "dry-run"

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

@@ -1,4 +1,4 @@
-import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ResourceTemplate } from "@modelcontextprotocol/server";
 import fs from "node:fs/promises";
 import { sessionStore } from "../../sessionStore.js";
 // URIs:

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

@@ -44,8 +44,8 @@ export function registerSessionsTool(server) {
     server.registerTool("sessions", {
         title: "List or fetch oracle sessions",
         description: "Inspect Oracle session history stored under `ORACLE_HOME_DIR` (shared with the CLI). List recent sessions or fetch one by id/slug (optionally including metadata + request + log).",
-        inputSchema: sessionsInputShape,
-        outputSchema: sessionsOutputShape,
+        inputSchema: z.object(sessionsInputShape),
+        outputSchema: z.object(sessionsOutputShape),
     }, async (input) => {
         const textContent = (text) => [{ type: "text", text }];
         const { id, hours = 24, limit = 100, includeAll = false, detail = false, } = sessionsInputSchema.parse(input);

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

@@ -0,0 +1,182 @@
+import { realpathSync, watch } from "node:fs";
+import { z } from "zod";
+import { sessionStore } from "../../sessionStore.js";
+import { waitInputSchema } from "../types.js";
+import { consultArtifactSummaryShape, consultImageSummaryShape, consultModelSummaryShape, readSessionLogTail, summarizeArtifactsForConsult, summarizeImageArtifactsForConsult, summarizeModelRunsForConsult, } from "./consult.js";
+const TERMINAL_SESSION_STATUSES = new Set(["completed", "partial", "error", "cancelled"]);
+const DEFAULT_FALLBACK_INTERVAL_MS = 1_000;
+const waitInputShape = {
+    id: z.string().min(1, "Session id is required.").describe("Oracle session id or slug."),
+    timeoutMs: z
+        .number()
+        .int()
+        .nonnegative()
+        .optional()
+        .describe("How long to wait for a terminal session state. Omit to wait indefinitely; 0 returns an immediate snapshot. A wait timeout never cancels the Oracle session."),
+};
+const waitOutputShape = {
+    sessionId: z.string(),
+    status: z.string(),
+    waitStatus: z.enum(["terminal", "timed_out"]),
+    timedOut: z.boolean(),
+    cancelled: z.boolean(),
+    output: z.string(),
+    models: z.array(consultModelSummaryShape).optional(),
+    artifacts: z.array(consultArtifactSummaryShape).optional(),
+    images: z.array(consultImageSummaryShape).optional(),
+};
+function abortReason(signal) {
+    return signal.reason instanceof Error
+        ? signal.reason
+        : new DOMException("Oracle session wait was cancelled.", "AbortError");
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw abortReason(signal);
+    }
+}
+export function isTerminalSessionStatus(status) {
+    return TERMINAL_SESSION_STATUSES.has(status);
+}
+export function createSessionChangeSource(directory) {
+    let watcher;
+    let notified = false;
+    let pendingWake;
+    const onWake = () => {
+        if (!pendingWake) {
+            notified = true;
+            return;
+        }
+        const wake = pendingWake;
+        pendingWake = undefined;
+        wake();
+    };
+    const onError = () => {
+        const failedWatcher = watcher;
+        watcher = undefined;
+        failedWatcher?.off("change", onWake);
+        failedWatcher?.off("error", onError);
+        failedWatcher?.close();
+        onWake();
+    };
+    try {
+        // Windows short-path aliases can trigger a native libuv prefix assertion.
+        watcher = watch(realpathSync.native(directory));
+        watcher.on("change", onWake);
+        watcher.on("error", onError);
+    }
+    catch {
+        // A timer fallback below keeps waits correct when filesystem notifications
+        // are unavailable or the session directory is on an unsupported volume.
+    }
+    return {
+        wait(delayMs, signal) {
+            throwIfAborted(signal);
+            return new Promise((resolve, reject) => {
+                let settled = false;
+                const finish = (error) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    clearTimeout(timer);
+                    if (pendingWake === wake)
+                        pendingWake = undefined;
+                    signal?.removeEventListener("abort", onAbort);
+                    if (error)
+                        reject(error);
+                    else
+                        resolve();
+                };
+                const wake = () => finish();
+                const onAbort = () => finish(abortReason(signal));
+                const timer = setTimeout(wake, delayMs);
+                pendingWake = wake;
+                signal?.addEventListener("abort", onAbort, { once: true });
+                if (signal?.aborted) {
+                    onAbort();
+                    return;
+                }
+                if (notified) {
+                    notified = false;
+                    queueMicrotask(wake);
+                }
+            });
+        },
+        close() {
+            watcher?.off("change", onWake);
+            watcher?.off("error", onError);
+            watcher?.close();
+            watcher = undefined;
+        },
+    };
+}
+const defaultWaitDeps = {
+    readSession: (id) => sessionStore.readSession(id),
+    getSessionDir: async (id) => (await sessionStore.getPaths(id)).dir,
+    createChangeSource: createSessionChangeSource,
+    now: Date.now,
+};
+export async function waitForSessionTerminal({ id, timeoutMs, signal, fallbackIntervalMs = DEFAULT_FALLBACK_INTERVAL_MS, }, deps = defaultWaitDeps) {
+    throwIfAborted(signal);
+    const deadline = timeoutMs === undefined ? undefined : deps.now() + timeoutMs;
+    let metadata = await deps.readSession(id);
+    if (!metadata) {
+        throw new Error(`Session "${id}" not found.`);
+    }
+    if (isTerminalSessionStatus(metadata.status)) {
+        return { metadata, waitStatus: "terminal", timedOut: false };
+    }
+    if (timeoutMs === 0) {
+        return { metadata, waitStatus: "timed_out", timedOut: true };
+    }
+    const directory = await deps.getSessionDir(id);
+    const changes = deps.createChangeSource(directory);
+    try {
+        // Close the read/watch race: the session may have completed while the
+        // filesystem watcher was being installed.
+        metadata = (await deps.readSession(id)) ?? metadata;
+        while (!isTerminalSessionStatus(metadata.status)) {
+            throwIfAborted(signal);
+            const remaining = deadline === undefined ? undefined : deadline - deps.now();
+            if (remaining !== undefined && remaining <= 0) {
+                return { metadata, waitStatus: "timed_out", timedOut: true };
+            }
+            const delayMs = Math.max(1, Math.min(fallbackIntervalMs, remaining ?? fallbackIntervalMs));
+            await changes.wait(delayMs, signal);
+            metadata = (await deps.readSession(id)) ?? metadata;
+        }
+        return { metadata, waitStatus: "terminal", timedOut: false };
+    }
+    finally {
+        changes.close();
+    }
+}
+export async function runWaitTool(input, extra) {
+    const { id, timeoutMs } = waitInputSchema.parse(input);
+    const result = await waitForSessionTerminal({ id, timeoutMs, signal: extra?.signal });
+    const { metadata } = result;
+    const logTail = (await readSessionLogTail(metadata.id, 4_000)) ?? "";
+    const summary = `Session ${metadata.id} (${metadata.status}; wait=${result.waitStatus})`;
+    return {
+        content: [{ type: "text", text: [summary, logTail || "(log empty)"].join("\n") }],
+        structuredContent: {
+            sessionId: metadata.id,
+            status: metadata.status,
+            waitStatus: result.waitStatus,
+            timedOut: result.timedOut,
+            cancelled: metadata.status === "cancelled",
+            output: logTail,
+            models: summarizeModelRunsForConsult(metadata.models),
+            artifacts: summarizeArtifactsForConsult(metadata.artifacts),
+            images: summarizeImageArtifactsForConsult(metadata.artifacts),
+        },
+    };
+}
+export function registerWaitTool(server) {
+    server.registerTool("wait", {
+        title: "Wait for an oracle session",
+        description: "Wait for an existing Oracle session to reach a terminal state without agent-side polling. Omit timeoutMs to wait indefinitely, or set a bounded caller wait. Wait timeout or request cancellation never cancels the Oracle session; call wait again with the same id to continue waiting.",
+        inputSchema: z.object(waitInputShape),
+        outputSchema: z.object(waitOutputShape),
+    }, async (input, context) => runWaitTool(input, { signal: context.mcpReq.signal }));
+}

package/dist/src/mcp/types.js

@@ -23,12 +23,13 @@ export const consultInputSchema = z
     browserBundleFormat: z.enum(["auto", "text", "zip"]).optional(),
     browserThinkingTime: browserThinkingTimeInputSchema.optional(),
     browserModelStrategy: z.enum(["select", "current", "ignore"]).optional(),
-    browserResearchMode: z.enum(["deep"]).optional(),
+    browserResearchMode: z.enum(["search", "deep"]).optional(),
     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(),
+    waitForCompletion: z.boolean().optional(),
     dryRun: z.boolean().optional(),
     search: z.boolean().optional(),
     slug: z.string().optional(),
@@ -41,3 +42,9 @@ export const sessionsInputSchema = z.object({
     includeAll: z.boolean().optional(),
     detail: z.boolean().optional(),
 });
+export const waitInputSchema = z
+    .object({
+    id: z.string().min(1, "Session id is required."),
+    timeoutMs: z.number().int().nonnegative().optional(),
+})
+    .strict();

package/dist/src/oracle/config.js

@@ -30,6 +30,20 @@ const countTokensAnthropic = (input) => {
 // supported limit at the base-rate boundary until cost estimation supports tiers.
 const GPT_5_6_BASE_RATE_INPUT_LIMIT = 272_000;
 export const MODEL_CONFIGS = {
+    "gpt-6-astra": {
+        model: "gpt-6-astra",
+        provider: "openai",
+        tokenizer: countTokensGpt5,
+        // Conservative base-rate budget, not Astra's maximum context window.
+        // https://developers.openai.com/api/docs/models/gpt-6-astra
+        inputLimit: 272_000,
+        pricing: {
+            inputPerToken: 10 / 1_000_000,
+            outputPerToken: 50 / 1_000_000,
+        },
+        reasoning: { effort: "xhigh" },
+        searchToolType: "web_search",
+    },
     "gpt-5.6": {
         model: "gpt-5.6",
         provider: "openai",

package/dist/src/oracle/errors.js

@@ -26,6 +26,17 @@ export class BrowserAutomationError extends OracleUserError {
         this.name = "BrowserAutomationError";
     }
 }
+/**
+ * The caller went away. Distinct from a failure: nothing was wrong with the run,
+ * it simply stopped being wanted, and a caller that reads this should not retry
+ * or report a problem.
+ */
+export class BrowserRunCancelledError extends OracleUserError {
+    constructor(message = "Browser run cancelled: the caller disconnected.") {
+        super("browser-automation", message, { stage: "run-cancelled" });
+        this.name = "BrowserRunCancelledError";
+    }
+}
 export class PromptValidationError extends OracleUserError {
     constructor(message, details, cause) {
         super("prompt-validation", message, details, cause);

package/dist/src/oracle/geminiModels.js

@@ -1,4 +1,5 @@
 const MODEL_ID_MAP = {
+    "gpt-6-astra": "gpt-6-astra",
     "gemini-3.1-flash-lite": "gemini-3.1-flash-lite",
     "gemini-3.1-pro": "gemini-3.1-pro-preview",
     "gemini-3.5-flash": "gemini-3.5-flash",

package/dist/src/oracle/providerRoutePlan.js

@@ -75,7 +75,8 @@ function buildResolvedProviderRoute(input) {
     });
     const provider = state.provider;
     const isAzureOpenAI = state.isAzureOpenAI;
-    let baseUrl = input.baseUrl?.trim();
+    // Azure owns the endpoint, including metadata lookups before request dispatch.
+    let baseUrl = isAzureOpenAI ? undefined : input.baseUrl?.trim();
     const providerQualifiedOpenRouterCandidate = !isAzureOpenAI && providerMode !== "openai" && input.model.includes("/");
     if (baseUrl &&
         providerQualifiedOpenRouterCandidate &&
@@ -83,7 +84,7 @@ function buildResolvedProviderRoute(input) {
         !isCustomBaseUrl(baseUrl)) {
         baseUrl = undefined;
     }
-    if (!baseUrl) {
+    if (!baseUrl && !isAzureOpenAI) {
         let envBaseUrl;
         if (input.model.startsWith("grok")) {
             envBaseUrl = env.XAI_BASE_URL?.trim() || "https://api.x.ai/v1";