cursor-opencode-provider 0.6.8 → 0.7.0

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, encodeMessage } from "./protocol/messages.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 { parseExecServerMessage, buildToolCallPart, buildExecClientMessages, buildReadRejectionMessages, buildUnsupportedExecDeny, classifyMissingReadTarget, isUriReadTarget, resolveReadTargetPath, parseExecIdFromToolCallId, detectExecVariantField, buildRequestContextResult, buildMcpStateResult, buildListMcpResourcesFallback, buildReadMcpResourceFallback, buildCustomWebToolAliases, extractHostSubagentCatalog, resolveCustomWebToolAlias, remapNativeSubagentForCatalog, preferCorrelatedTaskDescription, remapCorrelatedEditWriteForCatalog, remapEditToolsForCatalog, buildCompleteEditReadMessages, rejectPartialReadMutation, binaryWritePayload, CUSTOM_WEBFETCH_TOOL, CUSTOM_WEBSEARCH_TOOL, CUSTOM_LIST_MCP_RESOURCES_TOOL, CUSTOM_READ_MCP_RESOURCE_TOOL, hostToolDialectFromTools, opencodePathArg, } 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";
@@ -18,6 +18,7 @@ import { ASK_QUESTION_RESULT_FIELD, askQuestionResultFromToolOutput, askQuestion
 import { SWITCH_MODE_RESULT_FIELD, getActiveCursorMode, isBridgedCursorPlanModeActive, isCursorPlanModeActive, setActiveCursorMode, switchModeResultFromQuestionOutput, switchModeResultFromToolOutput, switchModeToolInput, takeActiveCursorModeReminder, } from "./protocol/switch-mode.js";
 import { CREATE_PLAN_NOT_APPROVED_REASON, CREATE_PLAN_RESULT_FIELD, CURSOR_PLAN_STAGE_TOOL, createPlanApproved, createPlanStageInput, } from "./protocol/create-plan.js";
 import { flushPlanExecutionKickoff, formatPlanKickoffPath, hasPlanExecutionKickoff, planExecutionKickoffState, planPathFromUri, queuePlanExecutionKickoff, takePlanExecutionKickoffWarning, } from "./plan-execution-kickoff.js";
+import { flushHostAgentModeSwitch, queueHostAgentModeSwitch, } from "./host-agent-mode.js";
 import { CURSOR_IMAGE_SAVE_TOOL, imageMimeForPath, remapCursorImageWritePath, } from "./protocol/generate-image.js";
 import { stageCursorImage } from "./image-staging.js";
 import { IMAGE_PERMISSION_DENIED_PREFIX } from "./image-save.js";
@@ -34,7 +35,7 @@ import { getOrBuildRequestContext } from "./context/frozen.js";
 import { workspaceRootFromRequestContext } from "./context/env.js";
 import { ensureOpencodeProjectDir, opencodeGlobalCacheDir, setHostCacheDirOverride, } from "./context/paths.js";
 import { resolveAgentUrl } from "./agent-url.js";
-import { CURSOR_API_HOST, CURSOR_COMPACTION_OPTION } from "./shared.js";
+import { CURSOR_API_HOST, CURSOR_COMPACTION_OPTION, CURSOR_HOST_AGENT_OPTION, } from "./shared.js";
 import { isCompactionSession } from "./compaction-marker.js";
 import { getSessionDirectory } from "./session-directory.js";
 import { assertCursorUserImageSupport, extractCursorPromptImages } from "./image-input.js";
@@ -57,6 +58,7 @@ const sentHistoryImageHashesBySession = new Map();
 // 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();
+const promptIdentityBySession = new Map();
 export const MAX_TURN_STATE_SESSIONS = 256;
 const MAX_SENT_HISTORY_IMAGES_PER_SESSION = 256;
 const DEFAULT_RETRY_POLICY = {
@@ -373,6 +375,35 @@ function rememberPostCompactionRebase(sessionKey) {
         postCompactionRebaseBySession.delete(oldest);
     }
 }
+function normalizePromptIdentity(value) {
+    const hostAgent = value.hostAgent?.trim();
+    const systemPromptHash = value.systemPromptHash?.trim();
+    return {
+        ...(hostAgent ? { hostAgent } : {}),
+        ...(systemPromptHash ? { systemPromptHash } : {}),
+    };
+}
+function rememberPromptIdentity(sessionKey, value) {
+    const normalized = normalizePromptIdentity(value);
+    if (!normalized.hostAgent && !normalized.systemPromptHash)
+        return;
+    promptIdentityBySession.delete(sessionKey);
+    promptIdentityBySession.set(sessionKey, normalized);
+    while (promptIdentityBySession.size > MAX_TURN_STATE_SESSIONS) {
+        const oldest = promptIdentityBySession.keys().next().value;
+        if (!oldest)
+            break;
+        promptIdentityBySession.delete(oldest);
+    }
+}
+function promptIdentityChanged(previous, current) {
+    // Compare only facts the current host supplied. This keeps standalone calls
+    // and older compatibility surfaces from invalidating a valid checkpoint just
+    // because they cannot expose an agent id.
+    return ((current.hostAgent !== undefined && previous.hostAgent !== current.hostAgent)
+        || (current.systemPromptHash !== undefined
+            && previous.systemPromptHash !== current.systemPromptHash));
+}
 function sentHistoryImageHashes(sessionKey) {
     if (!sessionKey)
         return undefined;
@@ -538,6 +569,12 @@ async function doStreamImpl(modelId, options, callOptions) {
                             setActiveCursorMode(activeSession.openCodeSessionId, "plan");
                         }
                     }
+                    await flushHostAgentModeSwitch(activeSession.openCodeSessionId, {
+                        cursorSessionID: activeSession.sessionId,
+                        terminal: activeSession.closed,
+                        pumpActive: activeSession.pumpActive || activeSession.pumpOwner != null,
+                        pendingExecs: activeSession.pending.size,
+                    });
                 }
                 catch (e) {
                     activeSession.pumpActive = false;
@@ -693,13 +730,25 @@ async function startSession(modelId, token, callOptions, options, startOptions)
             rememberPostCompactionRebase(sessionKey);
         if (restored?.toolCatalog.length)
             restoreTurnToolCatalog(sessionKey, restored.toolCatalog);
+        if (restored?.hostAgent || restored?.systemPromptHash) {
+            rememberPromptIdentity(sessionKey, {
+                ...(restored.hostAgent ? { hostAgent: restored.hostAgent } : {}),
+                ...(restored.systemPromptHash ? { systemPromptHash: restored.systemPromptHash } : {}),
+            });
+        }
     }
     const providerOptions = callOptions.providerOptions?.cursor;
+    const hostAgent = typeof providerOptions?.[CURSOR_HOST_AGENT_OPTION] === "string"
+        ? String(providerOptions[CURSOR_HOST_AGENT_OPTION]).trim() || undefined
+        : undefined;
     // The classic plugin marks OpenCode's agent="compaction" through chat.params.
-    // OpenCode 2.0 removed that hook, so its plugin records the same fact against
-    // the session id from session.hook("context") instead; consult both.
+    // OpenCode 2.0 removed that hook, so its plugin writes the same request-local
+    // option from session hooks. The session marker is a fallback only when a
+    // host does not preserve mutable options; explicit false prevents concurrent
+    // title/generate calls from inheriting a compaction marker.
     // Do not infer this from tools/toolChoice: standalone no-tool calls are valid.
-    const isCompaction = providerOptions?.[CURSOR_COMPACTION_OPTION] === true || isCompactionSession(sessionKey);
+    const compactionOption = providerOptions?.[CURSOR_COMPACTION_OPTION];
+    const isCompaction = compactionOption === true || (compactionOption === undefined && isCompactionSession(sessionKey));
     const toolState = await resolveTurnToolState({
         sessionKey,
         incomingTools,
@@ -718,14 +767,31 @@ async function startSession(modelId, token, callOptions, options, startOptions)
     }
     const allowTools = toolState.allowTools;
     const discoveredSubagentCatalog = extractHostSubagentCatalog(cursorTools);
-    const resetState = resolveTurnConversationReset({ sessionKey, isCompaction });
     let recovery = startOptions?.recovery;
     let resumeRecovery = recovery?.kind === "resume" ? recovery : undefined;
     let resuming = !!resumeRecovery;
+    const lifecycle = !allowTools && !isCompaction && !recovery;
+    // 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 option is only a fallback for the directory recorded
+    // from `session.hook("context")`.
+    const workspaceRoot = path.resolve(getSessionDirectory(sessionKey) ?? (options.workspaceRoot || process.cwd()));
+    const baseSystemPrompt = extractSystemPrompt(prompt);
+    const interactionGuidance = buildOpenCodeInteractionGuidance(cursorTools, isCompaction, workspaceRoot);
+    const stableSystemPrompt = [baseSystemPrompt, interactionGuidance].filter(Boolean).join("\n\n");
+    const stableSystemPromptHash = stableSystemPrompt
+        ? createHash("sha256").update(stableSystemPrompt).digest("hex")
+        : undefined;
+    const resetState = resolveTurnConversationReset({
+        sessionKey,
+        isCompaction,
+        ...(lifecycle
+            ? {}
+            : { promptIdentity: { hostAgent, systemPromptHash: stableSystemPromptHash } }),
+    });
     // Compaction must not reuse the prior conversation; its first normal turn
     // must also rebase so the summary-agent checkpoint cannot replace the normal
     // system prompt and OpenCode's newly compacted history.
-    const lifecycle = !allowTools && !isCompaction && !recovery;
     let bound = resuming
         ? { conversationId: resumeRecovery.conversationId, reset: false, previousId: undefined }
         : bindConversationId(sessionKey, {
@@ -781,18 +847,13 @@ async function startSession(modelId, token, callOptions, options, startOptions)
     const userText = recovery?.kind === "rebase"
         ? "Continue the interrupted turn from the conversation history above. Do not repeat completed work."
         : (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
-    // fallback; `getSessionDirectory` carries the real per-session directory
-    // recorded from `session.hook("context")` in `plugin-opencode2.ts`.
-    const workspaceRoot = path.resolve(getSessionDirectory(sessionKey) ?? (options.workspaceRoot || process.cwd()));
-    const baseSystemPrompt = extractSystemPrompt(prompt);
-    const interactionGuidance = buildOpenCodeInteractionGuidance(cursorTools, isCompaction, workspaceRoot);
     // After an approved SwitchMode, inject the Cursor CLI-shaped mode reminder
     // (same <system_reminder> contract the CLI uses after flipping unifiedMode).
     const startedWithCheckpoint = !!conversationState;
-    const modeReminder = isCompaction || startedWithCheckpoint || lifecycle
+    const activeMode = getActiveCursorMode(sessionKey);
+    const nativePlanPromptOwnsMode = hostAgent === "plan"
+        && (activeMode === "plan" || activeMode === "spec");
+    const modeReminder = isCompaction || startedWithCheckpoint || lifecycle || nativePlanPromptOwnsMode
         ? undefined
         : takeActiveCursorModeReminder(sessionKey, {
             advertisedTools: cursorTools.map((tool) => tool.name),
@@ -983,6 +1044,9 @@ async function startSession(modelId, token, callOptions, options, startOptions)
         stream.destroy();
         throw error;
     }
+    const hostToolDialect = hostToolDialectFromTools(tools);
+    trace(`host tool dialect: filePathKey=${hostToolDialect.filePathKey} shellTool=${hostToolDialect.shellTool} ` +
+        `tools=[${tools.map((t) => t.name).join(",")}]`);
     const session = {
         sessionId: crypto.randomUUID(),
         conversationId,
@@ -1009,6 +1073,8 @@ async function startSession(modelId, token, callOptions, options, startOptions)
             execRequests: 0,
         },
         openCodeSessionId: lifecycle ? undefined : sessionKey,
+        hostAgent,
+        stableSystemPromptHash,
         postCompactionRebase: isCompaction,
         toolCatalog: snapshotToolCatalog(sessionKey),
         stream,
@@ -1024,6 +1090,7 @@ async function startSession(modelId, token, callOptions, options, startOptions)
         blobs: new Map(),
         toolDescriptors,
         toolAliases: webToolAliases.aliases,
+        hostToolDialect,
         subagentCatalog,
         requestContext,
         allowTools,
@@ -1216,7 +1283,7 @@ function buildCreatePlanContinuationFrame(pending, result, sessionKey, cursorSes
         plan_uri: planUri,
     });
 }
-function buildSwitchModeContinuationFrame(pending, result, sessionKey) {
+function buildSwitchModeContinuationFrame(pending, result) {
     const metadata = pending.resultMetadata ?? {};
     const interactionId = metadata.interactionId;
     if (typeof interactionId !== "number") {
@@ -1228,16 +1295,13 @@ function buildSwitchModeContinuationFrame(pending, result, sessionKey) {
     const answer = metadata.switchModeBridgeKind === "question"
         ? switchModeResultFromQuestionOutput(result.output, result.error !== undefined)
         : switchModeResultFromToolOutput(result.output, result.error !== undefined);
-    if ("approved" in answer) {
-        const target = metadata.switchModeTarget;
-        if (typeof target === "string" && target.trim()) {
-            const normalized = target.trim().toLowerCase();
-            setActiveCursorMode(sessionKey, target, {
-                bridgedPlanEntered: normalized === "plan" || normalized === "spec",
-            });
-        }
-    }
-    return buildSwitchModeInteractionReply(interactionId, answer);
+    const target = "approved" in answer && typeof metadata.switchModeTarget === "string"
+        ? metadata.switchModeTarget.trim()
+        : "";
+    return {
+        frame: buildSwitchModeInteractionReply(interactionId, answer),
+        ...(target ? { approvedTarget: target, bridgeKind: metadata.switchModeBridgeKind } : {}),
+    };
 }
 /**
  * Deliver trailing tool results onto a live continuation session.
@@ -1265,6 +1329,7 @@ export function deliverContinuationResults(session, trailingToolResults) {
         }
         const pending = claim.pending;
         let frames = [];
+        let deliveredSwitchMode;
         if (pending.resultField === ASK_QUESTION_RESULT_FIELD) {
             // A bridged Cursor AskQuestion. The host tool result carries the user's
             // choices; translate them back into the Cursor result the interaction is
@@ -1284,7 +1349,14 @@ export function deliverContinuationResults(session, trailingToolResults) {
             // approved{} or rejected{reason} on the still-open InteractionQuery.
             // Approval also arms the CLI-shaped mode reminder for the next Run.
             try {
-                frames = [buildSwitchModeContinuationFrame(pending, r, session.openCodeSessionId)];
+                const built = buildSwitchModeContinuationFrame(pending, r);
+                frames = [built.frame];
+                if (built.approvedTarget) {
+                    deliveredSwitchMode = {
+                        target: built.approvedTarget,
+                        bridgeKind: built.bridgeKind,
+                    };
+                }
             }
             catch (error) {
                 trace(`continuation: switch_mode encode FAILED execId=${r.execId} err=${error.message}`);
@@ -1405,6 +1477,22 @@ export function deliverContinuationResults(session, trailingToolResults) {
                 continue;
             return undefined;
         }
+        if (deliveredSwitchMode) {
+            const normalized = deliveredSwitchMode.target.toLowerCase();
+            setActiveCursorMode(session.openCodeSessionId, deliveredSwitchMode.target, {
+                bridgedPlanEntered: normalized === "plan" || normalized === "spec",
+            });
+            // A question-emulated exit has no native host plan tool to perform the
+            // actual primary-agent switch. Queue only after Cursor received the
+            // approved response; a failed write must not mutate host mode.
+            if (deliveredSwitchMode.bridgeKind === "question" && session.openCodeSessionId) {
+                queueHostAgentModeSwitch({
+                    sessionID: session.openCodeSessionId,
+                    targetModeID: deliveredSwitchMode.target,
+                    cursorSessionID: session.sessionId,
+                });
+            }
+        }
         // A host `todoread` result is the authoritative list. Refresh the mirrored
         // snapshot (direct reads and bridged native reads alike) so later merges
         // apply onto host truth, not a stale write.
@@ -1686,7 +1774,7 @@ export async function pump(session, controller, ids, abortSignal) {
         const display = parseDisplayToolCall(displayCallId, stored);
         if (display?.variant !== "edit_tool_call" || display.bridgeable === false)
             return false;
-        const requestedPath = typeof parsed.args.filePath === "string" ? parsed.args.filePath : "";
+        const requestedPath = opencodePathArg(parsed.args) ?? "";
         const editPath = typeof display.args.path === "string" ? display.args.path : "";
         if (!requestedPath || !editPath)
             return false;
@@ -1784,7 +1872,7 @@ export async function pump(session, controller, ids, abortSignal) {
     const rejectMissingReadTarget = (parsed) => {
         if (parsed.toolName !== "read")
             return false;
-        const requested = typeof parsed.args.filePath === "string" ? parsed.args.filePath : "";
+        const requested = opencodePathArg(parsed.args) ?? "";
         if (!requested)
             return false;
         // A scheme-addressed target is the advertised host executor's to resolve,
@@ -2084,6 +2172,8 @@ export async function pump(session, controller, ids, abortSignal) {
                         requestContext: session.requestContext,
                         toolCatalog: session.toolCatalog ?? [],
                         postCompactionRebase: session.postCompactionRebase,
+                        hostAgent: session.hostAgent,
+                        systemPromptHash: session.stableSystemPromptHash,
                     }).catch((error) => {
                         trace(`conversation persistence: TurnEnded save failed ` +
                             `sessionKey=${session.openCodeSessionId}: ${String(error)}`);
@@ -2312,7 +2402,7 @@ export async function pump(session, controller, ids, abortSignal) {
                 else {
                     replaySafety.markBarrier("non-control-exec");
                     const displayCallId = extractExecDisplayCallId(esm);
-                    const parsed = parseExecServerMessage(esm);
+                    const parsed = parseExecServerMessage(esm, session.hostToolDialect);
                     if (parsed) {
                         const executableToolName = resolveCustomWebToolAlias(parsed.toolName, session.toolAliases);
                         if (executableToolName !== parsed.toolName) {
@@ -2320,6 +2410,20 @@ export async function pump(session, controller, ids, abortSignal) {
                             parsed.toolName = executableToolName;
                         }
                         remapNativeSubagentForCatalog(parsed, advertisedToolNameSet, session.subagentCatalog);
+                        // SubagentArgs has no description; Cursor's real title lives on the
+                        // correlated display TaskToolCall. Prefer that over the 5-word prompt slice.
+                        if (displayCallId && (parsed.toolName === "task" || parsed.toolName === "subagent")) {
+                            const stored = session.displayToolCalls.get(displayCallId);
+                            const display = parseDisplayToolCall(displayCallId, stored);
+                            if (display?.variant === "task_tool_call") {
+                                const description = typeof display.args.description === "string" ? display.args.description : undefined;
+                                preferCorrelatedTaskDescription(parsed, description);
+                                if (description?.trim()) {
+                                    trace(`exec: preferred TaskToolCall description callId=${displayCallId} ` +
+                                        `description=${JSON.stringify(description.trim())}`);
+                                }
+                            }
+                        }
                         const editCall = displayCallId
                             ? session.editToolCalls?.get(displayCallId)
                             : undefined;
@@ -2605,9 +2709,17 @@ export async function pump(session, controller, ids, abortSignal) {
                     setActiveCursorMode(session.openCodeSessionId, sw.args.targetModeId, {
                         bridgedPlanEntered: false,
                     });
+                    const hostAgentSwitchQueued = session.openCodeSessionId
+                        ? queueHostAgentModeSwitch({
+                            sessionID: session.openCodeSessionId,
+                            targetModeID: sw.args.targetModeId,
+                            cursorSessionID: session.sessionId,
+                        })
+                        : false;
                     trace(`interaction_query: APPROVED switch_mode id=${handled.id} ` +
                         `target=${JSON.stringify(sw.args.targetModeId)} (no host plan tool; ` +
-                        `provider-owned mode) cursorToolCallId=${sw.toolCallId || "(none)"}`);
+                        `${hostAgentSwitchQueued ? "native host-agent switch queued" : "provider-owned fallback"}) ` +
+                        `cursorToolCallId=${sw.toolCallId || "(none)"}`);
                     continue;
                 }
                 if (handled.outcome === "bridged" && handled.switchMode) {
@@ -2875,8 +2987,14 @@ export function buildOpenCodeInteractionGuidance(tools, isCompaction, workspaceR
     if (names.has(CUSTOM_READ_MCP_RESOURCE_TOOL)) {
         instructions.push(`- To read an MCP resource, call \`${CUSTOM_READ_MCP_RESOURCE_TOOL}\`; do not use Cursor's native resource-reading interaction.`);
     }
-    if (names.has("task")) {
-        const target = "`task`";
+    if (names.has("execute")) {
+        const shell = names.has("shell") ? "`shell`" : names.has("bash") ? "`bash`" : undefined;
+        instructions.push(shell
+            ? `- OpenCode \`execute\` is Code Mode JavaScript (\`code\`); it is not a shell. For OS commands, call OpenCode ${shell}. Do not pass \`command\` to \`execute\`.`
+            : "- OpenCode `execute` is Code Mode JavaScript (`code`); it is not a shell. Do not pass `command` to `execute`.");
+    }
+    if (names.has("task") || names.has("subagent")) {
+        const target = names.has("task") ? "`task`" : "`subagent`";
         const available = subagents.agents.map((agent) => `\`${agent.name}\``).join(", ");
         instructions.push(`- Native Cursor Task/subagent requests are executed through OpenCode ${target}. ` +
             "Advertised custom subagent names are used exactly; otherwise `unspecified` and `generalPurpose` select host `general`, " +
@@ -3143,9 +3261,25 @@ export function resolveTurnConversationReset(input) {
             rememberPostCompactionRebase(sessionKey);
         return { reset: true, reason: "compaction" };
     }
+    let promptChange;
+    if (sessionKey && input.promptIdentity) {
+        const current = normalizePromptIdentity(input.promptIdentity);
+        const previous = promptIdentityBySession.get(sessionKey);
+        if (previous && promptIdentityChanged(previous, current)) {
+            promptChange = current.hostAgent !== undefined && previous.hostAgent !== current.hostAgent
+                ? "agent-change"
+                : "system-prompt-change";
+        }
+        rememberPromptIdentity(sessionKey, {
+            ...previous,
+            ...current,
+        });
+    }
     if (sessionKey && postCompactionRebaseBySession.delete(sessionKey)) {
         return { reset: true, reason: "post-compaction-rebase" };
     }
+    if (promptChange)
+        return { reset: true, reason: promptChange };
     return { reset: false };
 }
 export function resetTurnStateForTests() {
@@ -3156,6 +3290,8 @@ export function resetTurnStateForTests() {
     toolCatalogWaitersBySession.clear();
     toolCatalogBySession.clear();
     postCompactionRebaseBySession.clear();
+    promptIdentityBySession.clear();
+    mirroredTodosBySession.clear();
 }
 function extractUserText(lastUser) {
     if (!lastUser)

package/dist/models.d.ts

@@ -84,9 +84,20 @@ export declare function fetchModels(token: string, options?: {
     headers?: Record<string, string>;
     timeoutMs?: number;
 }): Promise<ModelInfo[]>;
-export declare function refreshModelCache(cacheDir: string, fetcher: () => Promise<ModelInfo[]>): Promise<ModelInfo[]>;
+export declare function refreshModelCache(cacheDir: string, fetcher: () => Promise<ModelInfo[]>, options?: {
+    forceAfterInflight?: boolean;
+}): Promise<ModelInfo[]>;
 export declare function discoverModels(token: string, cacheDir: string, options?: {
     baseURL?: string;
     headers?: Record<string, string>;
     timeoutMs?: number;
+    /**
+     * Bypass even a fresh cache and require an authoritative response.
+     *
+     * Model availability is account-scoped. Callers use this after a
+     * credential switch so a fresh cache produced by the previous account is
+     * never rebound to the new connection. A forced refresh rejects on fetch
+     * failure; the caller can keep the already-published inventory unchanged.
+     */
+    forceRefresh?: boolean;
 }): Promise<ModelInfo[]>;

package/dist/models.js

@@ -396,11 +396,18 @@ export async function fetchModels(token, options = {}) {
     return mapAvailableModelsResponse(raw);
 }
 const refreshesByDirectory = new Map();
-export async function refreshModelCache(cacheDir, fetcher) {
+export async function refreshModelCache(cacheDir, fetcher, options = {}) {
     const key = path.resolve(cacheDir);
     const existing = refreshesByDirectory.get(key);
-    if (existing)
-        return existing;
+    if (existing) {
+        if (!options.forceAfterInflight)
+            return existing;
+        // An account switch must not join a background refresh authenticated as
+        // the previous account. Wait for that write to finish, then run this
+        // caller's fetch so its account inventory is authoritative on disk.
+        await existing.catch(() => { });
+        return refreshModelCache(cacheDir, fetcher, options);
+    }
     const refresh = (async () => {
         const models = await fetcher();
         await writeCache(cacheDir, {
@@ -420,10 +427,11 @@ export async function refreshModelCache(cacheDir, fetcher) {
     }
 }
 export async function discoverModels(token, cacheDir, options = {}) {
+    const { forceRefresh = false, ...fetchOptions } = options;
     const cached = await readCache(cacheDir);
-    const refresh = () => refreshModelCache(cacheDir, () => fetchModels(token, options));
+    const refresh = () => refreshModelCache(cacheDir, () => fetchModels(token, fetchOptions), { forceAfterInflight: forceRefresh });
     // Cache is fresh → return it; refresh in background
-    if (cached && isCacheFresh(cached)) {
+    if (!forceRefresh && cached && isCacheFresh(cached)) {
         // Background refresh (fire and forget)
         void refresh()
             .catch(() => {
@@ -436,7 +444,9 @@ export async function discoverModels(token, cacheDir, options = {}) {
         try {
             return await refresh();
         }
-        catch {
+        catch (error) {
+            if (forceRefresh)
+                throw error;
             return cached.models;
         }
     }

package/dist/opencode2/catalog.d.ts

@@ -1,8 +1,9 @@
 import { type ModelInfo } from "../models.js";
-import type { CatalogDraft } from "./types.js";
+import { type OpenCode2ModelCost } from "../pricing.js";
+import type { ConnectionInfo, ModelVariantInfo, ProviderEditor } from "./types.js";
 /**
- * Catalog registration for the OpenCode 2.0 plugin — the replacement for the
- * classic plugin's `config` hook.
+ * In-memory provider registration for the OpenCode 2.0 plugin — the replacement
+ * for the classic plugin's `config` hook.
  *
  * Model naming, thinking suffixes, and long-context tiering are NOT reimplemented
  * here: we run the shared `modelsToConfig` and translate its output into the 2.0
@@ -14,10 +15,10 @@ export declare const CURSOR_INTEGRATION_ID = "cursor";
  * `aisdk:` selects OpenCode 2.0's AI SDK path, which is what surfaces the
  * `aisdk.hook("sdk")` / `("language")` extension points we supply the provider
  * through. The suffix is this package's npm name so the host's built-in
- * `DynamicProviderPlugin` can still resolve it if our own hook is ever
- * bypassed — that fallback runs `npm.add(pkg)` against the *published*
- * registry into `<host-cache>/packages/<pkg>/node_modules/<pkg>`, ignoring
- * any local `file://` plugin path this process was loaded from.
+ * fallback can still resolve it if our own hook is ever bypassed — that
+ * fallback runs `npm.add(pkg)` against the *published* registry into
+ * `<host-cache>/packages/<pkg>/node_modules/<pkg>`, ignoring any local
+ * `file://` plugin path this process was loaded from.
  *
  * `CURSOR_OPENCODE2_DEV_ENTRY` overrides the suffix with an `aisdk:file://…`
  * spec instead, pointed at a local built entry file (e.g. `dist/index.js`,
@@ -27,7 +28,41 @@ export declare const CURSOR_INTEGRATION_ID = "cursor";
  * Unset in production; only meant for local `opencode2 run` testing.
  */
 export declare const CURSOR_AISDK_PACKAGE: string;
-/** Register (or update) the Cursor provider entry. `update` is an upsert. */
-export declare function applyCursorProvider(draft: CatalogDraft): void;
-/** Register every discovered Cursor model. Safe to re-run; `update` upserts. */
-export declare function applyCursorModels(draft: CatalogDraft, models: ModelInfo[]): void;
+/**
+ * Plain-object `Model.Info` equivalent used by `ctx.provider.transform`.
+ */
+export type CatalogModelInfo = {
+    id: string;
+    modelID: string;
+    providerID: string;
+    name: string;
+    capabilities: {
+        tools: boolean;
+        input: string[];
+        output: string[];
+    };
+    limit: {
+        context: number;
+        output: number;
+    };
+    variants: ModelVariantInfo[];
+    status: "active";
+    enabled: true;
+    time: {
+        released: number;
+    };
+    cost: OpenCode2ModelCost[];
+    settings?: Record<string, unknown>;
+};
+/** Translate one `modelsToConfig` entry into the 2.0 `Model.Info` shape. */
+export declare function modelConfigEntryToInfo(id: string, entry: Record<string, any>): CatalogModelInfo;
+/** Full model map for the in-memory provider inventory. */
+export declare function modelsToCatalogModelMap(models: ModelInfo[]): Record<string, CatalogModelInfo>;
+/**
+ * Publish discovered Cursor models into the live provider inventory.
+ *
+ * Skip while empty (keeps the last successful inventory through a no-op
+ * transform on first register), replace the definition with `editor.add`,
+ * then `ctx.provider.reload()`.
+ */
+export declare function applyCursorProviderInventory(editor: ProviderEditor, models: ModelInfo[], sourceConnection?: ConnectionInfo): void;