cursor-opencode-provider 0.8.1 → 0.8.3

package/dist/opencode2/tool-results.js

@@ -0,0 +1,66 @@
+export const TOOL_RESULT_STATUS_KEY = "opencodeToolResult";
+const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value : undefined;
+export function nativeToolFailure(value, refusal) {
+    const envelope = record(value);
+    const error = record(envelope?.error);
+    const type = typeof error?.type === "string" && error.type ? error.type : "tool.execution";
+    const message = typeof error?.message === "string" && error.message
+        ? error.message : typeof value === "string" && value ? value : `OpenCode tool failed (${type})`;
+    const content = Array.isArray(envelope?.content) ? envelope.content.flatMap(item => {
+        const part = record(item);
+        return part?.type === "text" && typeof part.text === "string" && part.text ? [part.text] : [];
+    }).join("\n") : "";
+    return { type, text: content ? `${message}\n\n${content}` : message,
+        ...(refusal ? { refusal } : type === "permission.rejected" ? { refusal: "rejected" } : {}) };
+}
+/** The native tool hook preserves the underlying typed permission cause. */
+export function nativeToolRefusal(error) {
+    const seen = new Set();
+    for (let depth = 0; depth < 16 && !seen.has(error); depth++) {
+        seen.add(error);
+        const cause = record(error);
+        if (!cause)
+            return undefined;
+        if (cause._tag === "Permission.BlockedError")
+            return "permission_denied";
+        if (cause._tag === "Permission.CorrectedError" || cause._tag === "Permission.DeclinedError")
+            return "rejected";
+        error = cause.error;
+    }
+    return undefined;
+}
+/** Metadata travels with each part, including history and independently loaded SDK copies. */
+export function preserveNativeToolResults(messages, refusals = new Map()) {
+    if (!Array.isArray(messages))
+        return [];
+    return messages.map(message => {
+        const msg = record(message);
+        if (msg?.role !== "tool" || !Array.isArray(msg.content))
+            return message;
+        return { ...msg, content: msg.content.map(item => {
+                const part = record(item);
+                const result = record(part?.result);
+                if (part?.type !== "tool-result" || typeof part.id !== "string" || !result
+                    || typeof result.type !== "string" || !["error", "text", "json", "content"].includes(result.type))
+                    return item;
+                const metadata = record(part.providerMetadata);
+                const cursor = record(metadata?.cursor);
+                const status = result.type === "error"
+                    ? { callID: part.id, status: "error", failure: nativeToolFailure(result.value, refusals.get(part.id)) }
+                    : { callID: part.id, status: "completed" };
+                return { ...part, providerMetadata: { ...metadata, cursor: { ...cursor, [TOOL_RESULT_STATUS_KEY]: status } } };
+            }) };
+    });
+}
+export function toolResultFailure(options, callID) {
+    const status = record(record(record(options)?.cursor)?.[TOOL_RESULT_STATUS_KEY]);
+    if (status?.callID !== callID || status.status !== "error")
+        return undefined;
+    const failure = record(status.failure);
+    if (!failure || typeof failure.type !== "string" || typeof failure.text !== "string")
+        return undefined;
+    const refusal = failure.refusal === "permission_denied" || failure.refusal === "rejected" ? failure.refusal : undefined;
+    return { type: failure.type, text: failure.text || `OpenCode tool failed (${failure.type || "tool.execution"})`,
+        ...(refusal ? { refusal } : {}) };
+}

package/dist/plugin-opencode2.js

@@ -3,9 +3,11 @@ import { createSdk, cursorApiBaseURL, cursorGetServerConfigTelemetryEnabled, isC
 import { opencode2PlanDir, opencodeGlobalCacheDir, setNativePlansDir } from "./context/paths.js";
 import { discoverModels, isCacheFresh, readCache } from "./models.js";
 import { resolveAgentUrl } from "./agent-url.js";
-import { sessionActivity } from "./activity.js";
+import { applyHostPromptEvent, applyHostToolEvent, sessionActivity } from "./activity.js";
+import { notifyHostInterrupt } from "./host-interrupt.js";
+import { announceHostSteer, forgetEarlySteerOfInbox, forgetEarlySteers, rememberQueuedSteer, takeQueuedSteer, } from "./host-steer.js";
 import { fetchOpenCodeWebSearchText, parseExaWebSearchResults, } from "./web-tools.js";
-import { captureCursorShellResult, cursorShellEnvForCommand, prepareCursorShellArgs, releaseCursorShellEnv, sanitizeRegisteredCursorShellOutput, } from "./shell-timeout.js";
+import { armCursorShellCreate, captureCursorShellResult, captureCursorShellFailure, prepareCursorShellCreate, prepareCursorShellArgs, releaseCursorShellEnv, sanitizeRegisteredCursorShellOutput, } from "./shell-timeout.js";
 import { applyCursorProviderInventory, CURSOR_INTEGRATION_ID } from "./opencode2/catalog.js";
 import { applyCursorIntegration, requireCursorAccessToken, resolveCursorAccessToken, } from "./opencode2/integration.js";
 import { exposeDirectMcpTools, rememberDirectMcpNamespaces } from "./opencode2/mcp-direct.js";
@@ -20,6 +22,7 @@ import { trace } from "./debug.js";
 import { cancelHostAgentModeSwitch, hostAgentSwitchPromptText, setHostAgentModeSwitch, } from "./host-agent-mode.js";
 import { clearActiveCursorMode, getActiveCursorMode, normalizeSwitchModeId, setActiveCursorMode, } from "./protocol/switch-mode.js";
 import { CursorPlugin } from "./plugin.js";
+import { nativeToolRefusal, preserveNativeToolResults } from "./opencode2/tool-results.js";
 /**
  * OpenCode 2.0 plugin.
  *
@@ -101,6 +104,60 @@ const plugin = {
         let disposeHostAgentModeSwitch;
         trace(`opencode2 plugin: setup directory=${workspaceRoot}`);
         const hasShellEnvHook = typeof ctx.shell?.hook === "function";
+        const refusals = new Map();
+        const permissionCalls = new Map();
+        const rememberRefusal = (id, refusal) => {
+            refusals.delete(id);
+            refusals.set(id, refusal);
+            while (refusals.size > 512)
+                refusals.delete(refusals.keys().next().value);
+        };
+        const releasePermissionCalls = () => {
+            for (const call of permissionCalls.values())
+                releaseCursorShellEnv(call.callID);
+            permissionCalls.clear();
+        };
+        const toolLifecycle = (event) => {
+            const payload = eventPayload(event);
+            if (event?.type === "permission.asked" && payload?.source?.type === "tool"
+                && typeof payload.source.id === "string" && payload.source.id.startsWith("cursor_")
+                && typeof payload.id === "string" && typeof payload.sessionID === "string") {
+                permissionCalls.set(payload.id, { sessionID: payload.sessionID, callID: payload.source.id });
+            }
+            else if (event?.type === "permission.replied") {
+                const call = permissionCalls.get(payload?.requestID);
+                if (!call || call.sessionID !== payload?.sessionID)
+                    return;
+                permissionCalls.delete(payload.requestID);
+                if (payload.reply === "reject") {
+                    rememberRefusal(call.callID, "rejected");
+                    releaseCursorShellEnv(call.callID);
+                    // Native rejection also rejects the session's other pending requests.
+                    for (const [id, pending] of permissionCalls)
+                        if (pending.sessionID === call.sessionID) {
+                            rememberRefusal(pending.callID, "rejected");
+                            releaseCursorShellEnv(pending.callID);
+                            permissionCalls.delete(id);
+                        }
+                }
+            }
+            else if ((event?.type === "session.tool.failed" || event?.type === "session.tool.success")
+                && typeof payload?.id === "string") {
+                if (event.type === "session.tool.failed")
+                    releaseCursorShellEnv(payload.id);
+                for (const [id, call] of permissionCalls)
+                    if (call.callID === payload.id && call.sessionID === payload.sessionID) {
+                        permissionCalls.delete(id);
+                    }
+            }
+            else if (event?.type === "session.deleted") {
+                for (const [id, call] of permissionCalls)
+                    if (call.sessionID === payload?.sessionID) {
+                        releaseCursorShellEnv(call.callID);
+                        permissionCalls.delete(id);
+                    }
+            }
+        };
         if (typeof ctx.session.switchAgent === "function") {
             const switchAgent = ctx.session.switchAgent;
             const continueTurn = typeof ctx.session.synthetic === "function"
@@ -192,15 +249,13 @@ const plugin = {
         };
         // ── AI SDK wiring ────────────────────────────────────────
         await track(ctx.aisdk.hook("sdk", async (event) => {
-            if (event.sdk)
-                return;
             if (!isCursorPackage(event.package, event.model.providerID))
                 return;
+            // The host's generic loader runs before plugin hooks and may already
+            // have created a Cursor SDK with a captured token. Own our package's
+            // SDK so current integration credentials are resolved on every Run.
             event.sdk = createSdk({
                 name: event.model.providerID || CURSOR_PROVIDER_ID,
-                // Resolved per Run open: this SDK lives as long as the daemon, so
-                // a token captured here would outlive its expiry.
-                getAccessToken: (request) => requireCursorAccessToken(ctx.integration, request),
                 // Static fallback only. This hook fires once per model/package, not
                 // per session, and 2.0 runs one daemon across many projects — the
                 // real per-request directory comes from `x-opencode-directory`
@@ -208,6 +263,9 @@ const plugin = {
                 workspaceRoot,
                 cacheDir,
                 ...event.options,
+                // Keep after host options: a captured resolver/token must not bypass
+                // the integration's current credential and renewal path.
+                getAccessToken: (request) => requireCursorAccessToken(ctx.integration, request),
                 // Keep after `event.options` so the OC2 plugin always selects the
                 // `path`/`shell` dialect when advertised schemas are opaque.
                 defaultDialect: OPENCODE_2_TOOL_DIALECT,
@@ -262,22 +320,35 @@ const plugin = {
             exposeDirectMcpTools(draft, directMcpNamespaces);
         }));
         // ── Shell timeout wrapper ────────────────────────────────
-        await track(ctx.tool.hook("execute.before", (event) => {
-            if (!isShellTool(event.tool))
+        await track(ctx.tool.hook("execute.before", async (event) => {
+            if (!isShellTool(event.tool) || typeof event.input !== "object" || event.input === null)
                 return;
             const executionID = toolExecutionID(event);
-            prepareCursorShellArgs(executionID, event.input, {
-                // OpenCode 2.0 `shell.create.before` can inject env for bash/zsh.
+            const input = event.input;
+            prepareCursorShellArgs(executionID, input, {
+                deferToShellHook: hasShellEnvHook,
                 preferWrapperCommand: !hasShellEnvHook,
             });
+            if (hasShellEnvHook)
+                await armCursorShellCreate(executionID, event);
         }));
         await track(ctx.tool.hook("execute.after", (event) => {
+            const executionID = toolExecutionID(event);
+            if (event.status === "error") {
+                const refusal = nativeToolRefusal(event.error);
+                if (refusal)
+                    rememberRefusal(executionID, refusal);
+            }
+            else
+                refusals.delete(executionID);
             if (!isShellTool(event.tool))
                 return;
-            const executionID = toolExecutionID(event);
             try {
-                if (event.status !== "completed")
+                if (event.status !== "completed") {
+                    if (event.status === "error")
+                        captureCursorShellFailure(executionID, event.error);
                     return;
+                }
                 const result = event.result;
                 // V1: `output` is the model-facing string. V2: `output` is structured
                 // per-tool output (shell: `{ output: string, ... }`) and the
@@ -324,10 +395,7 @@ const plugin = {
         }));
         if (ctx.shell) {
             await track(ctx.shell.hook("create.before", (event) => {
-                const env = cursorShellEnvForCommand(event.command, event.cwd);
-                if (!env)
-                    return;
-                event.env = { ...event.env, ...env };
+                prepareCursorShellCreate(event);
             }));
         }
         const rememberSessionDirectory = async (sessionID) => {
@@ -341,6 +409,7 @@ const plugin = {
             }
         };
         await track(ctx.session.hook("context", async (event) => {
+            event.messages = preserveNativeToolResults(event.messages, refusals);
             markCompactionAndOptions(event, event.agent === "compaction");
             event.options ??= {};
             event.options[CURSOR_HOST_AGENT_OPTION] = event.agent;
@@ -401,14 +470,17 @@ const plugin = {
             };
         }, { providerID: CURSOR_PROVIDER_ID }));
         await track(ctx.session.hook("compaction", async (event) => {
+            event.messages = preserveNativeToolResults(event.messages, refusals);
             markCompactionAndOptions(event, true);
             await rememberSessionDirectory(event.sessionID);
         }));
         await track(ctx.session.hook("generate", async (event) => {
+            event.messages = preserveNativeToolResults(event.messages, refusals);
             markCompactionAndOptions(event, false);
             await rememberSessionDirectory(event.sessionID);
         }));
         await track(ctx.session.hook("title", async (event) => {
+            event.messages = preserveNativeToolResults(event.messages, refusals);
             markCompactionAndOptions(event, false);
             await rememberSessionDirectory(event.sessionID);
         }));
@@ -473,10 +545,13 @@ const plugin = {
             modelsLoaded = false;
             credentialGeneration++;
         };
-        const unsubscribe = subscribeSessionActivity(ctx, ensureModels, onCredentialSwitch);
+        const unsubscribe = subscribeSessionActivity(ctx, ensureModels, onCredentialSwitch, toolLifecycle, releasePermissionCalls);
         return async () => {
             clearInterval(retry);
             unsubscribe?.();
+            releasePermissionCalls();
+            refusals.clear();
+            await saveOpenTurnsForShutdown();
             disposeHostAgentModeSwitch?.();
             disposeNativePlansDir();
             trace(`opencode2 plugin: cleanup directory=${workspaceRoot}`);
@@ -486,22 +561,45 @@ const plugin = {
         };
     },
 };
-function subscribeSessionActivity(ctx, onEvent, onCredentialSwitch) {
+const SHUTDOWN_SAVE_TIMEOUT_MS = 2_000;
+/** Save every open turn for the next server start, without holding shutdown up for long. */
+async function saveOpenTurnsForShutdown() {
+    let timer;
+    const timedOut = new Promise((resolve) => {
+        timer = setTimeout(resolve, SHUTDOWN_SAVE_TIMEOUT_MS);
+        timer.unref?.();
+    });
+    try {
+        await Promise.race([notifyHostInterrupt(undefined, "shutdown"), timedOut]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function subscribeSessionActivity(ctx, onEvent, onCredentialSwitch, onToolEvent, onStreamClosed) {
     try {
-        const stream = ctx.event.subscribe();
+        const controller = new AbortController();
+        const stream = ctx.event.subscribe({ signal: controller.signal });
         if (!stream || typeof stream[Symbol.asyncIterator] !== "function")
             return undefined;
         let stopped = false;
         void (async () => {
-            for await (const event of stream) {
-                if (stopped)
-                    break;
-                applySessionActivity(event, onCredentialSwitch);
-                onEvent?.();
+            try {
+                for await (const event of stream) {
+                    if (stopped)
+                        break;
+                    applySessionActivity(event, onCredentialSwitch);
+                    onToolEvent?.(event);
+                    onEvent?.();
+                }
+            }
+            finally {
+                onStreamClosed?.();
             }
         })().catch(() => { });
         return () => {
             stopped = true;
+            controller.abort();
         };
     }
     catch {
@@ -511,6 +609,8 @@ function subscribeSessionActivity(ctx, onEvent, onCredentialSwitch) {
 function applySessionActivity(event, onCredentialSwitch) {
     const payload = eventPayload(event);
     const info = payload?.info;
+    applyHostPromptEvent(sessionActivity, event?.type, payload);
+    applyHostToolEvent(sessionActivity, event?.type, payload);
     switch (event?.type) {
         case "credential.switched":
         case "credential.updated": {
@@ -537,6 +637,7 @@ function applySessionActivity(event, onCredentialSwitch) {
             if (id) {
                 sessionActivity.removeSession(id);
                 clearSessionTodos(id);
+                forgetEarlySteers(id);
                 clearActiveCursorMode(id);
                 cancelHostAgentModeSwitch(id);
             }
@@ -561,6 +662,42 @@ function applySessionActivity(event, onCredentialSwitch) {
                 sessionActivity.recordActivity(id);
             break;
         }
+        case "session.inbox.enqueued": {
+            const id = payload?.sessionID;
+            if (id)
+                sessionActivity.recordActivity(id);
+            const steer = inboxSteer(id, payload?.inboxID, payload?.item);
+            if (!steer)
+                break;
+            if (payload.item.delivery === "steer")
+                announceInboxSteer(steer);
+            else
+                rememberQueuedSteer(steer);
+            break;
+        }
+        case "session.inbox.delivery.changed": {
+            const id = payload?.sessionID;
+            if (id)
+                sessionActivity.recordActivity(id);
+            if (payload?.delivery !== "steer" || typeof payload?.inboxID !== "string")
+                break;
+            const steer = takeQueuedSteer(payload.inboxID);
+            if (steer)
+                announceInboxSteer(steer);
+            break;
+        }
+        case "session.inbox.delivered":
+        case "session.inbox.cancelled": {
+            const id = payload?.sessionID;
+            if (id)
+                sessionActivity.recordActivity(id);
+            if (typeof payload?.inboxID !== "string")
+                break;
+            takeQueuedSteer(payload.inboxID);
+            if (event.type === "session.inbox.cancelled" && typeof id === "string")
+                forgetEarlySteerOfInbox(id, payload.inboxID);
+            break;
+        }
         default: {
             // OpenCode 2.0 emits granular `session.*` progress events instead of
             // the V1 `message.updated` family (`session.tool.called/success/failed`,
@@ -571,9 +708,32 @@ function applySessionActivity(event, onCredentialSwitch) {
                 const id = payload?.sessionID ?? info?.sessionID ?? info?.id;
                 if (id)
                     sessionActivity.recordActivity(id);
+                if (id && type === "session.execution.interrupted") {
+                    void notifyHostInterrupt(id, typeof payload?.reason === "string" ? payload.reason : "user", typeof event.created === "number" ? event.created : Date.now());
+                }
             }
             break;
         }
     }
 }
+/** A plain-text user message; one with files or skills reaches the prompt in another shape. */
+function inboxSteer(sessionID, inboxID, item) {
+    if (typeof sessionID !== "string" || !sessionID || typeof inboxID !== "string" || !inboxID)
+        return undefined;
+    if (item?.type !== "user" || (item.delivery !== "steer" && item.delivery !== "queue"))
+        return undefined;
+    const prompt = item.payload;
+    if (typeof prompt?.text !== "string" || !prompt.text.trim())
+        return undefined;
+    if (prompt.files?.length || prompt.skills?.length)
+        return undefined;
+    return { sessionID, inboxID, text: prompt.text };
+}
+function announceInboxSteer(steer) {
+    const taken = announceHostSteer(steer);
+    if (taken === undefined)
+        return;
+    trace(`steer: OpenCode enqueued a mid-step message sessionID=${steer.sessionID} inboxID=${steer.inboxID} ` +
+        `chars=${steer.text.length} ${taken ? "injected into the pumping Run" : "left for the next step"}`);
+}
 export default plugin;

package/dist/plugin.js

@@ -4,14 +4,15 @@ import { pollForTokens, exchangeApiKey, isExpiringSoon, generatePkceParams, gene
 import { renewSessionIfDue, resolveApiKeyToken, } from "./auth-renewal.js";
 import { CursorAuthError } from "./errors.js";
 import { errorMessage, trace } from "./debug.js";
+import { normalizeClassicInterruptedResults } from "./classic-tool-results.js";
 import { readCache, discoverModels, isCacheFresh } from "./models.js";
 import { modelsToConfig } from "./model-config.js";
 import { loadClassicTools } from "./classic-tools.js";
 import { opencodeGlobalCacheDir } from "./context/paths.js";
 import { readStoredAuth } from "./context/auth-store.js";
 import { resolveAgentUrl } from "./agent-url.js";
-import { captureCursorShellResult, cursorShellEnvForCall, cursorShellOriginalCommand, prepareCursorShellArgs, releaseCursorShellEnv, sanitizeRegisteredCursorShellOutput, setCursorShellPath, } from "./shell-timeout.js";
-import { sessionActivity } from "./activity.js";
+import { captureCursorShellResult, cursorShellEnvForCall, cursorShellOriginalCommand, cursorShellTimeoutMs, prepareCursorShellArgs, releaseCursorShellEnv, sanitizeRegisteredCursorShellOutput, setCursorShellPath, resolveCursorShellPath, } from "./shell-timeout.js";
+import { applyHostPromptEvent, applyHostToolEvent, sessionActivity } from "./activity.js";
 import { dispatchHostEventBridge } from "./host-event-bridge.js";
 import { createPromptHostAgentModeSwitch, setHostAgentModeSwitch } from "./host-agent-mode.js";
 import { isHostPlanFileResolved, resolveHostPlanFile } from "./host-plan-file.js";
@@ -250,6 +251,9 @@ export async function CursorPlugin(input) {
             cursor_image_save: classicTools.imageSave,
         },
         async event({ event }) {
+            // The SDK's event union predates these prompt events; read them untyped.
+            applyHostPromptEvent(sessionActivity, event.type, event.properties);
+            applyHostToolEvent(sessionActivity, event.type, event.properties);
             switch (event.type) {
                 case "session.created":
                     sessionActivity.linkSession(event.properties.info.id, event.properties.info.parentID);
@@ -266,6 +270,11 @@ export async function CursorPlugin(input) {
                     break;
                 case "message.part.updated":
                     sessionActivity.recordActivity(event.properties.part.sessionID);
+                    // Rejection/abort can stop the classic host before a continuation or
+                    // execute.after. Its persisted tool state is still authoritative.
+                    if (event.properties.part.type === "tool" && event.properties.part.state.status === "error") {
+                        releaseCursorShellEnv(event.properties.part.callID);
+                    }
                     break;
             }
             await dispatchHostEventBridge({
@@ -275,13 +284,22 @@ export async function CursorPlugin(input) {
                 serverUrl: input.serverUrl,
             });
         },
+        async "experimental.chat.messages.transform"(_hookInput, output) {
+            // The classic host retains the original array and discards hook output.
+            // Replace entries with request-only clones, preserving array identity.
+            const normalized = normalizeClassicInterruptedResults(output.messages);
+            for (let index = 0; index < output.messages.length; index++)
+                output.messages[index] = normalized[index];
+        },
         async "tool.execute.before"(hookInput, output) {
             if (hookInput.tool !== "bash")
                 return;
             // bash/zsh retain the original display/permission command and wrap via
-            // shell.env. sh/dash need a short wrapper-file command because their
+            // shell.env. sh/dash disclose the managed launcher inline because their
             // non-interactive `-c` path ignores BASH_ENV / ZDOTDIR.
-            prepareCursorShellArgs(hookInput.callID, output.args);
+            prepareCursorShellArgs(hookInput.callID, output.args, {
+                shellPath: resolveCursorShellPath(undefined, input.directory),
+            });
         },
         async "shell.env"(hookInput, output) {
             const env = cursorShellEnvForCall(hookInput.callID);
@@ -302,6 +320,11 @@ export async function CursorPlugin(input) {
                     if (typeof metadata.output === "string") {
                         metadata.output = sanitizeRegisteredCursorShellOutput(hookInput.callID, metadata.output);
                     }
+                    // The stored output keeps only a display notice, and the saved
+                    // outcome does not survive consumption or a restart.
+                    const timeoutMs = cursorShellTimeoutMs(hookInput.callID);
+                    if (timeoutMs !== undefined)
+                        metadata.cursorShellTimeoutMs = timeoutMs;
                 }
             }
             finally {
@@ -339,7 +362,7 @@ export async function CursorPlugin(input) {
             }
         },
         async config(cfg) {
-            setCursorShellPath(cfg.shell);
+            setCursorShellPath(cfg.shell, input.directory);
             cfg.provider ??= {};
             const models = await loadModels();
             const existing = cfg.provider[CURSOR_PROVIDER_ID];

package/dist/pricing-data.d.ts

@@ -140,14 +140,19 @@ export declare const CURSOR_MODEL_COSTS: {
     };
     readonly "gemini-3.7-flash": {
         readonly input: 0.75;
-        readonly output: 3.5;
+        readonly output: 3.75;
         readonly cache_read: 0.075;
     };
     readonly "gemini-3.8-flash": {
         readonly input: 0.75;
-        readonly output: 3.5;
+        readonly output: 3.75;
         readonly cache_read: 0.075;
     };
+    readonly "gemini-4-argon": {
+        readonly input: 2;
+        readonly output: 10;
+        readonly cache_read: 0.1;
+    };
     readonly "glm-5.2": {
         readonly input: 1.4;
         readonly output: 4.4;
@@ -304,6 +309,11 @@ export declare const CURSOR_MODEL_COSTS: {
         readonly output: 4.25;
         readonly cache_read: 0.15;
     };
+    readonly "muse-wonder-1.0": {
+        readonly input: 4;
+        readonly output: 20;
+        readonly cache_read: 0.2;
+    };
 };
 export declare const CURSOR_MODEL_CONTEXTS: {
     readonly "claude-fable-5": {
@@ -396,6 +406,10 @@ export declare const CURSOR_MODEL_CONTEXTS: {
         readonly maxContext: 200000;
         readonly maxContextForMaxMode: 1000000;
     };
+    readonly "gemini-4-argon": {
+        readonly maxContext: 200000;
+        readonly maxContextForMaxMode: 1000000;
+    };
     readonly "glm-5.2": {
         readonly maxContext: 200000;
     };
@@ -464,6 +478,10 @@ export declare const CURSOR_MODEL_CONTEXTS: {
         readonly maxContext: 300000;
         readonly maxContextForMaxMode: 1000000;
     };
+    readonly "muse-wonder-1.0": {
+        readonly maxContext: 300000;
+        readonly maxContextForMaxMode: 1000000;
+    };
 };
 export declare const CURSOR_MODEL_CAPABILITIES: {
     readonly "claude-fable-5": {
@@ -535,6 +553,9 @@ export declare const CURSOR_MODEL_CAPABILITIES: {
     readonly "gemini-3.8-flash": {
         readonly supportsImages: true;
     };
+    readonly "gemini-4-argon": {
+        readonly supportsImages: true;
+    };
     readonly "glm-5.2": {
         readonly supportsImages: false;
     };
@@ -595,4 +616,7 @@ export declare const CURSOR_MODEL_CAPABILITIES: {
     readonly "muse-spark-1.3": {
         readonly supportsImages: true;
     };
+    readonly "muse-wonder-1.0": {
+        readonly supportsImages: true;
+    };
 };

package/dist/pricing-data.js

@@ -140,14 +140,19 @@ export const CURSOR_MODEL_COSTS = {
     },
     "gemini-3.7-flash": {
         "input": 0.75,
-        "output": 3.5,
+        "output": 3.75,
         "cache_read": 0.075
     },
     "gemini-3.8-flash": {
         "input": 0.75,
-        "output": 3.5,
+        "output": 3.75,
         "cache_read": 0.075
     },
+    "gemini-4-argon": {
+        "input": 2,
+        "output": 10,
+        "cache_read": 0.1
+    },
     "glm-5.2": {
         "input": 1.4,
         "output": 4.4,
@@ -303,6 +308,11 @@ export const CURSOR_MODEL_COSTS = {
         "input": 1.25,
         "output": 4.25,
         "cache_read": 0.15
+    },
+    "muse-wonder-1.0": {
+        "input": 4,
+        "output": 20,
+        "cache_read": 0.2
     }
 };
 export const CURSOR_MODEL_CONTEXTS = {
@@ -396,6 +406,10 @@ export const CURSOR_MODEL_CONTEXTS = {
         "maxContext": 200000,
         "maxContextForMaxMode": 1000000
     },
+    "gemini-4-argon": {
+        "maxContext": 200000,
+        "maxContextForMaxMode": 1000000
+    },
     "glm-5.2": {
         "maxContext": 200000
     },
@@ -463,6 +477,10 @@ export const CURSOR_MODEL_CONTEXTS = {
     "muse-spark-1.3": {
         "maxContext": 300000,
         "maxContextForMaxMode": 1000000
+    },
+    "muse-wonder-1.0": {
+        "maxContext": 300000,
+        "maxContextForMaxMode": 1000000
     }
 };
 export const CURSOR_MODEL_CAPABILITIES = {
@@ -535,6 +553,9 @@ export const CURSOR_MODEL_CAPABILITIES = {
     "gemini-3.8-flash": {
         "supportsImages": true
     },
+    "gemini-4-argon": {
+        "supportsImages": true
+    },
     "glm-5.2": {
         "supportsImages": false
     },
@@ -594,5 +615,8 @@ export const CURSOR_MODEL_CAPABILITIES = {
     },
     "muse-spark-1.3": {
         "supportsImages": true
+    },
+    "muse-wonder-1.0": {
+        "supportsImages": true
     }
 };

package/dist/pricing.d.ts

@@ -40,7 +40,7 @@ export declare function validateOpenCodeModelCost(value: unknown, path?: string)
     errors: string[];
 };
 export declare function isOpenCodeModelCost(value: unknown): value is OpenCodeModelCost;
-/** Strip synthetic OpenCode suffixes (`…-1m`, `…-1m-2`, `…-1m-fast`, …). */
+/** Strip synthetic context suffixes (`…-1m`, `…-500k`, `…-500k-2-fast`, …). */
 export declare function wireModelIdForPricing(modelId: string): {
     baseId: string;
     longContextEntry: boolean;