cursor-opencode-provider 0.7.6 → 0.8.1

package/dist/host-agent-mode.js

@@ -4,28 +4,111 @@
  * The language model stays host-neutral: it records a canonical Cursor mode
  * (`plan`, `spec`, `agent`, ...). A host entrypoint may install this structural
  * callback when its public API can select the corresponding primary agent.
- * OpenCode 2.0 uses it to select its vendor-maintained `plan` / `build` agents;
- * OpenCode 1.x continues to use advertised `plan_enter` / `plan_exit` tools.
+ * OpenCode 2.0 uses it to select its vendor-maintained `plan` / `build` agents
+ * and continues the turn via `session.synthetic` (OpenCode 2 `switchAgent`
+ * only publishes the agent and would otherwise idle).
+ * On OpenCode 1.x hosts, advertised `plan_enter` / `plan_exit` tools stay
+ * authoritative; without `plan_enter`, the classic entrypoint selects the
+ * `plan` agent the 1.x way, with a synthetic user message for that agent.
  */
-import { trace } from "./debug.js";
-let switchHostAgent;
+import { errorMessage, trace } from "./debug.js";
+/**
+ * Live switches, newest last. A host may set the plugin up more than once in
+ * one process (one setup per location instance, re-setup on plugin reload) and
+ * dispose an older setup after a newer one installed its switch.
+ */
+const registrations = [];
+function activeSwitch() {
+    return registrations[registrations.length - 1];
+}
 const pending = new Map();
+const applying = new Map();
 const MAX_PENDING_HOST_AGENT_SWITCHES = 256;
-export function setHostAgentModeSwitch(fn) {
-    switchHostAgent = fn;
-    if (!fn)
+/** True for Cursor mode ids served by the host's `plan` primary agent. */
+function isPlanModeID(targetModeID) {
+    const mode = targetModeID.trim().toLowerCase();
+    return mode === "plan" || mode === "spec";
+}
+/** Synthetic user text that carries an OpenCode 1.x primary-agent switch. */
+export function hostAgentSwitchPromptText(agent) {
+    return agent === "plan"
+        ? "Plan mode is now active. Continue planning the request above under the plan-mode " +
+            "instructions, and do not implement anything until the plan is approved."
+        : "Plan mode has ended. Continue with the approved work.";
+}
+/**
+ * OpenCode 1.x shape of the switch: a 1.x session runs each turn under the
+ * agent of its latest user message, which is how the host's own plan_enter /
+ * plan_exit change agents.
+ *
+ * It accepts only a real transition of a session running one of the host's
+ * own primary agents: entering an existing `plan` agent from another primary
+ * agent, or leaving the observed `plan` agent. Subagent and hidden internal
+ * sessions (title, summary, compaction, task children) never get a user turn
+ * injected.
+ */
+export function createPromptHostAgentModeSwitch(prompt, primaryAgents) {
+    return {
+        accepts: ({ targetModeID, hostAgent }) => {
+            const agents = primaryAgents();
+            const current = hostAgent?.trim();
+            if (!agents || !current || !agents.has(current))
+                return false;
+            return isPlanModeID(targetModeID) ? current !== "plan" && agents.has("plan") : current === "plan";
+        },
+        apply: async ({ sessionID, targetModeID }) => {
+            const agent = isPlanModeID(targetModeID) ? "plan" : "build";
+            await prompt({ sessionID, agent, text: hostAgentSwitchPromptText(agent) });
+        },
+    };
+}
+/**
+ * Install this host's native switch; it is used until a newer one is
+ * installed. The returned disposer removes only this switch, so disposing an
+ * older setup never removes a newer setup's switch. `undefined` removes all.
+ */
+export function setHostAgentModeSwitch(fn, options = {}) {
+    if (!fn) {
+        registrations.length = 0;
         pending.clear();
+        return () => { };
+    }
+    const registration = { fn, options };
+    registrations.push(registration);
+    return () => {
+        const index = registrations.lastIndexOf(registration);
+        if (index >= 0)
+            registrations.splice(index, 1);
+        if (registrations.length === 0)
+            pending.clear();
+    };
 }
-/** Queue only when this host installed a native primary-agent switch. */
+/**
+ * How this host applies a Cursor mode switch to its primary agents: `resumes`
+ * when the switch also starts the next host turn, `next-turn` when the user's
+ * next message runs under the new agent, undefined without a native switch.
+ */
+export function hostAgentModeSwitchKind() {
+    const active = activeSwitch();
+    if (!active)
+        return undefined;
+    return active.options.resumesTurn === true ? "resumes" : "next-turn";
+}
+/** Queue only when this host installed a native primary-agent switch that accepts the request. */
 export function queueHostAgentModeSwitch(input) {
     const sessionID = input.sessionID.trim();
     const targetModeID = input.targetModeID.trim();
-    if (!switchHostAgent || !sessionID || !targetModeID)
+    const active = activeSwitch();
+    if (!active || !sessionID || !targetModeID)
         return false;
+    if (active.options.accepts && !active.options.accepts({ ...input, sessionID, targetModeID }))
+        return false;
+    const hostAgent = input.hostAgent?.trim();
     pending.set(sessionID, {
         sessionID,
         targetModeID,
         ...(input.cursorSessionID ? { cursorSessionID: input.cursorSessionID } : {}),
+        ...(hostAgent ? { hostAgent } : {}),
         attempts: 0,
     });
     while (pending.size > MAX_PENDING_HOST_AGENT_SWITCHES) {
@@ -38,6 +121,17 @@ export function queueHostAgentModeSwitch(input) {
         `cursorSessionID=${input.cursorSessionID ?? ""} target=${targetModeID}`);
     return true;
 }
+/**
+ * True while an approved switch into the host `plan` agent waits for its Run to
+ * end and will itself start the plan-agent turn that continues the work.
+ */
+export function isHostPlanEntryPending(sessionID) {
+    if (activeSwitch()?.options.resumesTurn !== true)
+        return false;
+    const key = sessionID?.trim();
+    const target = key ? pending.get(key)?.targetModeID : undefined;
+    return target !== undefined && isPlanModeID(target);
+}
 export function cancelHostAgentModeSwitch(sessionID) {
     const key = sessionID?.trim();
     if (key)
@@ -53,7 +147,8 @@ export async function flushHostAgentModeSwitch(sessionID, options = {}) {
     if (!key)
         return false;
     const state = pending.get(key);
-    if (!state || !switchHostAgent)
+    const apply = activeSwitch()?.fn;
+    if (!state || !apply || applying.has(key))
         return false;
     if (options.terminal !== true || options.pumpActive || (options.pendingExecs ?? 0) > 0) {
         return false;
@@ -70,9 +165,12 @@ export async function flushHostAgentModeSwitch(sessionID, options = {}) {
         return false;
     }
     state.attempts += 1;
+    applying.set(key, state);
     try {
-        await switchHostAgent(state);
-        pending.delete(key);
+        await apply(state);
+        // A request queued during the callback belongs to a later transition.
+        if (pending.get(key) === state)
+            pending.delete(key);
         trace(`host-agent-mode: switched sessionID=${key} target=${state.targetModeID}`);
         return true;
     }
@@ -80,13 +178,19 @@ export async function flushHostAgentModeSwitch(sessionID, options = {}) {
         // Keep the request pending so a later explicit provider turn can retry at
         // its own terminal boundary. The provider-owned mode reminder remains the
         // behavioral fallback until the native host switch succeeds.
-        delete state.cursorSessionID;
+        if (pending.get(key) === state)
+            delete state.cursorSessionID;
         trace(`host-agent-mode: FAILED sessionID=${key} target=${state.targetModeID} ` +
-            `attempts=${state.attempts} err=${error instanceof Error ? error.message : String(error)}`);
+            `attempts=${state.attempts} err=${errorMessage(error)}`);
         return false;
     }
+    finally {
+        if (applying.get(key) === state)
+            applying.delete(key);
+    }
 }
 export function resetHostAgentModeSwitchForTests() {
-    switchHostAgent = undefined;
+    registrations.length = 0;
     pending.clear();
+    applying.clear();
 }

package/dist/host-plan-file.d.ts

@@ -0,0 +1,28 @@
+/**
+ * OpenCode's own plan file per session, resolved while the session runs under
+ * the `plan` agent. CreatePlan records the plan there so the `plan_exit` review
+ * reads exactly the file the user approves.
+ *
+ * Resolution is structural: session `slug` / `time.created` from the classic
+ * client, project VCS and worktree from the plugin input, and the location
+ * from OpenCode's `Session.plan` rule (or an injected host path bridge).
+ */
+export declare function hostPlanFileFor(sessionID: string | undefined): string | undefined;
+/** True once the session's plan file is known, including known to be absent. */
+export declare function isHostPlanFileResolved(sessionID: string | undefined): boolean;
+/**
+ * Record a session's plan file. `null` records that the host defines none, so
+ * it is not looked up again; `undefined` forgets it, so the next request retries.
+ */
+export declare function setHostPlanFile(sessionID: string, file: string | null | undefined): void;
+export declare function resetHostPlanFilesForTests(): void;
+/**
+ * Resolve and remember the host plan file for one session. A session without
+ * one is remembered as such; a failed lookup is not, so a later request retries.
+ */
+export declare function resolveHostPlanFile(input: {
+    sessionID: string;
+    getSession: (sessionID: string) => Promise<unknown>;
+    worktree: string | undefined;
+    vcs: boolean;
+}): Promise<string | undefined>;

package/dist/host-plan-file.js

@@ -0,0 +1,76 @@
+/**
+ * OpenCode's own plan file per session, resolved while the session runs under
+ * the `plan` agent. CreatePlan records the plan there so the `plan_exit` review
+ * reads exactly the file the user approves.
+ *
+ * Resolution is structural: session `slug` / `time.created` from the classic
+ * client, project VCS and worktree from the plugin input, and the location
+ * from OpenCode's `Session.plan` rule (or an injected host path bridge).
+ */
+import { hostPlanFilePath } from "./context/paths.js";
+import { errorMessage, trace } from "./debug.js";
+/** Session → its plan file, or `null` when the host defines none for it. */
+const hostPlanFiles = new Map();
+const MAX_HOST_PLAN_FILES = 256;
+export function hostPlanFileFor(sessionID) {
+    const key = sessionID?.trim();
+    return (key ? hostPlanFiles.get(key) : undefined) ?? undefined;
+}
+/** True once the session's plan file is known, including known to be absent. */
+export function isHostPlanFileResolved(sessionID) {
+    const key = sessionID?.trim();
+    return !!key && hostPlanFiles.has(key);
+}
+/**
+ * Record a session's plan file. `null` records that the host defines none, so
+ * it is not looked up again; `undefined` forgets it, so the next request retries.
+ */
+export function setHostPlanFile(sessionID, file) {
+    const key = sessionID.trim();
+    if (!key)
+        return;
+    hostPlanFiles.delete(key);
+    if (file === undefined || file === "")
+        return;
+    hostPlanFiles.set(key, file);
+    while (hostPlanFiles.size > MAX_HOST_PLAN_FILES) {
+        const oldest = hostPlanFiles.keys().next().value;
+        if (!oldest)
+            break;
+        hostPlanFiles.delete(oldest);
+    }
+}
+export function resetHostPlanFilesForTests() {
+    hostPlanFiles.clear();
+}
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+/**
+ * Resolve and remember the host plan file for one session. A session without
+ * one is remembered as such; a failed lookup is not, so a later request retries.
+ */
+export async function resolveHostPlanFile(input) {
+    try {
+        const response = record(await input.getSession(input.sessionID));
+        const info = record(response?.data) ?? response;
+        const slug = typeof info?.slug === "string" ? info.slug : "";
+        const created = record(info?.time)?.created;
+        if (!slug || typeof created !== "number" || !input.worktree) {
+            setHostPlanFile(input.sessionID, null);
+            return undefined;
+        }
+        const file = hostPlanFilePath({ worktree: input.worktree, vcs: input.vcs, created, slug });
+        setHostPlanFile(input.sessionID, file ?? null);
+        if (file)
+            trace(`host-plan-file: sessionID=${input.sessionID} file=${file}`);
+        return file;
+    }
+    catch (error) {
+        trace(`host-plan-file: unresolved sessionID=${input.sessionID} err=${errorMessage(error)}`);
+        setHostPlanFile(input.sessionID, undefined);
+        return undefined;
+    }
+}

package/dist/image-input.d.ts

@@ -9,6 +9,8 @@ export type CursorHistoryImageExtraction = {
     hashes: string[];
     candidateCount: number;
     duplicateCount: number;
+    /** Unreadable optional tool media; explicit user attachments still fail loudly. */
+    omittedCount?: number;
 };
 export type CursorPromptImageExtraction = CursorHistoryImageExtraction & {
     userImageCount: number;
@@ -23,6 +25,22 @@ export declare function extractCursorHistoryImages(prompt: readonly unknown[], o
     maxBytes?: number;
     filenameOffset?: number;
 }): Promise<CursorHistoryImageExtraction>;
+/**
+ * Decode the images a host tool returned (its own `file-data` / `image-data`
+ * parts, or the `file` parts OpenCode moves into the trailing
+ * `Attached media from tool result:` message) for a held-Run exec result.
+ * Non-image parts are skipped; a part that cannot be decoded is dropped so the
+ * text result is still delivered.
+ */
+export declare function extractCursorToolResultImages(parts: readonly unknown[], options?: {
+    signal?: AbortSignal;
+    maxBytes?: number;
+    maxImages?: number;
+}): Promise<{
+    images: CursorImageInput[];
+    hashes: string[];
+    omittedCount: number;
+}>;
 export declare function extractCursorPromptImages(prompt: readonly unknown[], lastUser: Record<string, unknown> | undefined, options: {
     supportsImages: boolean;
     seenHistoryHashes?: ReadonlySet<string>;

package/dist/image-input.js

@@ -4,8 +4,14 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { UnsupportedFunctionalityError } from "@ai-sdk/provider";
 export const MAX_CURSOR_IMAGE_INPUT_BYTES = 20 * 1024 * 1024;
+function isToolMediaCaption(message) {
+    if (!message || !Array.isArray(message.content))
+        return false;
+    const first = message.content[0];
+    return first?.type === "text" && first.text === "Attached media from tool result:";
+}
 export function hasCursorUserImages(lastUser) {
-    return !!lastUser && Array.isArray(lastUser.content) && lastUser.content.some((part) => {
+    return !isToolMediaCaption(lastUser) && !!lastUser && Array.isArray(lastUser.content) && lastUser.content.some((part) => {
         if (!part || typeof part !== "object")
             return false;
         const file = part;
@@ -20,18 +26,20 @@ export function assertCursorUserImageSupport(lastUser, supportsImages, modelId)
         return;
     unsupported("image input", `Cursor model ${JSON.stringify(modelId)} does not support image input`);
 }
-function decodeBase64(value) {
+function decodeBase64(value, remaining) {
     const normalized = value.replace(/\s/g, "");
     if (!normalized || !/^[A-Za-z0-9+/_-]*={0,2}$/.test(normalized)) {
         return unsupported("image input", "Cursor provider received invalid base64 image data");
     }
+    const padding = normalized.endsWith("==") ? 2 : normalized.endsWith("=") ? 1 : 0;
+    assertImageSize(Math.floor((normalized.length - padding) * 3 / 4), remaining);
     const data = Uint8Array.from(Buffer.from(normalized, "base64"));
     if (data.length === 0) {
         return unsupported("image input", "Cursor provider received an empty image");
     }
     return data;
 }
-function decodeDataUrl(value) {
+function decodeDataUrl(value, remaining) {
     if (!value.startsWith("data:")) {
         return unsupported("image input", "Cursor provider supports base64-encoded image data URLs only");
     }
@@ -47,7 +55,7 @@ function decodeDataUrl(value) {
     const firstSeparator = metadata.indexOf(";");
     const mimeType = metadata.slice(0, firstSeparator);
     return {
-        data: decodeBase64(value.slice(commaIndex + 1)),
+        data: decodeBase64(value.slice(commaIndex + 1), remaining),
         mimeType: mimeType || undefined,
     };
 }
@@ -121,13 +129,15 @@ async function readResponseBytes(response, remaining) {
     return data;
 }
 async function resolveImageData(value, remaining, signal) {
-    if (value instanceof Uint8Array)
+    if (value instanceof Uint8Array) {
+        assertImageSize(value.length, remaining);
         return { data: Uint8Array.from(value) };
+    }
     if (typeof value === "string") {
-        return value.startsWith("data:") ? decodeDataUrl(value) : { data: decodeBase64(value) };
+        return value.startsWith("data:") ? decodeDataUrl(value, remaining) : { data: decodeBase64(value, remaining) };
     }
     if (value.protocol === "data:")
-        return decodeDataUrl(value.href);
+        return decodeDataUrl(value.href, remaining);
     if (value.protocol === "file:") {
         const filePath = fileURLToPath(value);
         const info = await stat(filePath);
@@ -183,21 +193,33 @@ export async function extractCursorUserImages(lastUser, signal, maxBytes = MAX_C
         const file = part;
         if (file.type !== "file")
             continue;
-        const image = await decodeCursorImagePart(file, byteBudget - totalBytes, signal, `image-${images.length + 1}`);
+        const image = await decodeCursorImagePart(toolImagePart(file) ?? file, byteBudget - totalBytes, signal, `image-${images.length + 1}`);
         totalBytes += image.data.length;
         images.push(image);
     }
     return images;
 }
-function pushImageFileParts(parts, content) {
+/** Normalize OpenCode / AI SDK attachment shapes before either delivery path. */
+function toolImagePart(part) {
+    if (!part || typeof part !== "object")
+        return undefined;
+    const file = part;
+    if (!["file", "file-data", "image-data", "image-url", "media", "image"].includes(String(file.type)))
+        return undefined;
+    const mediaType = typeof file.mediaType === "string" ? file.mediaType
+        : file.type === "image-url" ? "image/*" : file.mime;
+    if (typeof mediaType !== "string" || !mediaType.startsWith("image/"))
+        return undefined;
+    const source = file.url ?? file.uri;
+    const data = file.data ?? (typeof source === "string" && /^(?:https?|file):/.test(source) && URL.canParse(source)
+        ? new URL(source) : source);
+    return { ...file, mediaType, data };
+}
+function pushImageFileParts(parts, content, toolResult = false) {
     for (const part of content) {
-        if (!part || typeof part !== "object")
-            continue;
-        const file = part;
-        if (file.type === "file" &&
-            typeof file.mediaType === "string" &&
-            file.mediaType.startsWith("image/"))
-            parts.push(file);
+        const file = toolImagePart(part);
+        if (file?.type === "file")
+            parts.push({ file, toolResult });
     }
 }
 function cursorHistoryImageParts(prompt) {
@@ -222,7 +244,7 @@ function cursorHistoryImageParts(prompt) {
         if (record.role === "user") {
             if (i === lastUserIndex)
                 continue;
-            pushImageFileParts(parts, record.content);
+            pushImageFileParts(parts, record.content, isToolMediaCaption(record));
             continue;
         }
         if (record.role === "assistant") {
@@ -244,11 +266,9 @@ function cursorHistoryImageParts(prompt) {
             for (const value of output.value) {
                 if (!value || typeof value !== "object")
                     continue;
-                const file = value;
-                if (file.type === "file-data" &&
-                    typeof file.mediaType === "string" &&
-                    file.mediaType.startsWith("image/"))
-                    parts.push(file);
+                const file = toolImagePart(value);
+                if (file)
+                    parts.push({ file, toolResult: true });
             }
         }
     }
@@ -264,11 +284,22 @@ export async function extractCursorHistoryImages(prompt, options) {
     const hashes = [];
     const hashesThisTurn = new Set();
     let duplicateCount = 0;
+    let omittedCount = 0;
     let totalBytes = 0;
-    for (const file of candidates) {
+    for (const { file, toolResult } of candidates) {
         // Resolve against the per-image cap first so a previously sent duplicate
         // does not fail merely because little combined budget remains this turn.
-        const image = await decodeCursorImagePart(file, MAX_CURSOR_IMAGE_INPUT_BYTES, options.signal, `image-${(options.filenameOffset ?? 0) + images.length + 1}`, MAX_CURSOR_IMAGE_INPUT_BYTES);
+        let image;
+        try {
+            image = await decodeCursorImagePart(file, MAX_CURSOR_IMAGE_INPUT_BYTES, options.signal, `image-${(options.filenameOffset ?? 0) + images.length + 1}`);
+        }
+        catch (error) {
+            options.signal?.throwIfAborted();
+            if (!toolResult || (error instanceof Error && error.name === "AbortError"))
+                throw error;
+            omittedCount++;
+            continue;
+        }
         const hash = imageContentHash(image.data);
         if (options.seenHashes?.has(hash) || hashesThisTurn.has(hash)) {
             duplicateCount++;
@@ -280,15 +311,71 @@ export async function extractCursorHistoryImages(prompt, options) {
         hashes.push(hash);
         hashesThisTurn.add(hash);
     }
-    return { images, hashes, candidateCount: candidates.length, duplicateCount };
+    return { images, hashes, candidateCount: candidates.length, duplicateCount, ...(omittedCount > 0 ? { omittedCount } : {}) };
+}
+/**
+ * Decode the images a host tool returned (its own `file-data` / `image-data`
+ * parts, or the `file` parts OpenCode moves into the trailing
+ * `Attached media from tool result:` message) for a held-Run exec result.
+ * Non-image parts are skipped; a part that cannot be decoded is dropped so the
+ * text result is still delivered.
+ */
+export async function extractCursorToolResultImages(parts, options = {}) {
+    const maxBytes = cursorImageBudget(options.maxBytes ?? MAX_CURSOR_IMAGE_INPUT_BYTES);
+    const images = [];
+    const hashes = [];
+    let totalBytes = 0;
+    let omittedCount = 0;
+    options.signal?.throwIfAborted();
+    for (const part of parts) {
+        options.signal?.throwIfAborted();
+        const file = toolImagePart(part);
+        if (!file)
+            continue;
+        if (images.length >= (options.maxImages ?? Infinity) || totalBytes >= maxBytes) {
+            omittedCount++;
+            continue;
+        }
+        try {
+            const image = await decodeCursorImagePart(file, maxBytes - totalBytes, options.signal, `image-${images.length + 1}`);
+            options.signal?.throwIfAborted();
+            totalBytes += image.data.length;
+            images.push(image);
+            hashes.push(imageContentHash(image.data));
+        }
+        catch (error) {
+            // Tool media is optional: a missing file or failed download must not
+            // strand every pending exec. Cancellation still belongs to the caller.
+            options.signal?.throwIfAborted();
+            if (error instanceof Error && error.name === "AbortError")
+                throw error;
+            omittedCount++;
+        }
+    }
+    return { images, hashes, omittedCount };
 }
 export async function extractCursorPromptImages(prompt, lastUser, options) {
     const maxBytes = cursorImageBudget(options.maxBytes ?? MAX_CURSOR_IMAGE_INPUT_BYTES);
-    const userImages = await extractCursorUserImages(lastUser, options.signal, maxBytes);
+    const toolCaption = isToolMediaCaption(lastUser);
+    const caption = toolCaption && options.supportsImages
+        ? await extractCursorToolResultImages(lastUser.content, { signal: options.signal, maxBytes })
+        : undefined;
+    const captionHashes = [];
+    const seenHashes = new Set(options.seenHistoryHashes);
+    let captionDuplicates = 0;
+    const userImages = toolCaption ? (caption?.images ?? []).filter((_image, index) => {
+        const hash = caption.hashes[index];
+        if (seenHashes.has(hash)) {
+            captionDuplicates++;
+            return false;
+        }
+        seenHashes.add(hash);
+        captionHashes.push(hash);
+        return true;
+    }) : await extractCursorUserImages(lastUser, options.signal, maxBytes);
     const userBytes = userImages.reduce((total, image) => total + image.data.length, 0);
     // Seed history dedupe with this-turn last-user hashes so the same bytes on an
     // earlier user/assistant/tool message are not attached twice in one Run.
-    const seenHashes = new Set(options.seenHistoryHashes);
     for (const image of userImages)
         seenHashes.add(imageContentHash(image.data));
     const history = await extractCursorHistoryImages(prompt, {
@@ -300,7 +387,11 @@ export async function extractCursorPromptImages(prompt, lastUser, options) {
     });
     return {
         ...history,
+        hashes: [...captionHashes, ...history.hashes],
+        duplicateCount: history.duplicateCount + captionDuplicates,
         images: [...userImages, ...history.images],
-        userImageCount: userImages.length,
+        userImageCount: toolCaption ? 0 : userImages.length,
+        ...((history.omittedCount ?? 0) + (caption?.omittedCount ?? 0) > 0
+            ? { omittedCount: (history.omittedCount ?? 0) + (caption?.omittedCount ?? 0) } : {}),
     };
 }

package/dist/image-save.d.ts

@@ -17,16 +17,24 @@ export declare const IMAGE_PERMISSION_DENIED_PREFIX = "CursorImagePermissionDeni
 export type ImageSaveToolContext = {
     worktree: string;
     directory: string;
-    ask(input: {
+    /**
+     * Classic OpenCode 1.x `ToolContext.ask`. A host whose tool context has no
+     * permission prompt (OpenCode 2.0's public `ToolContext`) passes `null`
+     * explicitly: the commit then writes after containment, gated only by the
+     * tool's catalog permission. A missing `ask` is refused, never treated as
+     * permission.
+     */
+    ask: ((input: {
         permission: string;
         patterns: string[];
         always: string[];
         metadata: Record<string, unknown>;
-    }): Promise<void>;
+    }) => Promise<void>) | null;
 };
 export type ImageSaveResult = {
     title: string;
     output: string;
+    bytes: number;
     attachments?: Array<{
         type: "file";
         mime: string;