@steipete/oracle 0.20.0 → 0.20.2

package/dist/src/cli/sessionRunner.js

@@ -9,7 +9,6 @@ import { formatResponseMetadata, formatTransportMetadata } from "./sessionDispla
 import { markErrorLogged } from "./errorUtils.js";
 import { sendSessionNotification, deriveNotificationSettingsFromMetadata, } from "./notifier.js";
 import { sessionStore } from "../sessionStore.js";
-import { wait } from "../sessionManager.js";
 import { runMultiModelApiSession } from "../oracle/multiModelRunner.js";
 import { MODEL_CONFIGS, DEFAULT_SYSTEM_PROMPT } from "../oracle/config.js";
 import { isKnownModel } from "../oracle/modelResolver.js";
@@ -22,31 +21,71 @@ import { sanitizeOscProgress } from "./oscUtils.js";
 import { readFiles } from "../oracle/files.js";
 import { cwd as getCwd } from "node:process";
 import { resumeBrowserSession } from "../browser/reattach.js";
-import { retireRecoveredBrowserTarget } from "../browser/recoveryTarget.js";
+import { recoveryCaptureFromRuntime, retireCancelledBrowserTarget, retireRecoveredBrowserTarget, } from "../browser/recoveryTarget.js";
 import { hasRecoverableChatGptConversation } from "../browser/reattachability.js";
-import { estimateTokenCount } from "../browser/utils.js";
+import { delay, estimateTokenCount } from "../browser/utils.js";
 import { computeFileSha256, sanitizeArtifactFilename } from "../browser/artifacts.js";
 import { formatElapsed } from "../oracle/format.js";
 import { formatBrowserReattachGuidance } from "./reattachGuidance.js";
+import { BrowserRunCancelledError } from "../oracle/errors.js";
 const isTty = process.stdout.isTTY;
 const dim = (text) => (isTty ? kleur.dim(text) : text);
-export async function performSessionRun({ sessionMeta, runOptions, mode, browserConfig, cwd, log, write, version, notifications, browserDeps, muteStdout = false, }) {
+export async function performSessionRun({ sessionMeta, runOptions, mode, browserConfig, cwd, log, write, version, notifications, browserDeps, muteStdout = false, signal, }) {
     const writeInline = (chunk) => {
         // Keep session logs intact while still echoing inline output to the user.
         write(chunk);
         return muteStdout ? true : process.stdout.write(chunk);
     };
     let currentBrowser = browserConfig
-        ? { config: browserConfig }
+        ? {
+            config: browserConfig,
+            ...(mode === "browser" && sessionMeta.browser?.runtime?.submittedPromptHash !== undefined
+                ? { runtime: { submittedPromptHash: null } }
+                : {}),
+        }
         : sessionMeta.browser;
     await sessionStore.updateSession(sessionMeta.id, {
         status: "running",
         startedAt: new Date().toISOString(),
         mode,
-        ...(browserConfig ? { browser: { config: browserConfig } } : {}),
+        ...(browserConfig ? { browser: currentBrowser } : {}),
     });
     const notificationSettings = notifications ?? deriveNotificationSettingsFromMetadata(sessionMeta, process.env);
     const modelForStatus = runOptions.model ?? sessionMeta.model;
+    const checkBrowserCancellation = () => {
+        if (mode === "browser" && signal?.aborted)
+            throw new BrowserRunCancelledError();
+    };
+    const finalizeBrowserCancellation = async (cancellationError) => {
+        const completedAt = new Date().toISOString();
+        log("Browser run cancelled.");
+        if (modelForStatus) {
+            await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
+                status: "cancelled",
+                completedAt,
+                response: { status: "cancelled" },
+                error: undefined,
+                transport: undefined,
+            });
+        }
+        await sessionStore.updateSession(sessionMeta.id, {
+            status: "cancelled",
+            completedAt,
+            errorMessage: undefined,
+            mode,
+            browser: browserConfig
+                ? {
+                    ...currentBrowser,
+                    config: browserConfig,
+                }
+                : undefined,
+            response: { status: "cancelled" },
+            error: undefined,
+            transport: undefined,
+        });
+        await retireCancelledBrowserTarget(sessionMeta.id, recoveryCaptureFromRuntime(currentBrowser?.runtime), log);
+        throw cancellationError;
+    };
     try {
         if (mode === "browser") {
             if (!browserConfig) {
@@ -80,13 +119,17 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 browserConfig,
                 cwd,
                 log,
+                signal,
             }, runnerDeps);
+            checkBrowserCancellation();
             const writtenOutputPath = await writeAssistantOutput(runOptions.writeOutputPath, result.answerText ?? "", log);
+            checkBrowserCancellation();
             const outputArtifacts = await copyBrowserOutputArtifacts({
                 outputPath: writtenOutputPath,
                 savedFiles: runOptions.writeArtifacts ? result.savedFiles : undefined,
                 log,
             });
+            checkBrowserCancellation();
             const browserWarnings = [...(result.warnings ?? []), ...outputArtifacts.warnings];
             await sendSessionNotification({
                 sessionId: sessionMeta.id,
@@ -96,13 +139,16 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 usage: result.usage,
                 characters: result.answerText?.length,
             }, notificationSettings, log, result.answerText?.slice(0, 140));
+            checkBrowserCancellation();
             if (modelForStatus) {
                 await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
                     status: "completed",
                     completedAt: new Date().toISOString(),
                     usage: result.usage,
                 });
+                checkBrowserCancellation();
             }
+            checkBrowserCancellation();
             await sessionStore.updateSession(sessionMeta.id, {
                 status: "completed",
                 completedAt: new Date().toISOString(),
@@ -401,6 +447,9 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
         });
     }
     catch (error) {
+        if (error instanceof BrowserRunCancelledError) {
+            return await finalizeBrowserCancellation(error);
+        }
         const message = formatError(error);
         log(`ERROR: ${message}`);
         markErrorLogged(error);
@@ -426,6 +475,11 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             const runtime = userError.details
                 ?.runtime;
             const recoverableRuntime = runtime ?? currentBrowser?.runtime;
+            currentBrowser = {
+                ...currentBrowser,
+                config: browserConfig,
+                runtime: recoverableRuntime,
+            };
             if (!hasRecoverableChatGptConversation(recoverableRuntime) &&
                 recoverableRuntime?.promptSubmitted !== true) {
                 log(dim("Chrome disconnected before a ChatGPT conversation was created; marking session error."));
@@ -495,22 +549,32 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             const connectionLostIntervalMs = configuredIntervalMs > 0
                 ? configuredIntervalMs
                 : Math.max(1_000, Math.min(browserConfig?.timeoutMs ?? 30_000, 30_000));
-            const success = await autoReattachUntilComplete({
-                sessionMeta,
-                runtime: recoverableRuntime ?? undefined,
-                browserConfig: {
-                    ...browserConfig,
-                    autoReattachIntervalMs: connectionLostIntervalMs,
-                    autoReattachDelayMs: browserConfig?.autoReattachDelayMs ?? 0,
-                    autoReattachTimeoutMs: browserConfig?.autoReattachTimeoutMs ?? browserConfig?.timeoutMs ?? 120_000,
-                },
-                browserMetadata: currentBrowser,
-                runOptions,
-                modelForStatus,
-                notificationSettings,
-                log,
-                maxAttempts: configuredIntervalMs > 0 ? undefined : 1,
-            });
+            let success;
+            try {
+                success = await autoReattachUntilComplete({
+                    sessionMeta,
+                    runtime: recoverableRuntime ?? undefined,
+                    browserConfig: {
+                        ...browserConfig,
+                        autoReattachIntervalMs: connectionLostIntervalMs,
+                        autoReattachDelayMs: browserConfig?.autoReattachDelayMs ?? 0,
+                        autoReattachTimeoutMs: browserConfig?.autoReattachTimeoutMs ?? browserConfig?.timeoutMs ?? 120_000,
+                    },
+                    browserMetadata: currentBrowser,
+                    runOptions,
+                    modelForStatus,
+                    notificationSettings,
+                    log,
+                    maxAttempts: configuredIntervalMs > 0 ? undefined : 1,
+                    signal,
+                });
+            }
+            catch (recoveryError) {
+                if (signal?.aborted || recoveryError instanceof BrowserRunCancelledError) {
+                    return await finalizeBrowserCancellation(new BrowserRunCancelledError());
+                }
+                throw recoveryError;
+            }
             if (success) {
                 return;
             }
@@ -531,6 +595,11 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             };
             const autoReattachIntervalMs = browserConfig?.autoReattachIntervalMs ?? 0;
             const autoRuntime = runtime ?? currentBrowser?.runtime;
+            currentBrowser = {
+                ...currentBrowser,
+                config: browserConfig,
+                runtime: autoRuntime,
+            };
             const willAutoReattach = autoReattachIntervalMs > 0 && Boolean(autoRuntime);
             if (willAutoReattach) {
                 if (modelForStatus) {
@@ -554,16 +623,26 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                     response: timeoutResponse,
                     error: timeoutError,
                 });
-                const success = await autoReattachUntilComplete({
-                    sessionMeta,
-                    runtime: autoRuntime,
-                    browserConfig,
-                    browserMetadata: currentBrowser,
-                    runOptions,
-                    modelForStatus,
-                    notificationSettings,
-                    log,
-                });
+                let success;
+                try {
+                    success = await autoReattachUntilComplete({
+                        sessionMeta,
+                        runtime: autoRuntime,
+                        browserConfig,
+                        browserMetadata: currentBrowser,
+                        runOptions,
+                        modelForStatus,
+                        notificationSettings,
+                        log,
+                        signal,
+                    });
+                }
+                catch (recoveryError) {
+                    if (signal?.aborted || recoveryError instanceof BrowserRunCancelledError) {
+                        return await finalizeBrowserCancellation(new BrowserRunCancelledError());
+                    }
+                    throw recoveryError;
+                }
                 if (success) {
                     return;
                 }
@@ -976,7 +1055,7 @@ async function writeAssistantOutput(targetPath, content, log) {
         log(dim(`write-output failed (${reason}); session completed anyway.`));
     }
 }
-async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig, browserMetadata, runOptions, modelForStatus, notificationSettings, log, maxAttempts, }) {
+async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig, browserMetadata, runOptions, modelForStatus, notificationSettings, log, maxAttempts, signal, }) {
     if (!runtime || !browserConfig) {
         log(dim("Auto-reattach disabled: missing runtime or browser config."));
         return false;
@@ -991,12 +1070,16 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
         120_000;
     const maxTotalMs = 2 * 60 * 60 * 1000; // 2h hard cap; avoid infinite polling by default.
     const maxDeadline = Date.now() + maxTotalMs;
+    const checkCancellation = () => {
+        if (signal?.aborted)
+            throw new BrowserRunCancelledError();
+    };
     const attemptLimit = typeof maxAttempts === "number" && maxAttempts > 0
         ? Math.floor(maxAttempts)
         : Number.POSITIVE_INFINITY;
     if (delayMs > 0) {
         log(dim(`Auto-reattach starting in ${formatElapsed(delayMs)}...`));
-        await wait(delayMs);
+        await delay(delayMs, signal);
     }
     if (Number.isFinite(attemptLimit)) {
         log(dim(`Auto-reattach will try up to ${attemptLimit} attempt(s).`));
@@ -1012,6 +1095,7 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
     logger.verbose = true;
     let attempt = 0;
     for (;;) {
+        checkCancellation();
         const remainingBudgetMs = maxDeadline - Date.now();
         if (remainingBudgetMs <= 0) {
             log(dim(`Auto-reattach stopped after ${formatElapsed(maxTotalMs)} without capturing an answer.`));
@@ -1025,9 +1109,11 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
                 ...browserConfig,
                 timeoutMs,
             };
-            const result = await resumeBrowserSession(runtime, reattachConfig, logger, {
+            const result = await awaitBrowserCancellation(resumeBrowserSession(runtime, reattachConfig, logger, {
                 promptPreview: sessionMeta.promptPreview,
-            });
+                signal,
+            }), signal);
+            checkCancellation();
             captureSucceeded = true;
             const answerText = result.answerMarkdown || result.answerText || "";
             const outputTokens = estimateTokenCount(answerText);
@@ -1040,8 +1126,11 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
                 existingArtifacts: sessionMeta.artifacts,
                 logger,
             });
+            checkCancellation();
             const paths = await sessionStore.getPaths(sessionMeta.id);
+            checkCancellation();
             await fs.appendFile(paths.log, `[auto-reattach] captured assistant response on attempt ${attempt}\nAnswer:\n${answerText}\n`, "utf8");
+            checkCancellation();
             if (modelForStatus) {
                 await sessionStore.updateModelRun(sessionMeta.id, modelForStatus, {
                     status: "completed",
@@ -1053,8 +1142,10 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
                         totalTokens: outputTokens,
                     },
                 });
+                checkCancellation();
             }
             await writeAssistantOutput(runOptions.writeOutputPath, answerText, log);
+            checkCancellation();
             await sendSessionNotification({
                 sessionId: sessionMeta.id,
                 sessionName: sessionMeta.options?.slug ?? sessionMeta.id,
@@ -1066,6 +1157,7 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
                 },
                 characters: answerText.length,
             }, notificationSettings, log, answerText.slice(0, 140));
+            checkCancellation();
             await sessionStore.updateSession(sessionMeta.id, {
                 status: "completed",
                 completedAt: new Date().toISOString(),
@@ -1091,6 +1183,9 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
             return true;
         }
         catch (error) {
+            if (signal?.aborted || error instanceof BrowserRunCancelledError) {
+                throw new BrowserRunCancelledError();
+            }
             if (captureSucceeded) {
                 const message = formatError(error);
                 if (modelForStatus) {
@@ -1128,7 +1223,25 @@ async function autoReattachUntilComplete({ sessionMeta, runtime, browserConfig,
             log(dim(`Auto-reattach stopped after ${formatElapsed(maxTotalMs)} without capturing an answer.`));
             return false;
         }
-        await wait(Math.min(intervalMs, remainingAfterAttemptMs));
+        await delay(Math.min(intervalMs, remainingAfterAttemptMs), signal);
+    }
+}
+async function awaitBrowserCancellation(task, signal) {
+    if (!signal)
+        return task;
+    if (signal.aborted)
+        throw new BrowserRunCancelledError();
+    let abort;
+    const cancelled = new Promise((_, reject) => {
+        abort = () => reject(new BrowserRunCancelledError());
+        signal.addEventListener("abort", abort, { once: true });
+    });
+    try {
+        return await Promise.race([task, cancelled]);
+    }
+    finally {
+        if (abort)
+            signal.removeEventListener("abort", abort);
     }
 }
 export function deriveModelOutputPath(basePath, model) {

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

@@ -299,6 +299,7 @@ export function buildConsultBrowserConfig({ userConfig, env, runModel, inputMode
         researchMode: browserResearchMode ?? configuredBrowser.researchMode,
         archiveConversations: browserArchive ?? configuredBrowser.archiveConversations,
         desiredModel: desiredModelLabel || mapModelToBrowserLabel(runModel),
+        modelIsImplicitDefault: !inputModel && !userConfig.model && !browserModelLabel,
     };
 }
 export function buildConsultDryRunResolved({ resolvedEngine, runOptions, browserConfig, }) {
@@ -436,13 +437,6 @@ export async function runConsultTool(input, { log: requestLog, launchDetached =
     const cwd = process.cwd();
     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) {
-        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({

package/dist/src/remote/client.js

@@ -5,11 +5,12 @@ import { pipeline } from "node:stream/promises";
 import path from "node:path";
 import { mkdir, readFile, rename, rm, stat } from "node:fs/promises";
 import { appendArtifacts, computeFileSha256, resolveSessionArtifactsDir, resolveUniqueArtifactPath, sanitizeArtifactFilename, sanitizeArtifactMimeType, validateArtifactFile, } from "../browser/artifacts.js";
-import { MAX_REMOTE_ARTIFACT_BYTES, } from "./types.js";
+import { MAX_REMOTE_ARTIFACT_BYTES, pickRemoteImageMetadata, } from "./types.js";
 import { materializeStagedFallbackBundle } from "../browser/prompt.js";
 import { checkRemoteHealth } from "./health.js";
 import { parseHostPort } from "../bridge/connection.js";
 import { BrowserRunCancelledError } from "../oracle/errors.js";
+import { resolveSiblingImagePath } from "../browser/chatgptImages.js";
 export function createRemoteBrowserExecutor({ host, token }) {
     // Return a drop-in replacement for runBrowserMode so the browser session runner can stay unchanged.
     return async function remoteBrowserExecutor(options) {
@@ -17,13 +18,20 @@ export function createRemoteBrowserExecutor({ host, token }) {
             throw new Error("Web Search is a local browser pilot; --remote-host does not negotiate this capability yet. Use local Chrome or --browser-attach-running.");
         }
         const callerSignal = options.signal;
+        const imageOutputRequested = Boolean(options.generateImagePath || options.outputPath);
         if (callerSignal?.aborted)
             throw new BrowserRunCancelledError("Browser run cancelled before the request was sent.");
-        if (callerSignal) {
+        if (callerSignal || imageOutputRequested) {
             const health = await checkRemoteHealth({ host, token, signal: callerSignal });
-            if (callerSignal.aborted)
+            if (callerSignal?.aborted)
                 throw new BrowserRunCancelledError();
-            if (health.capabilities?.runCancellation !== true)
+            if (imageOutputRequested &&
+                (!health.ok ||
+                    health.capabilities?.generatedImages !== true ||
+                    health.capabilities.artifactProtocolVersion !== 1)) {
+                throw new Error("Remote host cannot capture and transfer generated images; upgrade Oracle on the host and retry. The image request was not sent.");
+            }
+            if (callerSignal && health.capabilities?.runCancellation !== true)
                 throw new Error("Remote host does not support run cancellation; upgrade the host before using an AbortSignal.");
         }
         const payload = {
@@ -37,6 +45,7 @@ export function createRemoteBrowserExecutor({ host, token }) {
                 sessionId: options.sessionId,
                 followUpPrompts: options.followUpPrompts,
                 cancelOnDisconnect: callerSignal ? true : undefined,
+                imageOutputRequested,
             },
         };
         const body = Buffer.from(JSON.stringify(payload));
@@ -46,10 +55,12 @@ export function createRemoteBrowserExecutor({ host, token }) {
                 reject(new Error("Browser run cancelled before the request was sent."));
                 return;
             }
-            const transferredFiles = [];
+            const transferredArtifacts = [];
             const transferFailures = [];
             const transferPromises = [];
             let artifactTransferQueue = Promise.resolve();
+            const preferredImagePath = options.generateImagePath ?? options.outputPath;
+            let preferredImageIndex = 0;
             let settled = false;
             let resolved = null;
             const fail = (error) => {
@@ -95,7 +106,7 @@ export function createRemoteBrowserExecutor({ host, token }) {
                                     resolved = result;
                                 },
                                 onArtifact: (artifact) => {
-                                    transferredFiles.push(artifact);
+                                    transferredArtifacts.push(artifact);
                                 },
                                 onArtifactFailure: (message) => {
                                     transferFailures.push(message);
@@ -105,6 +116,12 @@ export function createRemoteBrowserExecutor({ host, token }) {
                                     artifactTransferQueue = queued.catch(() => undefined);
                                     return queued;
                                 },
+                                resolvePreferredImagePath: (descriptor) => {
+                                    if (!preferredImagePath)
+                                        return undefined;
+                                    const extension = path.extname(descriptor.filename).slice(1) || "png";
+                                    return resolveSiblingImagePath(path.resolve(preferredImagePath), preferredImageIndex++, extension);
+                                },
                                 onError: fail,
                             });
                             if (transferPromise) {
@@ -123,9 +140,18 @@ export function createRemoteBrowserExecutor({ host, token }) {
                             fail(new Error("Remote browser run completed without a result."));
                             return;
                         }
+                        if (preferredImagePath) {
+                            const images = transferredArtifacts.filter((artifact) => artifact.kind === "image");
+                            if (images.length === 0 ||
+                                images.length !== preferredImageIndex ||
+                                resolved.warnings?.some((warning) => warning.code === "remote-image-registration-failed")) {
+                                fail(new Error("Remote image output was not fully delivered. Inspect the bridge host's generated images and the artifact transfer diagnostics before retrying."));
+                                return;
+                            }
+                        }
                         settled = true;
                         callerSignal?.removeEventListener("abort", onCallerAbort);
-                        resolve(mergeTransferredArtifacts(resolved, transferredFiles, transferFailures));
+                        resolve(mergeTransferredArtifacts(resolved, transferredArtifacts, transferFailures));
                     })().catch(fail);
                 });
                 res.on("error", fail);
@@ -222,12 +248,16 @@ function handleEvent(params) {
     }
     if (event.type === "artifact-ready") {
         const displayFilename = sanitizeArtifactFilename(String(event.artifact?.filename ?? ""), "artifact.bin");
+        const preferredPath = event.artifact.kind === "image"
+            ? params.resolvePreferredImagePath(event.artifact)
+            : undefined;
         const transfer = params.enqueueArtifactTransfer(() => transferRemoteArtifact({
             hostname: params.hostname,
             port: params.port,
             token: params.token,
             descriptor: event.artifact,
             sessionId: params.options.sessionId,
+            preferredPath,
             signal: params.options.signal,
             log: params.options.log,
         })
@@ -256,9 +286,11 @@ async function transferRemoteArtifact(params) {
     validateRemoteArtifactDescriptor(params.descriptor);
     const sessionId = params.sessionId ?? params.descriptor.runId;
     const artifactsDir = resolveSessionArtifactsDir(sessionId);
-    await mkdir(artifactsDir, { recursive: true });
     const filename = sanitizeArtifactFilename(params.descriptor.filename, `artifact-${params.descriptor.artifactId}.bin`);
-    const finalPath = await resolveUniqueArtifactPath(path.join(artifactsDir, filename));
+    const finalPath = params.preferredPath
+        ? path.resolve(params.preferredPath)
+        : await resolveUniqueArtifactPath(path.join(artifactsDir, filename));
+    await mkdir(path.dirname(finalPath), { recursive: true });
     const partPath = `${finalPath}.part-${params.descriptor.artifactId}`;
     const artifactPath = `/runs/${encodeURIComponent(params.descriptor.runId)}/artifacts/${encodeURIComponent(params.descriptor.artifactId)}`;
     params.log?.(`[browser] Transferring artifact ${filename} from bridge host...`);
@@ -300,8 +332,7 @@ async function transferRemoteArtifact(params) {
     await rename(partPath, finalPath);
     params.log?.(`[browser] Transferred artifact to ${finalPath}`);
     const publishedFilename = path.basename(finalPath);
-    return {
-        kind: "file",
+    const baseArtifact = {
         path: finalPath,
         label: publishedFilename,
         mimeType: sanitizeArtifactMimeType(params.descriptor.mimeType),
@@ -313,6 +344,17 @@ async function transferRemoteArtifact(params) {
         origin: { mode: "bridge" },
         url: "bridge-artifact",
         finalUrl: "bridge-artifact",
+    };
+    if (params.descriptor.kind === "image") {
+        return {
+            ...baseArtifact,
+            kind: "image",
+            ...pickRemoteImageMetadata(params.descriptor.image),
+        };
+    }
+    return {
+        ...baseArtifact,
+        kind: "file",
         filename: publishedFilename,
     };
 }
@@ -371,7 +413,7 @@ async function downloadArtifactToFile(params) {
 function validateRemoteArtifactDescriptor(descriptor) {
     if (!descriptor ||
         typeof descriptor !== "object" ||
-        descriptor.kind !== "file" ||
+        (descriptor.kind !== "file" && descriptor.kind !== "image") ||
         typeof descriptor.runId !== "string" ||
         !/^[a-zA-Z0-9_-]{1,128}$/.test(descriptor.runId) ||
         typeof descriptor.artifactId !== "string" ||
@@ -385,9 +427,12 @@ function validateRemoteArtifactDescriptor(descriptor) {
         throw new Error("invalid bridge artifact descriptor");
     }
 }
-function mergeTransferredArtifacts(result, transferredFiles, transferFailures) {
-    const artifacts = appendArtifacts(result.artifacts, transferredFiles);
+function mergeTransferredArtifacts(result, transferredArtifacts, transferFailures) {
+    const transferredFiles = transferredArtifacts.filter((artifact) => artifact.kind === "file");
+    const transferredImages = transferredArtifacts.filter((artifact) => artifact.kind === "image");
+    const artifacts = appendArtifacts(result.artifacts, transferredArtifacts);
     const savedFiles = appendSavedFiles(result.savedFiles, transferredFiles);
+    const savedImages = appendSavedImages(result.savedImages, transferredImages);
     const warnings = [
         ...(result.warnings ?? []),
         ...transferFailures.map((message) => ({
@@ -400,9 +445,21 @@ function mergeTransferredArtifacts(result, transferredFiles, transferFailures) {
         ...result,
         artifacts,
         savedFiles,
+        savedImages,
         warnings: warnings.length > 0 ? warnings : undefined,
     };
 }
+function appendSavedImages(existing, additions) {
+    const merged = new Map();
+    for (const artifact of existing ?? []) {
+        merged.set(artifact.path, artifact);
+    }
+    for (const artifact of additions) {
+        merged.set(artifact.path, artifact);
+    }
+    const values = Array.from(merged.values());
+    return values.length > 0 ? values : undefined;
+}
 function appendSavedFiles(existing, additions) {
     const merged = new Map();
     for (const artifact of existing ?? []) {

package/dist/src/remote/health.js

@@ -93,6 +93,7 @@ function parseCapabilities(value) {
     return {
         ...(raw.deferredFallbackBundling === true ? { deferredFallbackBundling: true } : {}),
         ...(raw.runCancellation === true ? { runCancellation: true } : {}),
+        ...(raw.generatedImages === true ? { generatedImages: true } : {}),
         artifactTransfer: true,
         artifactProtocolVersion,
         maxArtifactBytes: Math.min(maxArtifactBytes, MAX_REMOTE_ARTIFACT_BYTES),