cursor-opencode-provider 0.6.4 → 0.6.6

package/dist/language-model.js

@@ -6,8 +6,11 @@ import { trace, traceRequestContextPaths } from "./debug.js";
 import { buildRunRequest, buildHeartbeat } from "./protocol/request.js";
 import { decodeFramePayload } from "./protocol/framing.js";
 import { debugWalkTurnEnded, decodeMessage, encodeMessage } from "./protocol/messages.js";
-import { parseExecServerMessage, buildToolCallPart, buildExecClientMessages, buildReadRejectionMessages, classifyMissingReadTarget, isUriReadTarget, resolveReadTargetPath, parseExecIdFromToolCallId, detectExecVariantField, buildRequestContextResult, buildMcpStateResult, buildListMcpResourcesFallback, buildReadMcpResourceFallback, buildCustomWebToolAliases, extractHostSubagentCatalog, resolveCustomWebToolAlias, remapNativeSubagentForCatalog, remapCorrelatedEditWriteForCatalog, remapEditToolsForCatalog, buildCompleteEditReadMessages, rejectPartialReadMutation, binaryWritePayload, CUSTOM_WEBFETCH_TOOL, CUSTOM_WEBSEARCH_TOOL, CUSTOM_LIST_MCP_RESOURCES_TOOL, CUSTOM_READ_MCP_RESOURCE_TOOL, } from "./protocol/tools.js";
-import { describeCursorExecVariant } from "./protocol/exec-variants.js";
+import { parseExecServerMessage, buildToolCallPart, buildExecClientMessages, buildReadRejectionMessages, buildUnsupportedExecDeny, classifyMissingReadTarget, isUriReadTarget, resolveReadTargetPath, parseExecIdFromToolCallId, detectExecVariantField, buildRequestContextResult, buildMcpStateResult, buildListMcpResourcesFallback, buildReadMcpResourceFallback, buildCustomWebToolAliases, extractHostSubagentCatalog, resolveCustomWebToolAlias, remapNativeSubagentForCatalog, remapCorrelatedEditWriteForCatalog, remapEditToolsForCatalog, buildCompleteEditReadMessages, rejectPartialReadMutation, binaryWritePayload, CUSTOM_WEBFETCH_TOOL, CUSTOM_WEBSEARCH_TOOL, CUSTOM_LIST_MCP_RESOURCES_TOOL, CUSTOM_READ_MCP_RESOURCE_TOOL, } from "./protocol/tools.js";
+import { buildGitDiffExecMessages } from "./protocol/git-diff.js";
+import { cursorExecVariantByRequestField, describeCursorExecVariant } from "./protocol/exec-variants.js";
+import { appendWorkspaceRootGrounding } from "./protocol/workspace-grounding.js";
+import { progressOnlyContinuationPrompt, shouldContinueProgressOnlyTurn, } from "./protocol/progress-continuation.js";
 import { advertisedToolNamesFromDescriptors, extractExecDisplayCallId, extractProtobufSubmessage, listProtobufFieldNumbers, parseDisplayToolCall, resolveBridgedOpenCodeToolCall, } from "./protocol/tool-call-bridge.js";
 import { handleKvServerMessage } from "./protocol/kv.js";
 import { buildAskQuestionInteractionReply, buildAsyncAskQuestionCompletion, buildCreatePlanInteractionReply, buildSwitchModeInteractionReply, handleInteractionQuery, } from "./protocol/interactions.js";
@@ -39,7 +42,7 @@ 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";
-import { buildLanguageModelV3UsageFromCounters, cursorUsageCountersFromTurnEnded, emptyLanguageModelV3Usage, formatCursorCacheDiagnostics, formatCursorTokenCategories, formatTurnUsageValidation, turnEndedCounter, } from "./usage.js";
+import { buildLanguageModelV3UsageFromCounters, cursorUsageCountersFromTurnEnded, emptyLanguageModelV3Usage, formatCursorCacheDiagnostics, formatCursorTokenCategories, formatTurnUsageValidation, occupancyUsageFromTokenDetails, OPENCODE_DISPLAY_ONLY_COST_METADATA, turnEndedCounter, } from "./usage.js";
 let _availableModels;
 // mtime of the cache file the last time we loaded it. Compared on each call
 // so discoverModels' background refresh is picked up without a process restart.
@@ -578,6 +581,64 @@ export async function pumpWithRecovery(input) {
         }
     }
 }
+const heartbeatWritePendingBySession = new WeakMap();
+const heartbeatGenerationBySession = new WeakMap();
+function bumpHeartbeatGeneration(session) {
+    const generation = (heartbeatGenerationBySession.get(session) ?? 0) + 1;
+    heartbeatGenerationBySession.set(session, generation);
+    heartbeatWritePendingBySession.set(session, false);
+    return generation;
+}
+function isCurrentHeartbeatGeneration(session, generation) {
+    return heartbeatGenerationBySession.get(session) === generation;
+}
+/** Start (or replace) the per-session heartbeat. In-flight writes from a prior attach are ignored. */
+export function attachSessionHeartbeat(session) {
+    session.heartbeatCancel?.();
+    if (session.heartbeat) {
+        clearInterval(session.heartbeat);
+        session.heartbeat = null;
+    }
+    const generation = bumpHeartbeatGeneration(session);
+    const interval = setInterval(() => {
+        if (session.closed || !isCurrentHeartbeatGeneration(session, generation))
+            return;
+        if (heartbeatWritePendingBySession.get(session)) {
+            trace(`heartbeat skipped: prior heartbeat write is still pending sessionId=${session.sessionId}`);
+            return;
+        }
+        heartbeatWritePendingBySession.set(session, true);
+        const stream = session.stream;
+        void writeWithBackpressure(stream, buildHeartbeat(), "heartbeat")
+            .then(() => {
+            if (!isCurrentHeartbeatGeneration(session, generation) || session.closed)
+                return;
+            sessionManager.recordHeartbeatWrite(session);
+        })
+            .catch((cause) => {
+            if (!isCurrentHeartbeatGeneration(session, generation) || session.closed)
+                return;
+            sessionManager.close(session, "heartbeat-write-failed", toCursorProviderError(cause, {
+                replaySafe: false,
+                fallback: "Cursor heartbeat write failed",
+            }));
+        })
+            .finally(() => {
+            if (isCurrentHeartbeatGeneration(session, generation)) {
+                heartbeatWritePendingBySession.set(session, false);
+            }
+        });
+    }, session.policy.heartbeatMs);
+    interval.unref?.();
+    session.heartbeat = interval;
+    session.heartbeatCancel = () => {
+        if (session.heartbeat)
+            clearInterval(session.heartbeat);
+        session.heartbeat = null;
+        if (isCurrentHeartbeatGeneration(session, generation))
+            bumpHeartbeatGeneration(session);
+    };
+}
 async function startSession(modelId, token, callOptions, options, startOptions) {
     const continuationPolicy = resolveContinuationPolicy(options.continuation);
     const prompt = callOptions.prompt;
@@ -941,32 +1002,61 @@ async function startSession(modelId, token, callOptions, options, startOptions)
         closed: false,
     };
     sessionManager.registerSession(session);
-    let heartbeatWritePending = false;
-    session.heartbeat = setInterval(() => {
-        if (session.closed)
-            return;
-        if (heartbeatWritePending) {
-            // The pending write has its own bounded drain wait and will close the
-            // session with the actual failing operation. Do not race it with another
-            // heartbeat or misattribute an existing KV backlog to the heartbeat.
-            trace(`heartbeat skipped: prior heartbeat write is still pending sessionId=${session.sessionId}`);
+    attachSessionHeartbeat(session);
+    const abortIfNeeded = (stream) => {
+        if (!session.closed && !callOptions.abortSignal?.aborted)
             return;
+        try {
+            stream?.destroy();
         }
-        heartbeatWritePending = true;
-        void writeWithBackpressure(stream, buildHeartbeat(), "heartbeat")
-            .then(() => sessionManager.recordHeartbeatWrite(session))
-            .catch((cause) => {
-            sessionManager.close(session, "heartbeat-write-failed", toCursorProviderError(cause, {
-                replaySafe: false,
-                fallback: "Cursor heartbeat write failed",
-            }));
-        })
-            .finally(() => { heartbeatWritePending = false; });
-    }, continuationPolicy.heartbeatMs);
-    session.heartbeat.unref?.();
-    session.heartbeatCancel = () => {
-        if (session.heartbeat)
-            clearInterval(session.heartbeat);
+        catch { /* already closed */ }
+        if (callOptions.abortSignal?.aborted) {
+            throw new CursorLocalCancellationError("Cursor progress-only continuation cancelled");
+        }
+        throw new CursorProtocolError("Cannot reopen a closed Cursor session");
+    };
+    session.reopenWithUserMessage = async (text) => {
+        abortIfNeeded();
+        const { resolveBearerToken } = await import("./auth.js");
+        const freshToken = await resolveBearerToken({
+            accessToken: options.accessToken,
+            apiKey: options.apiKey,
+            baseUrl: resolveApiBaseURL(options),
+        });
+        abortIfNeeded();
+        // Do not pass OpenCode's abortSignal into the h2 stream: a tool-calls abort
+        // must not tear down a Run we still need to pump. Check abort around open.
+        const next = await bidiRunStream(freshToken, { baseURL: agentBaseUrl, headers: options.headers });
+        abortIfNeeded(next);
+        const conversationState = session.resumeCheckpoint ?? getCheckpoint(session.conversationId);
+        const reqBytes = buildRunRequest({
+            text,
+            modelId: cursorModelId,
+            conversationId: session.conversationId,
+            conversationGroupId: session.cacheDiagnostics?.conversationGroupId ?? session.conversationId,
+            conversationState,
+            parameterValues,
+            maxMode,
+            toolDescriptors: session.toolDescriptors,
+            requestContext: session.requestContext,
+            action: "user",
+        });
+        try {
+            await writeWithBackpressure(next, reqBytes, "progress-only continuation Run");
+        }
+        catch (error) {
+            try {
+                next.destroy();
+            }
+            catch { }
+            throw error;
+        }
+        abortIfNeeded(next);
+        session.heartbeatCancel?.();
+        await waitForStreamWrites(session.stream);
+        abortIfNeeded(next);
+        sessionManager.replaceStream(session, next);
+        attachSessionHeartbeat(session);
     };
     callOptions.abortSignal?.addEventListener("abort", () => {
         // Abort after tool-calls is normal — preserve pending sessions.
@@ -1172,6 +1262,7 @@ export function deliverContinuationResults(session, trailingToolResults) {
         else if (!pending.bridged) {
             try {
                 const shellResult = pending.resultField === "shell_stream"
+                    || pending.resultField === "shell_result"
                     || pending.resultField === "background_shell_spawn_result"
                     ? consumeCursorShellResult(r.toolCallId, r.output)
                     : undefined;
@@ -1329,6 +1420,11 @@ function isTruthyEnv(value) {
     return value === "1" || value === "true";
 }
 const streamWriteChains = new WeakMap();
+async function waitForStreamWrites(stream) {
+    const pending = streamWriteChains.get(stream);
+    if (pending)
+        await pending.catch(() => undefined);
+}
 /**
  * Keep awaited protocol writes ordered per Run stream. In particular, a large
  * KV get_blob reply must drain before another KV reply or heartbeat is queued;
@@ -1439,6 +1535,9 @@ export async function pump(session, controller, ids, abortSignal) {
     const advertisedToolNameSet = new Set(advertisedToolNames.map((name) => resolveCustomWebToolAlias(name, session.toolAliases)));
     let textStarted = false;
     let reasoningStarted = false;
+    let assistantText = "";
+    let progressContinuationAttempts = 0;
+    let emittedHostTools = 0;
     const replaySafety = new AttemptReplaySafety(session.sessionId);
     const failRunProtocol = (message, code) => {
         replaySafety.markBarrier("unknown-or-malformed-frame");
@@ -1450,6 +1549,22 @@ export async function pump(session, controller, ids, abortSignal) {
         if (error instanceof CursorProviderError && error.origin !== "protocol")
             throw error;
     };
+    const writeExecFrames = async (frames, operation) => {
+        try {
+            for (const frame of frames) {
+                await writeWithBackpressure(session.stream, frame, operation);
+            }
+            return true;
+        }
+        catch (error) {
+            rethrowTransportWriteFailure(error);
+            const wrapped = new Error(`Failed to ${operation}: ${error.message}`);
+            trace(`exec: reply FAILED ${wrapped.message}`);
+            safeError(wrapped);
+            sessionManager.close(session);
+            return false;
+        }
+    };
     // OpenCode cancels the ReadableStream between turns (see the cancel handler
     // in doStreamImpl). The frames iterator can still yield a final `done` after
     // the cancel lands — controller.enqueue on a cancelled controller throws.
@@ -1480,29 +1595,20 @@ export async function pump(session, controller, ids, abortSignal) {
         streamClosed = true;
     };
     /** Reply on Cursor's correlated exec channel without exposing a host tool call. */
-    const rejectExec = (parsed, reason, label) => {
-        try {
-            for (const frame of buildExecClientMessages({
-                execId: parsed.id,
-                resultField: parsed.resultField,
-                output: "",
-                error: reason,
-                toolName: parsed.toolName,
-                resultMetadata: parsed.resultMetadata,
-                workspaceRoot: workspaceRootFromRequestContext(session.requestContext),
-            })) {
-                session.stream.write(frame);
-            }
+    const rejectExec = async (parsed, reason, label) => {
+        const groundedReason = appendWorkspaceRootGrounding(reason, workspaceRootFromRequestContext(session.requestContext));
+        const ok = await writeExecFrames(buildExecClientMessages({
+            execId: parsed.id,
+            resultField: parsed.resultField,
+            output: "",
+            error: groundedReason,
+            toolName: parsed.toolName,
+            resultMetadata: parsed.resultMetadata,
+            workspaceRoot: workspaceRootFromRequestContext(session.requestContext),
+        }), `reject ${label} id=${parsed.id}`);
+        if (ok)
             trace(`exec: REFUSED ${label} toolName=${parsed.toolName} id=${parsed.id}`);
-            return true;
-        }
-        catch (e) {
-            const error = new Error(`Failed to reject Cursor tool request (${label}): ${e.message}`);
-            trace(`exec: REFUSED reply FAILED ${error.message}`);
-            safeError(error);
-            sessionManager.close(session);
-            return false;
-        }
+        return ok;
     };
     /**
      * Cursor's streamed edit handshake needs the complete target before it sends
@@ -1668,6 +1774,7 @@ export async function pump(session, controller, ids, abortSignal) {
     const emitText = (text) => {
         if (!text)
             return;
+        assistantText += text;
         replaySafety.markBarrier("visible-text");
         // Close reasoning before text (hosts expect reasoning-end before text-start).
         if (reasoningStarted && !textStarted) {
@@ -1695,13 +1802,13 @@ export async function pump(session, controller, ids, abortSignal) {
     const emitFinish = (te, reason, settledUsage, settledSource) => {
         closeOpenSpans();
         const est = session.usageEstimate;
-        // OpenCode persists and sums every AI SDK finish. Cursor does not expose a
-        // final context total at tool boundaries, so charging the growing estimate
-        // there multiplies one held Run across all of its steps. Emit zero at
-        // intermediate boundaries, then prefer checkpoint tokenDetails exactly once
-        // when TurnEnded closes the held Run. Cursor CLI keeps context occupancy in
-        // agentStore tokenDetails; it does not reinterpret TurnEnded as occupancy.
-        const tokenDetails = te ? session.tokenDetails : undefined;
+        // OpenCode TUI/GUI replace each assistant message's tokens (they do not
+        // sum occupancy) and the TUI footer requires tokens.output > 0. Cost is
+        // added per step-finish. Emit checkpoint occupancy snapshots at tool-call
+        // boundaries with a $0 Copilot cost override, then the billed TurnEnded
+        // snapshot once at stop. Char/4 usageEstimate stays traces-only.
+        const tokenDetails = session.tokenDetails;
+        const occupancyDetails = !te && tokenDetails && tokenDetails.usedTokens > 0 ? tokenDetails : undefined;
         const contextSource = tokenDetails
             ? session.tokenDetailsFresh
                 ? "checkpoint-current-run"
@@ -1715,15 +1822,29 @@ export async function pump(session, controller, ids, abortSignal) {
                     priorContextTokens: session.cacheDiagnostics?.priorTokenDetails?.usedTokens,
                 })
                 : emptyLanguageModelV3Usage()
-            : emptyLanguageModelV3Usage());
+            : occupancyDetails
+                ? occupancyUsageFromTokenDetails(occupancyDetails, session.cacheDiagnostics?.priorTokenDetails)
+                : emptyLanguageModelV3Usage());
         const providerMetadata = te
             ? cursorTurnEndedProviderMetadata(te, tokenDetails, contextSource)
-            : undefined;
+            : occupancyDetails && contextSource
+                ? {
+                    ...OPENCODE_DISPLAY_ONLY_COST_METADATA,
+                    cursor: {
+                        usageVersion: 3,
+                        occupancyOnly: true,
+                        context: cursorContextUsageMetadata(occupancyDetails, contextSource),
+                    },
+                }
+                : undefined;
         const reasonLabel = typeof reason === "object" && reason && "unified" in reason
             ? String(reason.unified ?? "unknown")
             : String(reason);
         const inTotal = usage.inputTokens?.total ?? 0;
         const outTotal = usage.outputTokens?.total ?? 0;
+        const occupancySource = occupancyDetails
+            ? `occupancy-${contextSource ?? "unavailable"}`
+            : "intermediate-zero";
         trace(`finish: reason=${reasonLabel} ` +
             `v3In=${inTotal} v3Out=${outTotal} ` +
             `v3CacheRead=${usage.inputTokens?.cacheRead ?? 0} v3CacheWrite=${usage.inputTokens?.cacheWrite ?? 0} ` +
@@ -1734,11 +1855,20 @@ export async function pump(session, controller, ids, abortSignal) {
             `rawCacheWrite=${te ? turnEndedCounter(te, "cache_write") : est.cacheWrite} ` +
             `source=${te
                 ? settledSource ?? (contextSource ?? "unavailable")
-                : "intermediate-zero"}`);
+                : occupancySource}`);
         if (counters) {
             trace(formatTurnUsageValidation(counters, usage, tokenDetails, contextSource));
             trace(formatCursorCacheDiagnostics(counters, tokenDetails, cacheDiagnostics.priorTokenDetails, cacheDiagnostics));
         }
+        else if (occupancyDetails) {
+            trace(formatTurnUsageValidation({
+                inputTokens: occupancyDetails.usedTokens,
+                outputTokens: 1,
+                cacheRead: session.cacheDiagnostics?.priorTokenDetails?.usedTokens ?? 0,
+                cacheWrite: 0,
+                reasoningTokens: 0,
+            }, usage, occupancyDetails, contextSource));
+        }
         safeEnqueue({
             type: "finish",
             usage,
@@ -1906,6 +2036,31 @@ export async function pump(session, controller, ids, abortSignal) {
                             `sessionKey=${session.openCodeSessionId}: ${String(error)}`);
                     });
                 }
+                const checkpoint = session.resumeCheckpoint ?? getCheckpoint(session.conversationId);
+                if (typeof session.reopenWithUserMessage === "function"
+                    && checkpoint
+                    && checkpoint.length > 0
+                    && shouldContinueProgressOnlyTurn({
+                        allowTools: session.allowTools,
+                        advertisedToolCount: advertisedToolNames.length,
+                        assistantText,
+                        emittedHostTools,
+                        continuationAttempts: progressContinuationAttempts,
+                        pendingExecs: session.pending.size,
+                    })) {
+                    progressContinuationAttempts += 1;
+                    trace("progress-only: continuing attempt=1");
+                    try {
+                        await session.reopenWithUserMessage(progressOnlyContinuationPrompt(workspaceRootFromRequestContext(session.requestContext)));
+                        assistantText = "";
+                        continue;
+                    }
+                    catch (error) {
+                        // Cursor already completed this turn. A failed nudge must not discard
+                        // the valid turn_ended the user already received as assistant text.
+                        trace(`progress-only: continuation failed, finishing original turn: ${error.message}`);
+                    }
+                }
                 emitFinish(turnEnded, { unified: "stop", raw: undefined });
                 sessionManager.close(session);
                 return;
@@ -1985,6 +2140,7 @@ export async function pump(session, controller, ids, abortSignal) {
                             const input = JSON.stringify(bridged.args ?? {});
                             trace(`display BRIDGED tool-call toolCallId=${toolCallId} toolName=${bridged.toolName} ` +
                                 `variant=${bridged.variant} callId=${callId} inputLen=${input.length}`);
+                            emittedHostTools++;
                             closeOpenSpans();
                             safeEnqueue({
                                 type: "tool-call",
@@ -2075,6 +2231,24 @@ export async function pump(session, controller, ids, abortSignal) {
                         failRunProtocol("Cursor read_mcp_resource reply failed", RUN_REPLY_FAILED);
                     }
                 }
+                else if (esm.git_diff_request) {
+                    const request = (esm.git_diff_request ?? {});
+                    try {
+                        const frames = await buildGitDiffExecMessages({
+                            execId: esmId,
+                            request,
+                            workspaceRoot: workspaceRootFromRequestContext(session.requestContext),
+                        });
+                        for (const frame of frames) {
+                            await writeWithBackpressure(session.stream, frame, `git_diff reply id=${esmId}`);
+                        }
+                        trace(`exec git_diff: replied id=${esmId}`);
+                    }
+                    catch (error) {
+                        rethrowTransportWriteFailure(error);
+                        failRunProtocol("Cursor git_diff reply failed", RUN_REPLY_FAILED);
+                    }
+                }
                 else {
                     replaySafety.markBarrier("non-control-exec");
                     const displayCallId = extractExecDisplayCallId(esm);
@@ -2112,7 +2286,7 @@ export async function pump(session, controller, ids, abortSignal) {
                     trace(`exec: id=${parsed?.id} variant=${parsed ? Object.keys(parsed).join(",") : "none"} toolName=${parsed?.toolName} resultField=${parsed?.resultField}`);
                     if (parsed) {
                         if (parsed.localError) {
-                            if (!rejectExec(parsed, parsed.localError, "invalid mapping"))
+                            if (!await rejectExec(parsed, parsed.localError, "invalid mapping"))
                                 return;
                             continue;
                         }
@@ -2122,7 +2296,7 @@ export async function pump(session, controller, ids, abortSignal) {
                         // pumping for text / turn_ended instead of emitting tool-call.
                         if (!session.allowTools) {
                             const reason = "Tool calls are not available during this turn (summary/compaction).";
-                            if (!rejectExec(parsed, reason, "allowTools=false"))
+                            if (!await rejectExec(parsed, reason, "allowTools=false"))
                                 return;
                             continue;
                         }
@@ -2136,7 +2310,7 @@ export async function pump(session, controller, ids, abortSignal) {
                             if (!advertisedToolNameSet.has(CURSOR_IMAGE_SAVE_TOOL)) {
                                 const reason = "This OpenCode agent cannot write binary file content. "
                                     + "Do not retry this write with the same bytes.";
-                                if (!rejectExec(parsed, reason, "binary write unsupported"))
+                                if (!await rejectExec(parsed, reason, "binary write unsupported"))
                                     return;
                                 continue;
                             }
@@ -2157,7 +2331,7 @@ export async function pump(session, controller, ids, abortSignal) {
                                 });
                             }
                             catch (error) {
-                                if (!rejectExec(parsed, error.message, "binary write too large"))
+                                if (!await rejectExec(parsed, error.message, "binary write too large"))
                                     return;
                                 continue;
                             }
@@ -2173,6 +2347,7 @@ export async function pump(session, controller, ids, abortSignal) {
                             trace(`exec: binary write STAGED toolCallId=${toolCallId} ` +
                                 `requested=${JSON.stringify(binaryWrite.path)} target=${JSON.stringify(target)} ` +
                                 `bytes=${binaryWrite.data.length}`);
+                            emittedHostTools++;
                             closeOpenSpans();
                             safeEnqueue({
                                 type: "tool-call",
@@ -2198,7 +2373,7 @@ export async function pump(session, controller, ids, abortSignal) {
                                 `'${parsed.toolName}'.`;
                             trace(`exec: unavailable catalog target toolName=${parsed.toolName} ` +
                                 `advertised=[${advertisedToolNames.join(",")}]`);
-                            if (!rejectExec(parsed, reason, "unavailable tool"))
+                            if (!await rejectExec(parsed, reason, "unavailable tool"))
                                 return;
                             continue;
                         }
@@ -2215,6 +2390,7 @@ export async function pump(session, controller, ids, abortSignal) {
                         }
                         const tc = buildToolCallPart(parsed, session.sessionId);
                         if (parsed.resultField === "shell_stream"
+                            || parsed.resultField === "shell_result"
                             || parsed.resultField === "background_shell_spawn_result") {
                             registerCursorShellCall(tc.toolCallId, parsed.resultMetadata);
                         }
@@ -2222,6 +2398,7 @@ export async function pump(session, controller, ids, abortSignal) {
                         sessionManager.registerPending(parsed.id, session, parsed.resultField, parsed.toolName, false, parsed.resultMetadata);
                         // tc.input is already a JSON string (LanguageModelV3ToolCall.input).
                         trace(`exec: EMITTED tool-call toolCallId=${tc.toolCallId} toolName=${tc.toolName} inputLen=${tc.input.length}`);
+                        emittedHostTools++;
                         // Close open text/reasoning spans before tool-call (required by AI SDK V3).
                         closeOpenSpans();
                         safeEnqueue({
@@ -2233,11 +2410,36 @@ export async function pump(session, controller, ids, abortSignal) {
                         emitFinish(undefined, { unified: "tool-calls", raw: undefined });
                         return;
                     }
+                    // Known Cursor-native exec variants with no safe OpenCode bridge are
+                    // soft-denied with a populated typed result or throw, so the turn
+                    // continues with remaining tools. Unknown fields still hard-fail.
+                    const variantField = detectExecVariantField(payload);
+                    const variant = variantField !== undefined
+                        ? cursorExecVariantByRequestField(variantField)
+                        : undefined;
+                    if (variant?.handling === "unsupported") {
+                        const advertised = advertisedToolNames.length > 0 ? advertisedToolNames.join(", ") : "none";
+                        const rawReason = `Cursor-native '${variant.requestName}' is not available on this host. Continue with listed tools: ${advertised}; do not retry '${variant.requestName}'.`;
+                        const grounded = appendWorkspaceRootGrounding(rawReason, workspaceRootFromRequestContext(session.requestContext));
+                        // Allowlist/status denies have no string channel; buildUnsupportedExecDeny
+                        // ignores `reason` for those shapes and still selects the typed oneof.
+                        const frames = buildUnsupportedExecDeny({ execId: esmId, variant, reason: grounded });
+                        try {
+                            for (const frame of frames) {
+                                await writeWithBackpressure(session.stream, frame, `unsupported deny ${variant.requestName} id=${esmId}`);
+                            }
+                        }
+                        catch (error) {
+                            rethrowTransportWriteFailure(error);
+                            failRunProtocol("Cursor unsupported exec deny reply failed", RUN_REPLY_FAILED);
+                        }
+                        trace(`exec: SOFT-DENIED ${variant.requestName} id=${esmId}`);
+                        continue;
+                    }
                     // Never guess a response type for an unknown exec variant. Request and
                     // result field numbers are not universally identical; a structurally
                     // wrong reply recreates the heartbeat-only deadlock. Fail promptly so
                     // schema drift is actionable.
-                    const variantField = detectExecVariantField(payload);
                     const variantDescription = describeCursorExecVariant(variantField);
                     const hex = Array.from(payload.subarray(0, 48))
                         .map((x) => x.toString(16).padStart(2, "0"))
@@ -2313,6 +2515,7 @@ export async function pump(session, controller, ids, abortSignal) {
                     trace(`interaction_query: BRIDGED ask_question id=${handled.id} toolCallId=${toolCallId} ` +
                         `questions=${ask.args.questions.length} runAsync=${ask.args.runAsync} ` +
                         `cursorToolCallId=${ask.toolCallId || "(none)"}`);
+                    emittedHostTools++;
                     closeOpenSpans();
                     safeEnqueue({
                         type: "tool-call",
@@ -2359,6 +2562,7 @@ export async function pump(session, controller, ids, abortSignal) {
                         `bridge=${bridgeKind} hostTool=${toolName} ` +
                         `target=${JSON.stringify(sw.args.targetModeId)} ` +
                         `cursorToolCallId=${sw.toolCallId || "(none)"}`);
+                    emittedHostTools++;
                     closeOpenSpans();
                     safeEnqueue({
                         type: "tool-call",
@@ -2400,6 +2604,7 @@ export async function pump(session, controller, ids, abortSignal) {
                     // before asking — approving a plan you cannot read is not approval.
                     if (plan.planReview)
                         emitText(plan.planReview);
+                    emittedHostTools++;
                     closeOpenSpans();
                     safeEnqueue({
                         type: "tool-call",
@@ -2630,6 +2835,9 @@ export function buildOpenCodeInteractionGuidance(tools, isCompaction, workspaceR
             : []),
         ...instructions,
         "Emit the actual tool call and wait for its result; never merely claim or summarize that a tool was used.",
+        "A progress update such as \"Checking…\", \"Inspecting…\", or \"Let me look…\" is not a final answer.",
+        "After progress narration, call a listed tool in the same turn; if no tool is needed, provide the complete user-facing answer before finishing.",
+        "Never end a turn with progress narration alone.",
     ].join("\n");
 }
 /** Rough char→token estimate for mid-turn usage before TurnEnded arrives. */

package/dist/model-config.d.ts

@@ -1,4 +1,4 @@
-import { type ModelInfo } from "./models.js";
+import { type ModelInfo, type ModelVariant } from "./models.js";
 /**
  * Display names shared by both a thinking and a non-thinking model. A thinking
  * model with such a name needs a "Thinking" tag to disambiguate it from its
@@ -11,5 +11,7 @@ export declare function thinkingSuffixBaseNames(models: ModelInfo[]): Set<string
 export declare function modelInfoToConfig(mi: ModelInfo, options?: {
     thinkingSuffix?: boolean;
     contextTier?: "base" | "long";
+    variants?: ModelVariant[];
+    fast?: boolean;
 }): Record<string, any>;
 export declare function modelsToConfig(models: ModelInfo[]): Record<string, any>;