cursor-opencode-provider 0.3.2 → 0.4.1

package/dist/language-model.js

@@ -6,7 +6,7 @@ import { trace, traceRequestContextPaths } from "./debug.js";
 import { buildRunRequest, buildHeartbeat } from "./protocol/request.js";
 import { decodeFramePayload } from "./protocol/framing.js";
 import { debugWalkTurnEnded, decodeMessage } from "./protocol/messages.js";
-import { parseExecServerMessage, buildToolCallPart, buildExecClientMessages, buildReadRejectionMessages, classifyMissingReadTarget, resolveReadTargetPath, parseExecIdFromToolCallId, detectExecVariantField, buildRequestContextResult, buildMcpStateResult, buildCustomWebToolAliases, extractHostSubagentCatalog, resolveCustomWebToolAlias, remapNativeSubagentForCatalog, remapEditToolsForCatalog, CUSTOM_WEBFETCH_TOOL, CUSTOM_WEBSEARCH_TOOL, } from "./protocol/tools.js";
+import { parseExecServerMessage, buildToolCallPart, buildExecClientMessages, buildReadRejectionMessages, classifyMissingReadTarget, resolveReadTargetPath, parseExecIdFromToolCallId, detectExecVariantField, buildRequestContextResult, buildMcpStateResult, buildCustomWebToolAliases, extractHostSubagentCatalog, resolveCustomWebToolAlias, remapNativeSubagentForCatalog, remapCorrelatedEditWriteForCatalog, remapEditToolsForCatalog, CUSTOM_WEBFETCH_TOOL, CUSTOM_WEBSEARCH_TOOL, } from "./protocol/tools.js";
 import { describeCursorExecVariant } from "./protocol/exec-variants.js";
 import { advertisedToolNamesFromDescriptors, extractExecDisplayCallId, extractProtobufSubmessage, listProtobufFieldNumbers, parseDisplayToolCall, resolveBridgedOpenCodeToolCall, } from "./protocol/tool-call-bridge.js";
 import { handleKvServerMessage } from "./protocol/kv.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)
@@ -427,13 +464,19 @@ export async function pumpWithRecovery(input) {
             const delayMs = retryDelayMs(failure, attempt + 1, retryPolicy);
             trace(`Run retry backoff: attempt=${attempt + 1}/${maxRecoveries} delayMs=${delayMs}`);
             await sleepForRetry(delayMs, input.abortSignal);
-            session = await input.recover(checkpoint
+            const recovery = checkpoint
                 ? {
                     kind: "resume",
                     conversationId: pumpedSession.conversationId,
                     checkpoint: Uint8Array.from(checkpoint),
                 }
-                : { kind: "rebase" });
+                : { kind: "rebase" };
+            session = await input.recover(recovery);
+            if (recovery.kind === "resume") {
+                session.hadToolCallBoundary = pumpedSession.hadToolCallBoundary;
+                session.usageEstimate = { ...pumpedSession.usageEstimate };
+                session.editToolCalls = new Map(pumpedSession.editToolCalls);
+            }
             input.onSession?.(session);
         }
         finally {
@@ -484,9 +527,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 +565,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 +634,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 +670,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 +684,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();
@@ -628,6 +699,7 @@ async function startSession(modelId, token, callOptions, options, startOptions)
         frames: stream.frames()[Symbol.asyncIterator](),
         pending: new Map(),
         displayToolCalls: new Map(),
+        editToolCalls: new Map(),
         nextBridgedExecId: 900_000,
         blobs: new Map(),
         toolDescriptors,
@@ -1080,8 +1152,12 @@ export async function pump(session, controller, ids, abortSignal) {
     };
     const emitFinish = (te, reason) => {
         closeOpenSpans();
-        if (te) {
-            // Authoritative TurnEnded counts — replace the running estimate.
+        // TurnEnded is request-local only when this Run did not previously stop at
+        // a tool boundary. On a held multi-step Run Cursor aggregates every model
+        // invocation into these counters; treating that billed total as the final
+        // request's prompt size makes OpenCode compact after ordinary tasks.
+        const cumulativeTurnEnded = !!te && session.hadToolCallBoundary === true;
+        if (te && !cumulativeTurnEnded) {
             session.usageEstimate = {
                 inputTokens: turnEndedCounter(te, "input_tokens"),
                 outputTokens: turnEndedCounter(te, "output_tokens"),
@@ -1091,9 +1167,11 @@ export async function pump(session, controller, ids, abortSignal) {
             };
         }
         const est = session.usageEstimate;
-        const usage = te
+        const usage = te && !cumulativeTurnEnded
             ? buildLanguageModelV3UsageFromTurnEnded(te)
             : buildLanguageModelV3UsageFromEstimate(est, promptTokens, requestUsage.outputChars, estimateTokens);
+        if (!te)
+            session.hadToolCallBoundary = true;
         const providerMetadata = te ? cursorTurnEndedProviderMetadata(te) : undefined;
         const reasonLabel = typeof reason === "object" && reason && "unified" in reason
             ? String(reason.unified ?? "unknown")
@@ -1104,9 +1182,11 @@ export async function pump(session, controller, ids, abortSignal) {
             `v3In=${inTotal} v3Out=${outTotal} ` +
             `v3CacheRead=${usage.inputTokens?.cacheRead ?? 0} v3CacheWrite=${usage.inputTokens?.cacheWrite ?? 0} ` +
             `v3Reasoning=${usage.outputTokens?.reasoning ?? 0} ` +
-            `rawIn=${est.inputTokens} rawOut=${est.outputTokens} ` +
-            `rawCacheRead=${est.cacheRead} rawCacheWrite=${est.cacheWrite} ` +
-            `source=${te ? "turn_ended" : "estimate"}`);
+            `rawIn=${te ? turnEndedCounter(te, "input_tokens") : est.inputTokens} ` +
+            `rawOut=${te ? turnEndedCounter(te, "output_tokens") : est.outputTokens} ` +
+            `rawCacheRead=${te ? turnEndedCounter(te, "cache_read") : est.cacheRead} ` +
+            `rawCacheWrite=${te ? turnEndedCounter(te, "cache_write") : est.cacheWrite} ` +
+            `source=${te ? (cumulativeTurnEnded ? "estimate-cumulative-turn-ended" : "turn_ended") : "estimate"}`);
         safeEnqueue({
             type: "finish",
             usage,
@@ -1262,6 +1342,15 @@ export async function pump(session, controller, ids, abortSignal) {
                 if (callId && toolCall) {
                     session.displayToolCalls.set(callId, toolCall);
                     const variant = Object.keys(toolCall).find((k) => k.endsWith("_tool_call")) ?? "?";
+                    const display = parseDisplayToolCall(callId, toolCall);
+                    const editPath = display?.variant === "edit_tool_call"
+                        && typeof display.args.path === "string"
+                        ? display.args.path
+                        : undefined;
+                    if (editPath) {
+                        const editToolCalls = session.editToolCalls ?? (session.editToolCalls = new Map());
+                        editToolCalls.set(callId, { path: editPath });
+                    }
                     const callIdLog = callId.replace(/\r?\n/g, "\\n");
                     let wireFields = "";
                     if (variant === "?") {
@@ -1276,6 +1365,8 @@ export async function pump(session, controller, ids, abortSignal) {
             else if (iu?.tool_call_completed) {
                 const completed = iu.tool_call_completed;
                 const callId = typeof completed.call_id === "string" ? completed.call_id : "";
+                if (callId)
+                    session.editToolCalls?.delete(callId);
                 // If exec already claimed this call_id, display map entry is gone — skip.
                 if (!callId || !session.displayToolCalls.has(callId)) {
                     if (callId) {
@@ -1371,6 +1462,7 @@ export async function pump(session, controller, ids, abortSignal) {
                 }
                 else {
                     replaySafety.markBarrier("non-control-exec");
+                    const displayCallId = extractExecDisplayCallId(esm);
                     const parsed = parseExecServerMessage(esm);
                     if (parsed) {
                         const executableToolName = resolveCustomWebToolAlias(parsed.toolName, session.toolAliases);
@@ -1379,12 +1471,24 @@ export async function pump(session, controller, ids, abortSignal) {
                             parsed.toolName = executableToolName;
                         }
                         remapNativeSubagentForCatalog(parsed, advertisedToolNameSet, session.subagentCatalog);
+                        const editCall = displayCallId
+                            ? session.editToolCalls?.get(displayCallId)
+                            : undefined;
+                        if (editCall) {
+                            const remapped = remapCorrelatedEditWriteForCatalog(parsed, advertisedToolNameSet, editCall.path, workspaceRootFromRequestContext(session.requestContext));
+                            if (parsed.resultField === "write_result" && displayCallId) {
+                                session.editToolCalls?.delete(displayCallId);
+                            }
+                            if (remapped) {
+                                trace(`exec: preserved edit intent callId=${displayCallId} ` +
+                                    `path=${JSON.stringify(editCall.path)}`);
+                            }
+                        }
                         // Hosts that advertise `apply_patch` in place of `edit`/`write` (see
                         // protocol/apply-patch.ts) still receive Cursor's native write/edit
                         // exec requests. Translate before the unavailable-tool check below.
                         remapEditToolsForCatalog(parsed, advertisedToolNameSet, workspaceRootFromRequestContext(session.requestContext));
                     }
-                    const displayCallId = extractExecDisplayCallId(esm);
                     trace(`exec: id=${parsed?.id} variant=${parsed ? Object.keys(parsed).join(",") : "none"} toolName=${parsed?.toolName} resultField=${parsed?.resultField}`);
                     if (parsed) {
                         if (parsed.localError) {
@@ -1604,6 +1708,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;
@@ -1703,7 +1809,7 @@ export function estimatePromptTokens(prompt) {
         .join("\n");
     return estimateTokens(serializedContent.length);
 }
-/** Preserve cumulative Cursor counters as diagnostics, never as AI SDK request usage. */
+/** Preserve exact Cursor counters as diagnostics when they are cumulative across a multi-step Run. */
 export function cursorTurnEndedProviderMetadata(te) {
     return {
         cursor: {

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;

package/dist/opencode2/types.d.ts

@@ -9,7 +9,7 @@
  *     we touch is more stable than pinning a moving target.
  *
  * These mirror `@opencode-ai/plugin@next` `dist/promise/*.d.ts` as of
- * `0.0.0-next-16281`. `test/opencode2-conformance.test-d.ts` asserts our
+ * `0.0.0-next-17155`. `test/opencode2-conformance.types.ts` asserts our
  * default export still satisfies the real 2.0 `Plugin` interface.
  *
  * Effect `Schema` brands (Provider.ID, Model.ID, …) are modelled as plain
@@ -228,13 +228,19 @@ export type ToolDefinition = {
 export type ToolDraft = {
     add(tool: ToolDefinition): void;
 };
-export type ToolHookBase = {
+export type ToolHookBaseFields = {
     readonly tool: string;
     readonly sessionID: string;
     readonly agent: string;
     readonly messageID: string;
-    readonly callID: string;
 };
+export type ToolHookBase = ToolHookBaseFields & ({
+    readonly id: string;
+    readonly callID?: string;
+} | {
+    readonly id?: string;
+    readonly callID: string;
+});
 export type ToolHooks = {
     readonly "execute.before": ToolHookBase & {
         input: unknown;

package/dist/opencode2/types.js

@@ -9,7 +9,7 @@
  *     we touch is more stable than pinning a moving target.
  *
  * These mirror `@opencode-ai/plugin@next` `dist/promise/*.d.ts` as of
- * `0.0.0-next-16281`. `test/opencode2-conformance.test-d.ts` asserts our
+ * `0.0.0-next-17155`. `test/opencode2-conformance.types.ts` asserts our
  * default export still satisfies the real 2.0 `Plugin` interface.
  *
  * Effect `Schema` brands (Provider.ID, Model.ID, …) are modelled as plain

package/dist/plugin-opencode2.js

@@ -35,6 +35,12 @@ async function loadModels(cacheDir, accessToken) {
     // Preserve offline / stale-cache behavior rather than emptying the picker.
     return cached?.models ?? [];
 }
+function toolExecutionID(event) {
+    const id = event.id ?? event.callID;
+    if (!id)
+        throw new Error("OpenCode 2.0 tool hook did not provide an execution id");
+    return id;
+}
 const plugin = {
     id: "cursor.provider",
     setup: async (ctx) => {
@@ -142,29 +148,31 @@ const plugin = {
         await track(ctx.tool.hook("execute.before", (event) => {
             if (event.tool !== "bash")
                 return;
+            const executionID = toolExecutionID(event);
             // No `shell.env` in 2.0 → always use the wrapper-file command form.
-            prepareCursorShellArgs(event.callID, event.input, {
+            prepareCursorShellArgs(executionID, event.input, {
                 preferWrapperCommand: true,
             });
         }));
         await track(ctx.tool.hook("execute.after", (event) => {
             if (event.tool !== "bash")
                 return;
+            const executionID = toolExecutionID(event);
             try {
                 if (event.status !== "completed")
                     return;
                 const result = event.result;
-                result.title = cursorShellOriginalCommand(event.callID) ?? result.title;
-                result.output = captureCursorShellResult(event.callID, result.output, result.metadata);
+                result.title = cursorShellOriginalCommand(executionID) ?? result.title;
+                result.output = captureCursorShellResult(executionID, result.output, result.metadata);
                 if (result.metadata && typeof result.metadata === "object") {
                     const metadata = result.metadata;
                     if (typeof metadata.output === "string") {
-                        metadata.output = sanitizeRegisteredCursorShellOutput(event.callID, metadata.output);
+                        metadata.output = sanitizeRegisteredCursorShellOutput(executionID, metadata.output);
                     }
                 }
             }
             finally {
-                releaseCursorShellEnv(event.callID);
+                releaseCursorShellEnv(executionID);
             }
         }));
         // ── Compaction marker + session directory ───────────────────────────────