@steipete/oracle 0.10.0 → 0.11.0

package/dist/src/cli/sessionDisplay.js

@@ -1,10 +1,12 @@
 import chalk from "chalk";
 import kleur from "kleur";
+import fs from "node:fs/promises";
 import { renderMarkdownAnsi } from "./markdownRenderer.js";
 import { formatFinishLine } from "../oracle/finishLine.js";
 import { sessionStore, wait } from "../sessionStore.js";
 import { formatTokenCount, formatTokenValue } from "../oracle/runUtils.js";
 import { resumeBrowserSession } from "../browser/reattach.js";
+import { appendArtifacts, saveBrowserTranscriptArtifact, saveDeepResearchReportArtifact, } from "../browser/artifacts.js";
 import { estimateTokenCount } from "../browser/utils.js";
 import { formatSessionTableHeader, formatSessionTableRow, resolveSessionCost, } from "./sessionTable.js";
 import { abbreviateResponseId, buildResponseOwnerIndex, resolveSessionLineage, } from "./sessionLineage.js";
@@ -29,6 +31,66 @@ function isProcessAlive(pid) {
         return true;
     }
 }
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function isDeepResearchBrowserSession(metadata) {
+    return metadata.mode === "browser" && metadata.browser?.config?.researchMode === "deep";
+}
+function isDeepResearchPlaceholderCapture(metadata, logText) {
+    const answer = trimBeforeFirstAnswer(logText)
+        .replace(/^Answer:\s*/i, "")
+        .toLowerCase()
+        .replace(/\s+/g, " ")
+        .trim();
+    const isToolOnly = answer === "called tool" ||
+        answer === "used tool" ||
+        answer === "użyto narzędzia" ||
+        answer === "narzędzie wywołane";
+    const modelUsage = metadata.models?.find((run) => run.model === metadata.model)?.usage;
+    const outputTokens = metadata.usage?.outputTokens ?? modelUsage?.outputTokens;
+    return isToolOnly && (outputTokens == null || outputTokens <= 8);
+}
+async function writeReattachAnswer(sessionId, result, replaceExistingLog) {
+    const body = result.answerMarkdown || result.answerText;
+    if (replaceExistingLog) {
+        const paths = await sessionStore.getPaths(sessionId);
+        await fs.writeFile(paths.log, `[reattach] replaced incomplete Deep Research capture from existing Chrome tab\nAnswer:\n${body}\n`, "utf8");
+        return;
+    }
+    const logWriter = sessionStore.createLogWriter(sessionId);
+    logWriter.logLine("[reattach] captured assistant response from existing Chrome tab");
+    logWriter.logLine("Answer:");
+    logWriter.logLine(body);
+    logWriter.stream.end();
+}
+async function saveReattachBrowserArtifacts(sessionId, metadata, result) {
+    const body = result.answerMarkdown || result.answerText;
+    const conversationUrl = metadata.browser?.runtime?.tabUrl;
+    const logger = ((message) => console.log(dim(message)));
+    const reportArtifact = isDeepResearchBrowserSession(metadata)
+        ? await saveDeepResearchReportArtifact({
+            sessionId,
+            reportMarkdown: body,
+            conversationUrl,
+            logger,
+        }).catch(() => null)
+        : null;
+    const prompt = (await readStoredPrompt(sessionId)) ?? metadata.promptPreview ?? "";
+    const transcriptArtifact = await saveBrowserTranscriptArtifact({
+        sessionId,
+        prompt,
+        answerMarkdown: body,
+        conversationUrl,
+        artifacts: appendArtifacts(undefined, [reportArtifact]),
+        logger,
+    }).catch(() => null);
+    return appendArtifacts(metadata.artifacts, [reportArtifact, transcriptArtifact]);
+}
 const CLEANUP_TIP = 'Tip: Run "oracle session --clear --hours 24" to prune cached runs (add --all to wipe everything).';
 export async function showStatus({ hours, includeAll, limit, showExamples = false, modelFilter, }) {
     const metas = await sessionStore.listSessions();
@@ -99,12 +161,25 @@ export async function attachSession(sessionId, options) {
     const runtime = metadata.browser?.runtime;
     const controllerAlive = isProcessAlive(runtime?.controllerPid);
     const hasChromeDisconnect = metadata.response?.incompleteReason === "chrome-disconnected";
-    const statusAllowsReattach = metadata.status === "running" || (metadata.status === "error" && hasChromeDisconnect);
-    const hasFallbackSessionInfo = Boolean(runtime?.chromePort || runtime?.tabUrl || runtime?.conversationId);
-    const canReattach = statusAllowsReattach &&
+    const hasIncompleteCapture = metadata.response?.incompleteReason === "incomplete-capture";
+    const statusAllowsReattach = metadata.status === "running" ||
+        (metadata.status === "error" && (hasChromeDisconnect || hasIncompleteCapture));
+    const hasFallbackSessionInfo = Boolean(runtime?.chromePort ||
+        runtime?.chromeBrowserWSEndpoint ||
+        runtime?.chromeProfileRoot ||
+        runtime?.tabUrl ||
+        runtime?.conversationId);
+    const deepResearchPlaceholderCapture = isDeepResearchBrowserSession(metadata) &&
+        hasFallbackSessionInfo &&
+        isDeepResearchPlaceholderCapture(metadata, await sessionStore.readLog(sessionId).catch(() => ""));
+    const completedDeepResearchPlaceholder = metadata.status === "completed" && deepResearchPlaceholderCapture;
+    const canReattach = (statusAllowsReattach || completedDeepResearchPlaceholder) &&
         metadata.mode === "browser" &&
         hasFallbackSessionInfo &&
-        (hasChromeDisconnect || (runtime?.controllerPid && !controllerAlive));
+        (hasChromeDisconnect ||
+            hasIncompleteCapture ||
+            completedDeepResearchPlaceholder ||
+            (runtime?.controllerPid && !controllerAlive));
     if (canReattach) {
         const portInfo = runtime?.chromePort ? `port ${runtime.chromePort}` : "unknown port";
         const urlInfo = runtime?.tabUrl ? `url=${runtime.tabUrl}` : "url=unknown";
@@ -116,11 +191,9 @@ export async function attachSession(sessionId, options) {
                 }
             }), { verbose: true }), { promptPreview: metadata.promptPreview });
             const outputTokens = estimateTokenCount(result.answerMarkdown);
-            const logWriter = sessionStore.createLogWriter(sessionId);
-            logWriter.logLine("[reattach] captured assistant response from existing Chrome tab");
-            logWriter.logLine("Answer:");
-            logWriter.logLine(result.answerMarkdown || result.answerText);
-            logWriter.stream.end();
+            const artifacts = await saveReattachBrowserArtifacts(sessionId, metadata, result);
+            await writeReattachAnswer(sessionId, result, completedDeepResearchPlaceholder ||
+                (hasIncompleteCapture && deepResearchPlaceholderCapture));
             if (metadata.model) {
                 await sessionStore.updateModelRun(metadata.id, metadata.model, {
                     status: "completed",
@@ -142,10 +215,12 @@ export async function attachSession(sessionId, options) {
                     reasoningTokens: 0,
                     totalTokens: outputTokens,
                 },
+                errorMessage: undefined,
                 browser: {
                     config: metadata.browser?.config,
                     runtime,
                 },
+                artifacts,
                 response: { status: "completed" },
                 error: undefined,
                 transport: undefined,
@@ -156,6 +231,28 @@ export async function attachSession(sessionId, options) {
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             console.log(chalk.red(`Reattach failed: ${message}`));
+            if (completedDeepResearchPlaceholder) {
+                if (metadata.model) {
+                    await sessionStore.updateModelRun(metadata.id, metadata.model, {
+                        status: "error",
+                        response: { status: "incomplete", incompleteReason: "incomplete-capture" },
+                        error: {
+                            category: "browser-automation",
+                            message: `Deep Research capture incomplete: ${message}`,
+                        },
+                    });
+                }
+                await sessionStore.updateSession(sessionId, {
+                    status: "error",
+                    errorMessage: `Deep Research capture incomplete: ${message}`,
+                    response: { status: "incomplete", incompleteReason: "incomplete-capture" },
+                    error: {
+                        category: "browser-automation",
+                        message: `Deep Research capture incomplete: ${message}`,
+                    },
+                });
+                metadata = (await sessionStore.readSession(sessionId)) ?? metadata;
+            }
         }
     }
     if (!options?.suppressMetadata) {
@@ -181,6 +278,14 @@ export async function attachSession(sessionId, options) {
         else if (metadata.model) {
             console.log(`Model: ${metadata.model}`);
         }
+        if (metadata.artifacts && metadata.artifacts.length > 0) {
+            console.log("Artifacts:");
+            for (const artifact of metadata.artifacts) {
+                const label = artifact.label ?? artifact.kind;
+                const size = artifact.sizeBytes ? ` (${formatBytes(artifact.sizeBytes)})` : "";
+                console.log(`- ${chalk.cyan(label)} — ${artifact.path}${size}`);
+            }
+        }
         const responseSummary = formatResponseMetadata(metadata.response);
         if (responseSummary) {
             console.log(dim(`Response: ${responseSummary}`));
@@ -413,6 +518,13 @@ export function trimBeforeFirstAnswer(logText) {
     if (index === -1) {
         return logText;
     }
+    const fromFirstAnswer = logText.slice(index);
+    if (/^Answer:\s*(called tool|used tool|użyto narzędzia|narzędzie wywołane)\s*\n\[reattach\]/i.test(fromFirstAnswer)) {
+        const laterIndex = logText.lastIndexOf(marker);
+        if (laterIndex > index) {
+            return logText.slice(laterIndex);
+        }
+    }
     return logText.slice(index);
 }
 function formatRelativeDuration(referenceIso) {

package/dist/src/cli/sessionRunner.js

@@ -2,7 +2,7 @@ import kleur from "kleur";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { runOracle, OracleResponseError, OracleTransportError, extractResponseMetadata, asOracleUserError, extractTextOutput, } from "../oracle.js";
-import { runBrowserSessionExecution, } from "../browser/sessionRunner.js";
+import { ensureSessionArtifacts, runBrowserSessionExecution, } from "../browser/sessionRunner.js";
 import { renderMarkdownAnsi } from "./markdownRenderer.js";
 import { formatResponseMetadata, formatTransportMetadata } from "./sessionDisplay.js";
 import { markErrorLogged } from "./errorUtils.js";
@@ -59,7 +59,12 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                     });
                 },
             };
-            const result = await runBrowserSessionExecution({ runOptions, browserConfig, cwd, log }, runnerDeps);
+            const result = await runBrowserSessionExecution({
+                runOptions: { ...runOptions, sessionId: runOptions.sessionId ?? sessionMeta.id },
+                browserConfig,
+                cwd,
+                log,
+            }, runnerDeps);
             if (modelForStatus) {
                 await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
                     status: "completed",
@@ -72,10 +77,13 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 completedAt: new Date().toISOString(),
                 usage: result.usage,
                 elapsedMs: result.elapsedMs,
+                errorMessage: undefined,
                 browser: {
                     config: browserConfig,
                     runtime: result.runtime,
+                    archive: result.archive,
                 },
+                artifacts: mergeArtifacts(sessionMeta.artifacts, result.artifacts),
                 response: undefined,
                 transport: undefined,
                 error: undefined,
@@ -242,6 +250,7 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 completedAt: new Date().toISOString(),
                 usage: aggregateUsage,
                 elapsedMs: summary.elapsedMs,
+                errorMessage: undefined,
                 response: undefined,
                 transport: undefined,
                 error: undefined,
@@ -300,6 +309,7 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             completedAt: new Date().toISOString(),
             usage: result.usage,
             elapsedMs: result.elapsedMs,
+            errorMessage: undefined,
             response: extractResponseMetadata(result.response),
             transport: undefined,
             error: undefined,
@@ -358,22 +368,34 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
         if (assistantTimeout && mode === "browser") {
             const runtime = userError.details
                 ?.runtime;
-            log(dim("Assistant response timed out; keeping session running for reattach."));
+            log(dim("Assistant response timed out; marking capture incomplete for reattach."));
             if (modelForStatus) {
                 await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
-                    status: "running",
-                    completedAt: undefined,
+                    status: "error",
+                    completedAt: new Date().toISOString(),
+                    response: { status: "incomplete", incompleteReason: "incomplete-capture" },
+                    error: {
+                        category: userError.category,
+                        message: userError.message,
+                        details: userError.details,
+                    },
                 });
             }
             await sessionStore.updateSession(sessionMeta.id, {
-                status: "running",
+                status: "error",
+                completedAt: new Date().toISOString(),
                 errorMessage: message,
                 mode,
                 browser: {
                     config: browserConfig,
                     runtime: runtime ?? sessionMeta.browser?.runtime,
                 },
-                response: { status: "running", incompleteReason: "assistant-timeout" },
+                response: { status: "incomplete", incompleteReason: "incomplete-capture" },
+                error: {
+                    category: userError.category,
+                    message: userError.message,
+                    details: userError.details,
+                },
             });
             const autoReattachIntervalMs = browserConfig?.autoReattachIntervalMs ?? 0;
             if (autoReattachIntervalMs > 0) {
@@ -447,6 +469,17 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
         throw error;
     }
 }
+function mergeArtifacts(existing, additions) {
+    const merged = new Map();
+    for (const artifact of existing ?? []) {
+        merged.set(`${artifact.kind}:${artifact.path}`, artifact);
+    }
+    for (const artifact of additions ?? []) {
+        merged.set(`${artifact.kind}:${artifact.path}`, artifact);
+    }
+    const values = Array.from(merged.values());
+    return values.length > 0 ? values : undefined;
+}
 function formatError(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -538,6 +571,15 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
             });
             const answerText = result.answerMarkdown || result.answerText || "";
             const outputTokens = estimateTokenCount(answerText);
+            const artifacts = await ensureSessionArtifacts({
+                sessionId: sessionMeta.id,
+                prompt: runOptions.prompt,
+                answerMarkdown: answerText,
+                conversationUrl: runtime.tabUrl,
+                browserConfig,
+                existingArtifacts: sessionMeta.artifacts,
+                logger,
+            });
             const logWriter = sessionStore.createLogWriter(sessionMeta.id);
             logWriter.logLine(`[auto-reattach] captured assistant response on attempt ${attempt}`);
             logWriter.logLine("Answer:");
@@ -564,10 +606,12 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
                     reasoningTokens: 0,
                     totalTokens: outputTokens,
                 },
+                errorMessage: undefined,
                 browser: {
                     config: browserConfig,
                     runtime,
                 },
+                artifacts: mergeArtifacts(sessionMeta.artifacts, artifacts),
                 response: { status: "completed" },
                 error: undefined,
                 transport: undefined,

package/dist/src/mcp/consultPresets.js

@@ -0,0 +1,19 @@
+const CHATGPT_PRO_HEAVY_MODEL = "gpt-5.5-pro";
+const CHATGPT_PRO_HEAVY_THINKING_TIME = "extended";
+export function applyConsultPreset(input) {
+    if (!input.preset) {
+        return input;
+    }
+    if (input.preset === "chatgpt-pro-heavy") {
+        if (input.models && input.models.length > 0) {
+            throw new Error('MCP consult preset "chatgpt-pro-heavy" cannot be combined with models.');
+        }
+        return {
+            ...input,
+            engine: input.engine ?? "browser",
+            model: input.model ?? CHATGPT_PRO_HEAVY_MODEL,
+            browserThinkingTime: input.browserThinkingTime ?? CHATGPT_PRO_HEAVY_THINKING_TIME,
+        };
+    }
+    return input;
+}

package/dist/src/mcp/server.js

@@ -6,6 +6,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { getCliVersion } from "../version.js";
 import { registerConsultTool } from "./tools/consult.js";
+import { registerProjectSourcesTool } from "./tools/projectSources.js";
 import { registerSessionsTool } from "./tools/sessions.js";
 import { registerSessionResources } from "./tools/sessionResources.js";
 export async function startMcpServer() {
@@ -18,6 +19,7 @@ export async function startMcpServer() {
         },
     });
     registerConsultTool(server);
+    registerProjectSourcesTool(server);
     registerSessionsTool(server);
     registerSessionResources(server);
     const transport = new StdioServerTransport();