cursor-opencode-provider 0.3.2 → 0.4.0

package/README.md

@@ -17,6 +17,7 @@ OpenCode driving a Cursor-routed Grok model through this provider:
 - **OpenCode integration** — registers a `cursor` provider with auth hooks and cached model list
 - **Authentication** — browser OAuth (PKCE), or API key from [cursor.com/settings](https://cursor.com/settings)
 - **Model discovery** — fetches available models from Cursor's API and caches them locally
+- **Image input** — advertises vision only for supported models and forwards OpenCode image attachments to Cursor
 - **Streaming** — bidirectional Connect-RPC Runs with stale-session rotation, health checks, semantic/read-idle deadlines, bounded replay-safe recovery, and activity-aware held tool continuations
 - **Tool calls** — maps Cursor exec-server messages to AI SDK / OpenCode tool-call parts, including catalog-aware native subagent execution: exact advertised custom agents win, `unspecified` / `generalPurpose` select `general`, read-oriented `bugbot` / `security-review` select `explore`, and `cursor-guide` selects enabled Kilo `scout` before `explore`; MiMo `actor` is used instead of its work-item `task` tool when advertised. The bridge also covers the Pi read/bash/edit/write/grep/find/ls request/result range, enforces the exact current OpenCode tool catalog, mirrors finalized display-only todo/plan state, and strips OpenCode's `read` XML envelope before returning content to Cursor.
 - **Thinking / reasoning** — surfaces extended-thinking deltas where the model supports it
@@ -47,7 +48,7 @@ Add the package to OpenCode config. OpenCode installs npm plugins with Bun at st
 }
 ```
 
-Pin a version if you want: `"cursor-opencode-provider@0.3.2"`.
+Pin a version if you want: `"cursor-opencode-provider@0.4.0"`.
 
 You can also install it yourself first:
 
@@ -117,7 +118,7 @@ browser login or an API key. `CURSOR_API_KEY` is also picked up automatically.
 }
 ```
 
-Pin a version if you want: `"cursor-opencode-provider@0.3.2/plugin/opencode2"`.
+Pin a version if you want: `"cursor-opencode-provider@0.4.0/plugin/opencode2"`.
 
 OpenCode 2.0 installs the published package into its host cache and loads the AI SDK
 entry from there (`aisdk:cursor-opencode-provider`). No extra env vars are required.
@@ -197,7 +198,7 @@ Feature parity with the classic plugin, and the two places 2.0 differs:
 | `chat.params` flags compaction turns | **No `chat.params` in 2.0** — the compaction agent is detected in `ctx.session.hook("context")` and correlated by session id |
 
 > **Beta.** OpenCode 2.0 and its plugin API are both beta and still changing. This
-> entrypoint is built against `@opencode-ai/plugin@next` (`0.0.0-next-16281`) and is
+> entrypoint is built against `@opencode-ai/plugin@next` (`0.0.0-next-17155`) and is
 > guarded by a compile-time conformance check, but expect churn.
 
 ### Authenticate
@@ -259,6 +260,28 @@ OpenCode’s context limit is static per model entry, while Cursor’s long-cont
 
 The Run still uses Cursor’s original model id; OpenCode’s synthetic `-1m` id is only for picking and limits.
 
+#### Context limit sources
+
+The provider resolves each catalog context limit in this order:
+
+1. Live `AvailableModels` metadata (variant `context` parameters first, then context-limit fields)
+2. Cursor’s published model table, generated from [`docs.md`](https://cursor.com/docs.md) alongside pricing data
+3. A conservative `200000` fallback when neither source publishes a limit
+
+The docs fallback only fills static catalog metadata. It does not invent Cursor variants or enable a long-context tier that `AvailableModels` did not advertise.
+
+#### Image input
+
+The provider advertises `text` + `image` input only when the selected Cursor model supports images; model output remains text. This works in the classic plugin, the 1.18 v2 plugin, and OpenCode 2.0.
+
+Image support is resolved in this order:
+
+1. Live `AvailableModels.supportsImages` metadata, including authoritative `false` values
+2. The `Capabilities` column in Cursor's [`docs.md`](https://cursor.com/docs.md), generated alongside context and pricing metadata
+3. Text-only when neither source describes the model
+
+OpenCode image file parts are decoded from bytes, base64/data URLs, local file URLs, or HTTP(S) URLs and sent through Cursor's `UserMessage.selected_context.selected_images` field. On fresh or rebased Runs, the provider also harvests image `file-data` from tool results and `file` parts from assistant history; previously sent history images are deduplicated by content hash per OpenCode session. Held-open continuation results remain text-only because Cursor's exec-result channel has no image field. Attachments are limited to 20 MiB total, matching OpenCode's desktop attachment budget. PDF, audio, and video inputs are not advertised or silently discarded.
+
 #### Max mode
 
 Cursor IDE has a separate **Max Mode** toggle that sets `requested_model.max_mode` and selects the default max / 1m variant. OpenCode has no equivalent custom toggle, so this provider approximates it:
@@ -337,6 +360,7 @@ OpenCode
 | `src/opencode2/` | 2.0-only catalog mapping, integration/auth, and local API types |
 | `src/plugin-core.ts` | Host-neutral SDK factory, package matching, API base/telemetry resolution |
 | `src/model-config.ts` | Cursor model → OpenCode model mapping shared by every plugin surface |
+| `src/image-input.ts` | AI SDK image attachment validation, decoding, and size limits |
 | `src/pricing.ts` / `src/pricing-data.ts` | Cursor docs token rates → classic `cost` and OpenCode 2.0 cost tiers |
 | `src/index.ts` | `createCursor` factory; default export is `CursorPlugin` |
 | `src/language-model.ts` | AI SDK `LanguageModelV3` adapter (`doStream`, `doGenerate`) |
@@ -426,4 +450,4 @@ Project `instructions` may reference absolute or `~/` paths (OpenCode parity). S
 
 ## License
 
-MIT
+MIT

package/dist/image-input.d.ts

@@ -0,0 +1,31 @@
+export declare const MAX_CURSOR_IMAGE_INPUT_BYTES: number;
+export type CursorImageInput = {
+    data: Uint8Array;
+    filename: string;
+    mimeType: string;
+};
+export type CursorHistoryImageExtraction = {
+    images: CursorImageInput[];
+    hashes: string[];
+    candidateCount: number;
+    duplicateCount: number;
+};
+export type CursorPromptImageExtraction = CursorHistoryImageExtraction & {
+    userImageCount: number;
+};
+export declare function hasCursorUserImages(lastUser: Record<string, unknown> | undefined): boolean;
+export declare function assertCursorUserImageSupport(lastUser: Record<string, unknown> | undefined, supportsImages: boolean, modelId: string): void;
+export declare function extractCursorUserImages(lastUser: Record<string, unknown> | undefined, signal?: AbortSignal, maxBytes?: number): Promise<CursorImageInput[]>;
+export declare function extractCursorHistoryImages(prompt: readonly unknown[], options: {
+    supportsImages: boolean;
+    seenHashes?: ReadonlySet<string>;
+    signal?: AbortSignal;
+    maxBytes?: number;
+    filenameOffset?: number;
+}): Promise<CursorHistoryImageExtraction>;
+export declare function extractCursorPromptImages(prompt: readonly unknown[], lastUser: Record<string, unknown> | undefined, options: {
+    supportsImages: boolean;
+    seenHistoryHashes?: ReadonlySet<string>;
+    signal?: AbortSignal;
+    maxBytes?: number;
+}): Promise<CursorPromptImageExtraction>;

package/dist/image-input.js

@@ -0,0 +1,281 @@
+import { createHash } from "node:crypto";
+import { readFile, stat } from "node:fs/promises";
+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;
+export function hasCursorUserImages(lastUser) {
+    return !!lastUser && Array.isArray(lastUser.content) && lastUser.content.some((part) => {
+        if (!part || typeof part !== "object")
+            return false;
+        const file = part;
+        return file.type === "file" && typeof file.mediaType === "string" && file.mediaType.startsWith("image/");
+    });
+}
+function unsupported(functionality, message) {
+    throw new UnsupportedFunctionalityError({ functionality, message });
+}
+export function assertCursorUserImageSupport(lastUser, supportsImages, modelId) {
+    if (!hasCursorUserImages(lastUser) || supportsImages)
+        return;
+    unsupported("image input", `Cursor model ${JSON.stringify(modelId)} does not support image input`);
+}
+function decodeBase64(value) {
+    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 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) {
+    if (!value.startsWith("data:")) {
+        return unsupported("image input", "Cursor provider supports base64-encoded image data URLs only");
+    }
+    const commaIndex = value.indexOf(",", 5);
+    if (commaIndex < 0) {
+        return unsupported("image input", "Cursor provider supports base64-encoded image data URLs only");
+    }
+    const metadata = value.slice(5, commaIndex);
+    const finalSeparator = metadata.lastIndexOf(";");
+    if (finalSeparator < 0 || metadata.slice(finalSeparator + 1) !== "base64") {
+        return unsupported("image input", "Cursor provider supports base64-encoded image data URLs only");
+    }
+    const firstSeparator = metadata.indexOf(";");
+    const mimeType = metadata.slice(0, firstSeparator);
+    return {
+        data: decodeBase64(value.slice(commaIndex + 1)),
+        mimeType: mimeType || undefined,
+    };
+}
+function inferImageMimeType(data) {
+    if (data.length >= 8 &&
+        data[0] === 0x89 && data[1] === 0x50 && data[2] === 0x4e && data[3] === 0x47 &&
+        data[4] === 0x0d && data[5] === 0x0a && data[6] === 0x1a && data[7] === 0x0a)
+        return "image/png";
+    if (data.length >= 3 && data[0] === 0xff && data[1] === 0xd8 && data[2] === 0xff) {
+        return "image/jpeg";
+    }
+    if (data.length >= 6) {
+        const header = Buffer.from(data.subarray(0, 6)).toString("ascii");
+        if (header === "GIF87a" || header === "GIF89a")
+            return "image/gif";
+    }
+    if (data.length >= 12 &&
+        Buffer.from(data.subarray(0, 4)).toString("ascii") === "RIFF" &&
+        Buffer.from(data.subarray(8, 12)).toString("ascii") === "WEBP")
+        return "image/webp";
+    return undefined;
+}
+function assertImageSize(size, remaining) {
+    if (size > remaining) {
+        unsupported("image input", `Cursor provider image attachments exceed the ${MAX_CURSOR_IMAGE_INPUT_BYTES / 1024 / 1024} MiB limit`);
+    }
+}
+function cursorImageBudget(value) {
+    if (!Number.isFinite(value))
+        return MAX_CURSOR_IMAGE_INPUT_BYTES;
+    return Math.min(MAX_CURSOR_IMAGE_INPUT_BYTES, Math.max(0, Math.floor(value)));
+}
+function imageContentHash(data) {
+    return createHash("sha256").update(data).digest("hex");
+}
+async function readResponseBytes(response, remaining) {
+    const declaredLength = Number(response.headers.get("content-length"));
+    if (Number.isFinite(declaredLength) && declaredLength > remaining) {
+        assertImageSize(declaredLength, remaining);
+    }
+    if (!response.body) {
+        const data = new Uint8Array(await response.arrayBuffer());
+        assertImageSize(data.length, remaining);
+        return data;
+    }
+    const chunks = [];
+    let total = 0;
+    const reader = response.body.getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            total += value.length;
+            if (total > remaining) {
+                await reader.cancel();
+                assertImageSize(total, remaining);
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const data = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        data.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return data;
+}
+async function resolveImageData(value, remaining, signal) {
+    if (value instanceof Uint8Array)
+        return { data: Uint8Array.from(value) };
+    if (typeof value === "string") {
+        return value.startsWith("data:") ? decodeDataUrl(value) : { data: decodeBase64(value) };
+    }
+    if (value.protocol === "data:")
+        return decodeDataUrl(value.href);
+    if (value.protocol === "file:") {
+        const filePath = fileURLToPath(value);
+        const info = await stat(filePath);
+        assertImageSize(info.size, remaining);
+        return { data: Uint8Array.from(await readFile(filePath)), filename: path.basename(filePath) };
+    }
+    if (value.protocol !== "http:" && value.protocol !== "https:") {
+        return unsupported("image URL input", `Cursor provider does not support image URL protocol ${JSON.stringify(value.protocol)}`);
+    }
+    const response = await fetch(value, { signal });
+    if (!response.ok) {
+        return unsupported("image URL input", `Cursor provider could not fetch image URL (HTTP ${response.status})`);
+    }
+    return {
+        data: await readResponseBytes(response, remaining),
+        mimeType: response.headers.get("content-type")?.split(";", 1)[0]?.trim() || undefined,
+        filename: path.basename(value.pathname) || undefined,
+    };
+}
+async function decodeCursorImagePart(file, remaining, signal, defaultFilename, resolveLimit = remaining) {
+    if (typeof file.mediaType !== "string" || !file.mediaType.startsWith("image/")) {
+        return unsupported("file input", `Cursor provider supports image attachments only, not ${JSON.stringify(file.mediaType)}`);
+    }
+    if (!(file.data instanceof Uint8Array) && typeof file.data !== "string" && !(file.data instanceof URL)) {
+        return unsupported("image input", "Cursor provider received an invalid image data value");
+    }
+    const resolved = await resolveImageData(file.data, resolveLimit, signal);
+    assertImageSize(resolved.data.length, remaining);
+    const declaredMimeType = file.mediaType;
+    const mimeType = declaredMimeType === "image/*"
+        ? (resolved.mimeType?.startsWith("image/") ? resolved.mimeType : inferImageMimeType(resolved.data))
+        : declaredMimeType;
+    if (!mimeType?.startsWith("image/") || mimeType === "image/*") {
+        return unsupported("image input", "Cursor provider could not determine the image media type");
+    }
+    return {
+        data: resolved.data,
+        filename: (typeof file.filename === "string" && file.filename ? path.basename(file.filename) : undefined) ??
+            resolved.filename ??
+            defaultFilename,
+        mimeType,
+    };
+}
+export async function extractCursorUserImages(lastUser, signal, maxBytes = MAX_CURSOR_IMAGE_INPUT_BYTES) {
+    if (!lastUser || !Array.isArray(lastUser.content))
+        return [];
+    const byteBudget = cursorImageBudget(maxBytes);
+    const images = [];
+    let totalBytes = 0;
+    for (const part of lastUser.content) {
+        if (!part || typeof part !== "object")
+            continue;
+        const file = part;
+        if (file.type !== "file")
+            continue;
+        const image = await decodeCursorImagePart(file, byteBudget - totalBytes, signal, `image-${images.length + 1}`);
+        totalBytes += image.data.length;
+        images.push(image);
+    }
+    return images;
+}
+function cursorHistoryImageParts(prompt) {
+    const parts = [];
+    for (const message of prompt) {
+        if (!message || typeof message !== "object")
+            continue;
+        const record = message;
+        if (!Array.isArray(record.content))
+            continue;
+        if (record.role === "assistant") {
+            for (const part of record.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);
+            }
+            continue;
+        }
+        if (record.role !== "tool")
+            continue;
+        for (const part of record.content) {
+            if (!part || typeof part !== "object")
+                continue;
+            const toolResult = part;
+            if (toolResult.type !== "tool-result" || !toolResult.output || typeof toolResult.output !== "object") {
+                continue;
+            }
+            const output = toolResult.output;
+            if (output.type !== "content" || !Array.isArray(output.value))
+                continue;
+            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);
+            }
+        }
+    }
+    return parts;
+}
+export async function extractCursorHistoryImages(prompt, options) {
+    const candidates = cursorHistoryImageParts(prompt);
+    if (!options.supportsImages) {
+        return { images: [], hashes: [], candidateCount: candidates.length, duplicateCount: 0 };
+    }
+    const maxBytes = cursorImageBudget(options.maxBytes ?? MAX_CURSOR_IMAGE_INPUT_BYTES);
+    const images = [];
+    const hashes = [];
+    const hashesThisTurn = new Set();
+    let duplicateCount = 0;
+    let totalBytes = 0;
+    for (const file 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);
+        const hash = imageContentHash(image.data);
+        if (options.seenHashes?.has(hash) || hashesThisTurn.has(hash)) {
+            duplicateCount++;
+            continue;
+        }
+        assertImageSize(image.data.length, maxBytes - totalBytes);
+        totalBytes += image.data.length;
+        images.push(image);
+        hashes.push(hash);
+        hashesThisTurn.add(hash);
+    }
+    return { images, hashes, candidateCount: candidates.length, duplicateCount };
+}
+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 userBytes = userImages.reduce((total, image) => total + image.data.length, 0);
+    const history = await extractCursorHistoryImages(prompt, {
+        supportsImages: options.supportsImages,
+        seenHashes: options.seenHistoryHashes,
+        signal: options.signal,
+        maxBytes: maxBytes - userBytes,
+        filenameOffset: userImages.length,
+    });
+    return {
+        ...history,
+        images: [...userImages, ...history.images],
+        userImageCount: userImages.length,
+    };
+}

package/dist/language-model.js

@@ -24,6 +24,8 @@ import { resolveAgentUrl } from "./agent-url.js";
 import { CURSOR_API_HOST, CURSOR_COMPACTION_OPTION } from "./shared.js";
 import { isCompactionSession } from "./compaction-marker.js";
 import { getSessionDirectory } from "./session-directory.js";
+import { assertCursorUserImageSupport, extractCursorPromptImages } from "./image-input.js";
+import { resolveCursorModelSupportsImages } from "./model-metadata.js";
 import { consumeCursorShellResult, registerCursorShellCall, } from "./shell-timeout.js";
 import { analyzeReplayFrame, AttemptReplaySafety } from "./replay-safety.js";
 import { readAllFieldsStrict } from "./protocol/struct.js";
@@ -36,12 +38,14 @@ let _availableModelsMtimeMs = -1;
 // session so the new Cursor conversation is still born with tool definitions;
 // execution remains disabled for the summary turn itself.
 const toolCatalogBySession = new Map();
+const sentHistoryImageHashesBySession = new Map();
 // A compaction Run uses its own summary-agent system prompt. Its opaque Cursor
 // checkpoint must never become the base for the resumed normal agent: doing so
 // suppresses OpenCode's compacted prompt/system seed and makes Cursor narrate
 // tool use instead of emitting exec requests. Rebase once on the next turn.
 const postCompactionRebaseBySession = new Set();
 export const MAX_TURN_STATE_SESSIONS = 256;
+const MAX_SENT_HISTORY_IMAGES_PER_SESSION = 256;
 const DEFAULT_RETRY_POLICY = {
     maxAttempts: 3,
     baseDelayMs: 500,
@@ -251,6 +255,39 @@ function rememberPostCompactionRebase(sessionKey) {
         postCompactionRebaseBySession.delete(oldest);
     }
 }
+function sentHistoryImageHashes(sessionKey) {
+    if (!sessionKey)
+        return undefined;
+    const hashes = sentHistoryImageHashesBySession.get(sessionKey);
+    if (!hashes)
+        return undefined;
+    sentHistoryImageHashesBySession.delete(sessionKey);
+    sentHistoryImageHashesBySession.set(sessionKey, hashes);
+    return hashes;
+}
+function rememberSentHistoryImageHashes(sessionKey, hashes) {
+    if (!sessionKey || hashes.length === 0)
+        return;
+    const remembered = sentHistoryImageHashesBySession.get(sessionKey) ?? new Set();
+    for (const hash of hashes) {
+        remembered.delete(hash);
+        remembered.add(hash);
+        while (remembered.size > MAX_SENT_HISTORY_IMAGES_PER_SESSION) {
+            const oldest = remembered.values().next().value;
+            if (!oldest)
+                break;
+            remembered.delete(oldest);
+        }
+    }
+    sentHistoryImageHashesBySession.delete(sessionKey);
+    sentHistoryImageHashesBySession.set(sessionKey, remembered);
+    while (sentHistoryImageHashesBySession.size > MAX_TURN_STATE_SESSIONS) {
+        const oldest = sentHistoryImageHashesBySession.keys().next().value;
+        if (!oldest)
+            break;
+        sentHistoryImageHashesBySession.delete(oldest);
+    }
+}
 export function createCursorLanguageModel(modelId, providerId, options) {
     // Host Path.cache / explicit override wins over XDG heuristics for this process.
     if (options.cacheDir)
@@ -484,9 +521,10 @@ async function startSession(modelId, token, callOptions, options, startOptions)
             `sessionKey=${sessionKey ?? "(none)"} ` +
             `previousId=${bound.previousId ?? "-"} → conversationId=${conversationId}`);
     }
+    const lastUser = [...prompt].reverse().find((message) => message.role === "user");
     const userText = recovery?.kind === "rebase"
         ? "Continue the interrupted turn from the conversation history above. Do not repeat completed work."
-        : (extractUserText([...prompt].reverse().find((m) => m.role === "user")) || ".");
+        : (extractUserText(lastUser) || ".");
     // v1 sets `options.workspaceRoot` correctly per invocation (`input.directory`,
     // one plugin instance per project). OpenCode 2.0 runs one daemon across many
     // projects, so its static `options.workspaceRoot` is only a last-resort
@@ -521,6 +559,30 @@ async function startSession(modelId, token, callOptions, options, startOptions)
         : undefined;
     const hintMaxMode = !!(providerOptions?.maxMode ?? false);
     const modelInfo = _availableModels?.find((m) => m.id === cursorModelId);
+    const supportsImages = resolveCursorModelSupportsImages(cursorModelId, modelInfo?.supportsImages);
+    if (!resuming) {
+        assertCursorUserImageSupport(lastUser, supportsImages, cursorModelId);
+    }
+    const imageExtraction = resuming
+        ? { images: [], hashes: [], candidateCount: 0, duplicateCount: 0, userImageCount: 0 }
+        : await extractCursorPromptImages(prompt, lastUser, {
+            supportsImages,
+            // Content hashes are retained for the OpenCode session so growing
+            // history does not re-upload old screenshots. A recovery rebase opens
+            // a new Cursor conversation, so it must resend the same payload.
+            seenHistoryHashes: recovery?.kind === "rebase"
+                ? undefined
+                : sentHistoryImageHashes(sessionKey),
+            signal: callOptions.abortSignal,
+        });
+    if (!supportsImages && imageExtraction.candidateCount > 0) {
+        trace(`image input: dropped ${imageExtraction.candidateCount} tool/assistant history image(s); ` +
+            `model=${cursorModelId} does not support images`);
+    }
+    if (imageExtraction.duplicateCount > 0) {
+        trace(`image input: skipped ${imageExtraction.duplicateCount} previously sent history image(s)`);
+    }
+    const images = imageExtraction.images;
     const parameterValues = resolveVariantParameters(modelInfo, {
         reasoningEffort,
         maxMode: hintMaxMode,
@@ -566,6 +628,7 @@ async function startSession(modelId, token, callOptions, options, startOptions)
         : (bound.reset ? undefined : getCheckpoint(conversationId));
     const reqBytes = buildRunRequest({
         text: userText,
+        images,
         modelId: cursorModelId,
         conversationId,
         systemPrompt: conversationState ? undefined : systemPrompt,
@@ -601,6 +664,7 @@ async function startSession(modelId, token, callOptions, options, startOptions)
         `tools=${tools.length} incomingTools=${incomingTools.length} compaction=${isCompaction} ` +
         `skills=${skillsCount} hooks=${hooksCtx ? hooksCtx.split("\n").length : 0} ` +
         `availableModels=${_availableModels?.length ?? 0} userTextLen=${userText.length} ` +
+        `images=${images.length} imageBytes=${images.reduce((total, image) => total + image.data.length, 0)} ` +
         `historyMsgs=${history.length} historyChars=${historyChars} ` +
         `checkpointLen=${conversationState?.length ?? 0} reset=${bound.reset} ` +
         `resume=${resuming} ` +
@@ -614,6 +678,7 @@ async function startSession(modelId, token, callOptions, options, startOptions)
         trace(`hash checkpoint sha256=${sha(conversationState)}`);
     try {
         await writeWithBackpressure(stream, reqBytes, "initial Run request");
+        rememberSentHistoryImageHashes(sessionKey, imageExtraction.hashes);
     }
     catch (error) {
         stream.destroy();
@@ -1604,6 +1669,8 @@ function toolResultOutputToText(output) {
         return { text: JSON.stringify(o.value ?? null), isError };
     }
     if (o.type === "content" && Array.isArray(o.value)) {
+        // Held-open continuation exec frames are text-only. Media is intentionally
+        // omitted here and harvested from the full prompt when a fresh Run opens.
         const text = o.value
             .map((c) => {
             const cp = c;

package/dist/model-config.js

@@ -1,5 +1,6 @@
 import { CURSOR_VARIANT_PARAMETERS_KEY, CURSOR_WIRE_MODEL_ID_KEY, parseCursorContextLimit, } from "./models.js";
 import { applyCursorModelCost } from "./pricing.js";
+import { getDocumentedCursorModelContext, resolveCursorModelSupportsImages, } from "./model-metadata.js";
 /**
  * Cursor `ModelInfo` → OpenCode model-config mapping.
  *
@@ -147,19 +148,26 @@ export function modelInfoToConfig(mi, options = {}) {
     // OpenCode's context limit is static per model entry, while Cursor's context
     // tier is a variant parameter. Long-context choices are therefore emitted as
     // separate OpenCode entries by modelsToConfig.
+    const documentedContext = getDocumentedCursorModelContext(mi.id);
     const context = contextTier === "long"
-        ? (mi.maxContextForMaxMode ?? 1_000_000)
-        : (mi.maxContext ?? 200_000);
+        ? (mi.maxContextForMaxMode ?? documentedContext?.maxContextForMaxMode ?? 1_000_000)
+        : (mi.maxContext ?? documentedContext?.maxContext ?? 200_000);
     // OpenCode's overflow/compaction/UI use limit.context; generation and
     // thinking budgets use limit.output. models.dev 1M peers advertise
     // 64k–128k output — a tiny cap makes long-context sessions feel broken
     // even when the 1M input window is correct.
     const output = contextTier === "long" ? 128_000 : 32_000;
+    const supportsImages = resolveCursorModelSupportsImages(mi.id, mi.supportsImages);
     const config = {
         name,
+        attachment: supportsImages,
         reasoning: mi.supportsThinking ?? false,
         tool_call: mi.supportsAgent ?? true,
         temperature: false,
+        modalities: {
+            input: supportsImages ? ["text", "image"] : ["text"],
+            output: ["text"],
+        },
         limit: {
             context,
             output,

package/dist/model-metadata.d.ts

@@ -0,0 +1,10 @@
+export type CursorModelContext = {
+    maxContext?: number;
+    maxContextForMaxMode?: number;
+};
+export type CursorModelCapabilities = {
+    supportsImages: boolean;
+};
+export declare function getDocumentedCursorModelContext(modelId: string): CursorModelContext | undefined;
+export declare function getDocumentedCursorModelCapabilities(modelId: string): CursorModelCapabilities | undefined;
+export declare function resolveCursorModelSupportsImages(modelId: string, availableModelsValue?: boolean): boolean;

package/dist/model-metadata.js

@@ -0,0 +1,12 @@
+import { CURSOR_MODEL_CAPABILITIES, CURSOR_MODEL_CONTEXTS } from "./pricing-data.js";
+export function getDocumentedCursorModelContext(modelId) {
+    const context = CURSOR_MODEL_CONTEXTS[modelId];
+    return context ? { ...context } : undefined;
+}
+export function getDocumentedCursorModelCapabilities(modelId) {
+    const capabilities = CURSOR_MODEL_CAPABILITIES[modelId];
+    return capabilities ? { ...capabilities } : undefined;
+}
+export function resolveCursorModelSupportsImages(modelId, availableModelsValue) {
+    return availableModelsValue ?? getDocumentedCursorModelCapabilities(modelId)?.supportsImages ?? false;
+}

package/dist/models.d.ts

@@ -19,6 +19,7 @@ export type ModelInfo = {
     family?: string;
     supportsThinking?: boolean;
     supportsAgent?: boolean;
+    supportsImages?: boolean;
     maxContext?: number;
     /** Context window when max-mode is on (proto field 16). */
     maxContextForMaxMode?: number;

package/dist/models.js

@@ -109,6 +109,7 @@ function normalizeModelInfo(value) {
     const family = optionalString(value, ["family"]);
     const supportsThinking = optionalBoolean(value, ["supportsThinking", "supports_thinking"]);
     const supportsAgent = optionalBoolean(value, ["supportsAgent", "supports_agent"]);
+    const supportsImages = optionalBoolean(value, ["supportsImages", "supports_images"]);
     const supportsMaxMode = optionalBoolean(value, ["supportsMaxMode", "supports_max_mode"]);
     const maxContext = optionalPositiveNumber(value, ["maxContext", "contextTokenLimit", "context_token_limit"]);
     const maxContextForMaxMode = optionalPositiveNumber(value, ["maxContextForMaxMode", "contextTokenLimitForMaxMode", "context_token_limit_for_max_mode"]);
@@ -116,6 +117,7 @@ function normalizeModelInfo(value) {
         family === null ||
         supportsThinking === null ||
         supportsAgent === null ||
+        supportsImages === null ||
         supportsMaxMode === null ||
         maxContext === null ||
         maxContextForMaxMode === null) {
@@ -127,6 +129,7 @@ function normalizeModelInfo(value) {
         ...(family === undefined ? {} : { family }),
         ...(supportsThinking === undefined ? {} : { supportsThinking }),
         ...(supportsAgent === undefined ? {} : { supportsAgent }),
+        ...(supportsImages === undefined ? {} : { supportsImages }),
         ...(maxContext === undefined ? {} : { maxContext }),
         ...(maxContextForMaxMode === undefined ? {} : { maxContextForMaxMode }),
         ...(supportsMaxMode === undefined ? {} : { supportsMaxMode }),
@@ -293,11 +296,16 @@ export function mapAvailableModelsResponse(raw) {
             variantContextTokens(variants.find((v) => variantContextTokens(v) !== 1_000_000)) ??
             variantContextTokens(variants.find((v) => v.parameterValues.some((p) => p.id === "context")));
         const variantMaxContext = variantContextTokens(variants.find((v) => v.isDefaultMax));
+        const supportsImages = optionalBoolean(e, ["supportsImages", "supports_images"]);
+        if (supportsImages === null) {
+            throw new Error(`AvailableModels returned invalid supportsImages for ${name}`);
+        }
         models.push({
             id: name,
             displayName: (e.clientDisplayName ?? e.client_display_name ?? name),
             supportsThinking: apiBoolean(e, ["supportsThinking", "supports_thinking"]),
             supportsAgent: apiBoolean(e, ["supportsAgent", "supports_agent"]),
+            ...(supportsImages === undefined ? {} : { supportsImages }),
             maxContext: variantBaseContext ?? positiveNumber(e.contextTokenLimit ?? e.context_token_limit),
             maxContextForMaxMode: variantMaxContext ??
                 positiveNumber(e.contextTokenLimitForMaxMode ?? e.context_token_limit_for_max_mode),

package/dist/opencode2/catalog.js

@@ -58,12 +58,16 @@ function applyModelEntry(draft, id, entry) {
         model.modelID = wireId;
         model.providerID = CURSOR_PROVIDER_ID;
         model.name = entry.name;
+        const inputModalities = Array.isArray(entry.modalities?.input)
+            ? entry.modalities.input.filter((modality) => typeof modality === "string")
+            : ["text"];
+        const outputModalities = Array.isArray(entry.modalities?.output)
+            ? entry.modalities.output.filter((modality) => typeof modality === "string")
+            : ["text"];
         model.capabilities = {
             tools: entry.tool_call !== false,
-            // The provider does not convert file/image prompt parts, so text-only is
-            // the honest declaration. Revisit alongside Cursor's `supports_images`.
-            input: ["text"],
-            output: ["text"],
+            input: inputModalities,
+            output: outputModalities,
         };
         model.limit = { context: entry.limit.context, output: entry.limit.output };
         model.variants = variants;