cursor-opencode-provider 0.7.4 → 0.7.6

package/dist/language-model.js

@@ -32,6 +32,9 @@ import { resolveContinuationPolicy, sessionManager, } from "./session.js";
 import { CursorAuthError, CursorLocalCancellationError, CursorProtocolError, CursorProviderError, CursorRetryExhaustedError, CursorServerError, CursorTransportError, isTransientGrpcStatus, retrySuppressedError, toCursorProviderError, } from "./errors.js";
 import { readCache, cacheFilePath, resolveVariantParameters, resolveVariantMaxMode, extractCursorVariantParameters, resolveCursorWireModelId } from "./models.js";
 import { getOrBuildRequestContext } from "./context/frozen.js";
+import { getHeldOverlaySkills } from "./context/overlay.js";
+import { loadMergedConfig } from "./context/rules.js";
+import { buildDynamicCatalogRoutingInstruction, takeSkillCatalogChangeReminder, } from "./context/dynamic-catalog.js";
 import { admitContextEpoch, appendMidConversationMessage, resetContextEpochsForTests, } from "./context/epoch.js";
 import { workspaceRootFromRequestContext } from "./context/env.js";
 import { ensureOpencodeProjectDir, opencodeGlobalCacheDir, setHostCacheDirOverride, } from "./context/paths.js";
@@ -507,6 +510,12 @@ async function doStreamImpl(modelId, options, callOptions) {
     // false "orphaned tool results" errors after Cursor turn_ended and OpenCode
     // started the next step with old tools still in the prompt body.
     const trailingToolResults = extractTrailingToolResults(prompt);
+    // A host may submit an already rendered plan through its canonical stage
+    // tool after the Cursor Run has ended. The next call carries that tool result
+    // without a Cursor exec id; reconcile the approved mode before a fresh Run.
+    if (hasApprovedUncorrelatedPlanStageResult(prompt)) {
+        setActiveCursorMode(opencodeSessionKey(callOptions), "agent");
+    }
     let session = findContinuationSession(trailingToolResults);
     if (session) {
         // Write pending results onto the held-open Run. A dead stream closes the
@@ -533,19 +542,34 @@ async function doStreamImpl(modelId, options, callOptions) {
             if (historical > 0) {
                 trace(`fresh turn: ignoring ${historical} historical tool result(s) (not trailing)`);
             }
-            // Host may start a new user turn while the prior Run still has pending
-            // tools. Finish that Run on the same conversation (cancel stranded execs,
-            // drain turn_ended) before opening the new Run so the checkpoint prefix
-            // is preserved. registerSession will not close a prior Run that still
-            // has real pending execs; a failed prepare leaves that Run held.
-            try {
-                await preparePriorSessionForFreshTurn(sessionKey);
+            // An in-session helper (title/memory/task child) that reuses the parent
+            // OpenCode session id with a strictly smaller catalog must not cancel or
+            // supersede the held parent Run — that remints (`interrupted-run`) when
+            // the trailing tool result returns. Isolate onto an ephemeral conversation.
+            const busyPrior = sessionManager.findOpenByOpenCodeSessionId(sessionKey);
+            if (busyPrior
+                && !busyPrior.closed
+                && isProperCatalogSubset(extractTools(callOptions), busyPrior.toolCatalog ?? [])) {
+                trace(`fresh turn: isolating in-session helper — incomingTools subset of ` +
+                    `parentTools=${busyPrior.toolCatalog?.length ?? 0} ` +
+                    `priorSession=${busyPrior.sessionId} pending=${busyPrior.pending.size}`);
+                session = await openSession({ isolate: true });
             }
-            catch (error) {
-                trace(`fresh turn: prepare-prior failed — opening the new Run and leaving ` +
-                    `any still-pending prior held — ${error.message}`);
+            else {
+                // Host may start a new user turn while the prior Run still has pending
+                // tools. Finish that Run on the same conversation (cancel stranded execs,
+                // drain turn_ended) before opening the new Run so the checkpoint prefix
+                // is preserved. registerSession will not close a prior Run that still
+                // has real pending execs; a failed prepare leaves that Run held.
+                try {
+                    await preparePriorSessionForFreshTurn(sessionKey);
+                }
+                catch (error) {
+                    trace(`fresh turn: prepare-prior failed — opening the new Run and leaving ` +
+                        `any still-pending prior held — ${error.message}`);
+                }
+                session = await openSession();
             }
-            session = await openSession();
         }
     }
     let activeSession = session;
@@ -747,6 +771,7 @@ async function startSession(modelId, token, callOptions, options, startOptions)
     const prompt = callOptions.prompt;
     const incomingTools = extractTools(callOptions);
     const sessionKey = opencodeSessionKey(callOptions);
+    const isolateHelper = startOptions?.isolate === true;
     const cacheDir = opencodeGlobalCacheDir();
     if (sessionKey) {
         const restored = await hydrateConversationState(cacheDir, sessionKey).catch((error) => {
@@ -798,18 +823,28 @@ async function startSession(modelId, token, callOptions, options, startOptions)
     let resumeRecovery = recovery?.kind === "resume" ? recovery : undefined;
     let resuming = !!resumeRecovery;
     const lifecycle = !allowTools && !isCompaction && !recovery;
+    // Isolated helpers must not share the parent's openCodeSessionId or sticky
+    // conversation: registerSession would otherwise supersede the held parent Run.
+    const ephemeralRun = lifecycle || isolateHelper;
     // 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 last-resort fallback. Prefer the
-    // per-request `x-opencode-directory` header, then the session mark recorded
-    // from `session.hook("context")` via `getSessionDirectory`.
+    // per-request `x-opencode-directory` header (set by the 2.0 plugin's
+    // `session.hook("model.request")`), then the session mark recorded from the
+    // session hooks via `getSessionDirectory`.
     const workspaceRoot = resolveSessionWorkspaceRoot({
         sessionKey,
         headers: callOptions.headers,
         workspaceRoot: options.workspaceRoot,
     });
     const baseSystemPrompt = extractSystemPrompt(prompt);
-    const interactionGuidance = buildOpenCodeInteractionGuidance(cursorTools, isCompaction, workspaceRoot);
+    // One merged-config load per Run: guidance MCP ids and RequestContext
+    // descriptors must agree, and warm turns must not pay for a second disk read.
+    const mergedConfig = isCompaction ? undefined : await loadMergedConfig(workspaceRoot);
+    const knownMcpServers = Object.keys(mergedConfig?.mcp ?? {});
+    const interactionGuidance = buildOpenCodeInteractionGuidance(cursorTools, isCompaction, workspaceRoot, {
+        knownMcpServers,
+    });
     // Prompt-identity diagnostics are filled after Context Epoch admission below
     // (baseline hash is the epoch baseline, not a per-turn host hash).
     let frozenSystemPromptHash;
@@ -825,9 +860,9 @@ async function startSession(modelId, token, callOptions, options, startOptions)
         ? { conversationId: resumeRecovery.conversationId, reset: false, previousId: undefined }
         : bindConversationId(sessionKey, {
             reset: resetState.reset || recovery?.kind === "rebase",
-            ephemeral: lifecycle,
+            ephemeral: ephemeralRun,
         });
-    let conversationState = lifecycle
+    let conversationState = ephemeralRun
         ? undefined
         : resuming
             ? resumeRecovery.checkpoint
@@ -987,7 +1022,20 @@ async function startSession(modelId, token, callOptions, options, startOptions)
     });
     // Freeze RequestContext per conversation_id (CLI parity). Rebuilding every
     // Run mutates volatile slices (git porcelain, layout) and breaks prompt cache.
-    const { context: requestContext, reused: requestContextReused } = await getOrBuildRequestContext(conversationId, { workspaceRoot, tools: cursorTools });
+    const { context: requestContext, reused: requestContextReused } = await getOrBuildRequestContext(conversationId, { workspaceRoot, tools: cursorTools, mergedConfig });
+    // Issue #29: after skills are in RequestContext, admit the catalog. OpenCode
+    // only Mid-Conversation-updates when the available-skills list changes
+    // (SkillGuidance / SkillInstructions) — never per-turn matched-id nudges.
+    // Gate on the host-permitted set, not the epoch-held advertisement.
+    if (!isCompaction && !lifecycle) {
+        const skillDialect = hostToolDialectFromTools(tools, options.defaultDialect);
+        const skillNudge = takeSkillCatalogChangeReminder(conversationId, {
+            hasSkillTool: allowTools && incomingTools.some((tool) => tool.name === "skill"),
+            skills: getHeldOverlaySkills(conversationId),
+            skillArgKey: skillDialect.skillArgKey,
+        });
+        userText = appendMidConversationMessage(userText, skillNudge);
+    }
     const contextSubagents = Array.isArray(requestContext.custom_subagents)
         ? requestContext.custom_subagents
             .map((agent) => agent && typeof agent === "object" && typeof agent.name === "string"
@@ -1097,7 +1145,7 @@ async function startSession(modelId, token, callOptions, options, startOptions)
     }
     const hostToolDialect = hostToolDialectFromTools(tools, options.defaultDialect);
     trace(`host tool dialect: filePathKey=${hostToolDialect.filePathKey} shellTool=${hostToolDialect.shellTool} ` +
-        `tools=[${tools.map((t) => t.name).join(",")}]`);
+        `skillArgKey=${hostToolDialect.skillArgKey} tools=[${tools.map((t) => t.name).join(",")}]`);
     const session = {
         sessionId: crypto.randomUUID(),
         conversationId,
@@ -1125,7 +1173,7 @@ async function startSession(modelId, token, callOptions, options, startOptions)
             createPlanInTurn: false,
             switchModeInTurn: false,
         },
-        openCodeSessionId: lifecycle ? undefined : sessionKey,
+        openCodeSessionId: ephemeralRun ? undefined : sessionKey,
         hostAgent,
         stableSystemPromptHash: frozenSystemPromptHash,
         postCompactionRebase: isCompaction,
@@ -1138,7 +1186,7 @@ async function startSession(modelId, token, callOptions, options, startOptions)
         // Seed from the per-OpenCode-session copy: merges in this turn (and after
         // checkpoint resumes/rebases, which rebuild the session here) expand
         // against the last observed host list, not an empty one.
-        mirroredTodos: snapshotMirroredTodosBySession(lifecycle ? undefined : sessionKey),
+        mirroredTodos: snapshotMirroredTodosBySession(ephemeralRun ? undefined : sessionKey),
         nextBridgedExecId: 900_000,
         blobs: new Map(),
         toolDescriptors,
@@ -1242,6 +1290,39 @@ export function findContinuationSession(toolResults) {
     }
     return undefined;
 }
+/**
+ * True when `incoming` is a non-empty proper subset of `parent` by tool name.
+ * Used to spot in-session helpers that reuse the parent OpenCode session id
+ * with a reduced catalog (e.g. stripping `task` / `question` / `plan_exit`).
+ */
+export function isProperCatalogSubset(incoming, parent) {
+    if (incoming.length === 0 || parent.length === 0)
+        return false;
+    if (incoming.length >= parent.length)
+        return false;
+    const parentNames = new Set(parent.map((tool) => tool.name).filter((name) => !!name));
+    if (parentNames.size === 0)
+        return false;
+    let matched = 0;
+    for (const tool of incoming) {
+        const name = tool.name;
+        if (!name || !parentNames.has(name))
+            return false;
+        matched++;
+    }
+    return matched > 0 && matched < parentNames.size;
+}
+/**
+ * An open parent Run for this OpenCode session whose catalog strictly contains
+ * the incoming tools is treated as an in-session helper. Those calls must not
+ * cancel/supersede the parent (that remints on the trailing tool result).
+ */
+export function shouldIsolateInSessionHelper(openCodeSessionId, incomingTools) {
+    const prior = sessionManager.findOpenByOpenCodeSessionId(openCodeSessionId);
+    if (!prior || prior.closed)
+        return false;
+    return isProperCatalogSubset(incomingTools, prior.toolCatalog ?? []);
+}
 /** How long a fresh-turn drain may wait for Cursor `turn_ended` after bridged settle. */
 export const FRESH_TURN_DRAIN_TIMEOUT_MS = 8_000;
 /**
@@ -1836,6 +1917,14 @@ export function deliverContinuationResults(session, trailingToolResults) {
                 });
             }
         }
+        // A directly called advertised plan-stage tool can own the same review
+        // gate as a bridged CreatePlan. Its successful result means execution was
+        // approved, so the next Run must carry agent-mode guidance.
+        if (!pending.bridged
+            && pending.toolName === CURSOR_PLAN_STAGE_TOOL
+            && r.error === undefined) {
+            setActiveCursorMode(session.openCodeSessionId, "agent");
+        }
         // 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.
@@ -2864,7 +2953,7 @@ export async function pump(session, controller, ids, abortSignal) {
                                 imageId = stageCursorImage({
                                     path: target,
                                     projectDir,
-                                    mime: imageMimeForPath(target),
+                                    mime: imageMimeForPath(target, binaryWrite.data),
                                     data: binaryWrite.data,
                                     sessionId: session.openCodeSessionId,
                                 });
@@ -3299,6 +3388,25 @@ export function extractTrailingToolResults(prompt) {
         return [];
     return extractToolResults(prompt.slice(i + 1));
 }
+/** Detect a host-owned canonical plan review, excluding Cursor exec replies. */
+export function hasApprovedUncorrelatedPlanStageResult(prompt) {
+    if (prompt.length === 0 || prompt[prompt.length - 1].role !== "tool")
+        return false;
+    for (let i = prompt.length - 1; i >= 0 && prompt[i].role === "tool"; i--) {
+        const message = prompt[i];
+        if (!Array.isArray(message.content))
+            continue;
+        for (const part of message.content) {
+            if (part.type !== "tool-result" || part.toolName !== CURSOR_PLAN_STAGE_TOOL)
+                continue;
+            if (parseExecIdFromToolCallId(part.toolCallId))
+                continue;
+            const result = toolResultOutputToText(part.output);
+            return !result.isError;
+        }
+    }
+    return false;
+}
 function toolResultOutputToText(output) {
     if (output == null)
         return { text: "", isError: false };
@@ -3351,7 +3459,7 @@ export function groundCheckpointTurnText(userText, checkpoint, workspaceRoot, to
  * Redirect only to OpenCode tools that are genuinely advertised this turn;
  * compaction keeps its dedicated summary prompt unchanged.
  */
-export function buildOpenCodeInteractionGuidance(tools, isCompaction, workspaceRoot) {
+export function buildOpenCodeInteractionGuidance(tools, isCompaction, workspaceRoot, options = {}) {
     if (isCompaction)
         return undefined;
     const names = new Set(tools.map((tool) => tool.name));
@@ -3419,6 +3527,16 @@ export function buildOpenCodeInteractionGuidance(tools, isCompaction, workspaceR
             instructions.push("- Host `scout` is available for external documentation and dependency-source research. Use Cursor `cursor-guide` for that use case; local repository discovery still uses `bugbot`/`explore`.");
         }
     }
+    // Issue #29: skill/MCP stay off Cursor's native top-level list on both
+    // OpenCode 1.x and 2.0 — route them through the dynamic catalog instead.
+    {
+        const dynamicCatalog = buildDynamicCatalogRoutingInstruction({
+            toolNames: tools.map((tool) => tool.sourceName ?? tool.name),
+            knownMcpServers: options.knownMcpServers,
+        });
+        if (dynamicCatalog)
+            instructions.push(dynamicCatalog);
+    }
     if (names.has("write")) {
         instructions.push(names.has("edit")
             ? "- For file changes, use OpenCode `edit` for targeted changes to existing files and `write` to create files or intentionally replace complete contents; do not use shell, Python, or heredocs to change file content while these tools are available."

package/dist/opencode2/mcp-direct.d.ts

@@ -3,8 +3,13 @@ import type { ToolDraft } from "./types.js";
  * OpenCode 2 puts an MCP server's tools in Code Mode unless that server's
  * config sets `codemode: false` (`packages/schema/src/mcp.ts`, applied in
  * `packages/core/src/tool/mcp.ts`). Only `options.codemode === false` joins
- * the AI SDK catalog (`packages/core/src/tool.ts`). Cursor can call a tool
- * only when it is in that catalog.
+ * the AI SDK catalog (`packages/core/src/tool.ts`). This provider can advertise
+ * a tool to Cursor only when it is in that catalog.
+ *
+ * That AI SDK placement is necessary but not sufficient for Cursor models:
+ * non-native tools are still invoked through GetDynamicTools / CallDynamicTool
+ * (see `src/context/dynamic-catalog.ts`, issue #29). Classic OpenCode 1.x already
+ * puts MCP tools in the AI SDK catalog; this module is the OpenCode 2 equivalent.
  *
  * `config.codemode` is also the remote-connection switch: while it is not
  * false, OpenCode appends `?codemode=false` so servers that bundle their own

package/dist/opencode2/mcp-direct.js

@@ -2,8 +2,13 @@
  * OpenCode 2 puts an MCP server's tools in Code Mode unless that server's
  * config sets `codemode: false` (`packages/schema/src/mcp.ts`, applied in
  * `packages/core/src/tool/mcp.ts`). Only `options.codemode === false` joins
- * the AI SDK catalog (`packages/core/src/tool.ts`). Cursor can call a tool
- * only when it is in that catalog.
+ * the AI SDK catalog (`packages/core/src/tool.ts`). This provider can advertise
+ * a tool to Cursor only when it is in that catalog.
+ *
+ * That AI SDK placement is necessary but not sufficient for Cursor models:
+ * non-native tools are still invoked through GetDynamicTools / CallDynamicTool
+ * (see `src/context/dynamic-catalog.ts`, issue #29). Classic OpenCode 1.x already
+ * puts MCP tools in the AI SDK catalog; this module is the OpenCode 2 equivalent.
  *
  * `config.codemode` is also the remote-connection switch: while it is not
  * false, OpenCode appends `?codemode=false` so servers that bundle their own

package/dist/opencode2/types.d.ts

@@ -17,6 +17,13 @@ export type Registration = {
     readonly dispose: () => Promise<void>;
 };
 export type Hooks<Spec> = <Name extends keyof Spec>(name: Name, callback: (input: Spec[Name]) => Promise<void> | void) => Promise<Registration>;
+export type ModelHookOptions = {
+    /** Limits the hook to one provider; the host skips events for any other. */
+    readonly providerID?: string;
+};
+export type ModelHooks<Spec> = <Name extends keyof Spec>(name: Name, callback: (input: Spec[Name]) => Promise<void> | void, options?: Spec[Name] extends {
+    readonly model: unknown;
+} ? ModelHookOptions : never) => Promise<Registration>;
 export type Transform<Input> = (callback: (input: Input) => void) => Promise<Registration>;
 export type ProviderInfo = {
     id: string;
@@ -304,11 +311,28 @@ export type SessionTitle = {
     options?: Record<string, unknown>;
     result?: string;
 };
+/**
+ * Outbound request headers / route overrides for one model call.
+ * Headers reach the AI SDK as `callOptions.headers`.
+ */
+export type SessionModelRequest = {
+    readonly sessionID: string;
+    readonly agent: string;
+    readonly model: {
+        providerID: string;
+        id: string;
+        variant?: string;
+    };
+    readonly kind: "primary" | "compaction" | "title" | "generate";
+    baseURL?: string;
+    headers: Record<string, string>;
+};
 export type SessionHooks = {
     readonly context: SessionContext;
     readonly compaction: SessionCompaction;
     readonly generate: SessionGenerate;
     readonly title: SessionTitle;
+    readonly "model.request": SessionModelRequest;
 };
 /** Only the `location.directory` field we actually read. */
 export type SessionInfo = {
@@ -318,7 +342,7 @@ export type SessionInfo = {
     };
 };
 export type SessionDomain = {
-    readonly hook: Hooks<SessionHooks>;
+    readonly hook: ModelHooks<SessionHooks>;
     readonly get: (input: {
         sessionID: string;
     }) => Promise<SessionInfo>;

package/dist/plugin-opencode2.js

@@ -13,7 +13,8 @@ import { registerTodoTools } from "./opencode2/todo-tools.js";
 import { OPENCODE_2_TOOL_DIALECT } from "./protocol/tools.js";
 import { clearSessionTodos } from "./todo-store.js";
 import { markCompactionSession } from "./compaction-marker.js";
-import { markSessionDirectory } from "./session-directory.js";
+import { getSessionDirectory, markSessionDirectory } from "./session-directory.js";
+import { trace } from "./debug.js";
 import { cancelPlanExecutionKickoff, createPlanExecutionKickoffText, setPlanExecutionKickoff, } from "./plan-execution-kickoff.js";
 import { cancelHostAgentModeSwitch, setHostAgentModeSwitch, } from "./host-agent-mode.js";
 import { clearActiveCursorMode, getActiveCursorMode, normalizeSwitchModeId, setActiveCursorMode, } from "./protocol/switch-mode.js";
@@ -215,8 +216,8 @@ const plugin = {
                 ...(token ? { accessToken: token } : {}),
                 // 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` and
-                // the session.context hook below via `getSessionDirectory`.
+                // real per-request directory comes from `x-opencode-directory`
+                // (set on `session.model.request`) and the session-directory mark.
                 workspaceRoot,
                 cacheDir,
                 ...event.options,
@@ -267,8 +268,9 @@ const plugin = {
             // the host does not already own those names. When off, register none.
             registerTodoTools(draft);
             // MCP tools default into Code Mode. Move every server that did not
-            // explicitly opt in onto the direct catalog so Cursor can call them
-            // by name. See `opencode2/mcp-direct.ts`.
+            // explicitly opt in onto the direct catalog so this provider can
+            // advertise them to Cursor (issue #29 still routes via CallDynamicTool).
+            // See `opencode2/mcp-direct.ts`.
             exposeDirectMcpTools(draft, directMcpNamespaces);
         }));
         // ── Shell timeout wrapper ────────────────────────────────
@@ -342,13 +344,12 @@ const plugin = {
         }
         const rememberSessionDirectory = async (sessionID) => {
             try {
-                const info = (await ctx.session.get({ sessionID }));
-                // OpenCode 2.0 stable exposes a flat `directory`; older shapes nest it
-                // under `location.directory`. Prefer the flat field when both exist.
-                markSessionDirectory(sessionID, info.directory ?? info.location?.directory);
+                const info = await ctx.session.get({ sessionID });
+                markSessionDirectory(sessionID, info.location.directory);
             }
-            catch {
+            catch (error) {
                 // Best effort — falls back to the static workspaceRoot above.
+                trace(`session directory: session.get failed sessionID=${sessionID}: ${String(error)}`);
             }
         };
         await track(ctx.session.hook("context", async (event) => {
@@ -371,6 +372,31 @@ const plugin = {
             }
             await rememberSessionDirectory(event.sessionID);
         }));
+        // The session mark lives in module state, and OpenCode re-evaluates a local
+        // plugin's module graph per Location, so the copy running the model may not
+        // hold it. The header travels with the request (AI SDK
+        // `callOptions.headers` → `resolveSessionWorkspaceRoot`) and never reaches
+        // Cursor. Only a successful lookup updates the mark; on failure keep the
+        // last known session directory ahead of this Location's static root.
+        // Scoped by the host to this provider: other providers' requests never
+        // reach the callback, so the header cannot leak to their endpoints.
+        await track(ctx.session.hook("model.request", async (event) => {
+            const current = await ctx.session
+                .get({ sessionID: event.sessionID })
+                .then((info) => info.location.directory)
+                .catch((error) => {
+                trace(`model.request: session.get failed sessionID=${event.sessionID}: ${String(error)}`);
+                return undefined;
+            });
+            markSessionDirectory(event.sessionID, current);
+            const directory = current ?? getSessionDirectory(event.sessionID) ?? ctx.location?.directory;
+            if (!directory)
+                return;
+            event.headers = {
+                ...event.headers,
+                "x-opencode-directory": encodeURIComponent(directory),
+            };
+        }, { providerID: CURSOR_PROVIDER_ID }));
         await track(ctx.session.hook("compaction", async (event) => {
             markCompactionAndOptions(event, true);
             await rememberSessionDirectory(event.sessionID);

package/dist/pricing-data.d.ts

@@ -91,6 +91,12 @@ export declare const CURSOR_MODEL_COSTS: {
         readonly cache_read: 0.2;
         readonly cache_write: 2.5;
     };
+    readonly "claude-sonnet-5-5": {
+        readonly input: 2;
+        readonly output: 10;
+        readonly cache_read: 0.2;
+        readonly cache_write: 2.5;
+    };
     readonly "composer-2.5": {
         readonly input: 0.5;
         readonly output: 2.5;
@@ -141,6 +147,16 @@ export declare const CURSOR_MODEL_COSTS: {
         readonly output: 4.4;
         readonly cache_read: 0.26;
     };
+    readonly "glm-5.3": {
+        readonly input: 1.4;
+        readonly output: 4.4;
+        readonly cache_read: 0.26;
+    };
+    readonly "glm-5.3-flash": {
+        readonly input: 0.15;
+        readonly output: 0.5;
+        readonly cache_read: 0.029;
+    };
     readonly "gpt-5-mini": {
         readonly input: 0.25;
         readonly output: 2;
@@ -335,6 +351,10 @@ export declare const CURSOR_MODEL_CONTEXTS: {
         readonly maxContext: 200000;
         readonly maxContextForMaxMode: 1000000;
     };
+    readonly "claude-sonnet-5-5": {
+        readonly maxContext: 200000;
+        readonly maxContextForMaxMode: 1000000;
+    };
     readonly "composer-2.5": {
         readonly maxContext: 200000;
     };
@@ -369,6 +389,12 @@ export declare const CURSOR_MODEL_CONTEXTS: {
     readonly "glm-5.2": {
         readonly maxContext: 200000;
     };
+    readonly "glm-5.3": {
+        readonly maxContext: 1000000;
+    };
+    readonly "glm-5.3-flash": {
+        readonly maxContext: 1000000;
+    };
     readonly "gpt-5-mini": {
         readonly maxContext: 272000;
     };
@@ -469,6 +495,9 @@ export declare const CURSOR_MODEL_CAPABILITIES: {
     readonly "claude-sonnet-5": {
         readonly supportsImages: true;
     };
+    readonly "claude-sonnet-5-5": {
+        readonly supportsImages: true;
+    };
     readonly "composer-2.5": {
         readonly supportsImages: true;
     };
@@ -496,6 +525,12 @@ export declare const CURSOR_MODEL_CAPABILITIES: {
     readonly "glm-5.2": {
         readonly supportsImages: false;
     };
+    readonly "glm-5.3": {
+        readonly supportsImages: false;
+    };
+    readonly "glm-5.3-flash": {
+        readonly supportsImages: true;
+    };
     readonly "gpt-5-mini": {
         readonly supportsImages: true;
     };

package/dist/pricing-data.js

@@ -91,6 +91,12 @@ export const CURSOR_MODEL_COSTS = {
         "cache_read": 0.2,
         "cache_write": 2.5
     },
+    "claude-sonnet-5-5": {
+        "input": 2,
+        "output": 10,
+        "cache_read": 0.2,
+        "cache_write": 2.5
+    },
     "composer-2.5": {
         "input": 0.5,
         "output": 2.5,
@@ -141,6 +147,16 @@ export const CURSOR_MODEL_COSTS = {
         "output": 4.4,
         "cache_read": 0.26
     },
+    "glm-5.3": {
+        "input": 1.4,
+        "output": 4.4,
+        "cache_read": 0.26
+    },
+    "glm-5.3-flash": {
+        "input": 0.15,
+        "output": 0.5,
+        "cache_read": 0.029
+    },
     "gpt-5-mini": {
         "input": 0.25,
         "output": 2,
@@ -335,6 +351,10 @@ export const CURSOR_MODEL_CONTEXTS = {
         "maxContext": 200000,
         "maxContextForMaxMode": 1000000
     },
+    "claude-sonnet-5-5": {
+        "maxContext": 200000,
+        "maxContextForMaxMode": 1000000
+    },
     "composer-2.5": {
         "maxContext": 200000
     },
@@ -369,6 +389,12 @@ export const CURSOR_MODEL_CONTEXTS = {
     "glm-5.2": {
         "maxContext": 200000
     },
+    "glm-5.3": {
+        "maxContext": 1000000
+    },
+    "glm-5.3-flash": {
+        "maxContext": 1000000
+    },
     "gpt-5-mini": {
         "maxContext": 272000
     },
@@ -469,6 +495,9 @@ export const CURSOR_MODEL_CAPABILITIES = {
     "claude-sonnet-5": {
         "supportsImages": true
     },
+    "claude-sonnet-5-5": {
+        "supportsImages": true
+    },
     "composer-2.5": {
         "supportsImages": true
     },
@@ -496,6 +525,12 @@ export const CURSOR_MODEL_CAPABILITIES = {
     "glm-5.2": {
         "supportsImages": false
     },
+    "glm-5.3": {
+        "supportsImages": false
+    },
+    "glm-5.3-flash": {
+        "supportsImages": true
+    },
     "gpt-5-mini": {
         "supportsImages": true
     },

package/dist/protocol/generate-image.d.ts

@@ -30,8 +30,8 @@ export type DecodedGenerateImageQuery = {
     referenceImagePaths: string[];
     toolCallId: string;
 };
-/** Cursor names the target file; its extension is the only mime signal sent. */
-export declare function imageMimeForPath(filePath: string): string;
+/** Prefer encoded bytes: Cursor can send JPEG data with a .png target name. */
+export declare function imageMimeForPath(filePath: string, data?: Uint8Array): string;
 /** Decode a `generate_image_request_query` body, or undefined when unusable. */
 export declare function decodeGenerateImageQuery(queryBytes: Uint8Array): DecodedGenerateImageQuery | undefined;
 export type ImageWriteRoots = {

package/dist/protocol/generate-image.js

@@ -32,8 +32,20 @@ const IMAGE_MIME_BY_EXTENSION = {
     ".gif": "image/gif",
     ".webp": "image/webp",
 };
-/** Cursor names the target file; its extension is the only mime signal sent. */
-export function imageMimeForPath(filePath) {
+/** Prefer encoded bytes: Cursor can send JPEG data with a .png target name. */
+export function imageMimeForPath(filePath, data) {
+    if (data) {
+        const matches = (signature, offset = 0) => signature.every((byte, index) => data[offset + index] === byte);
+        if (matches([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))
+            return "image/png";
+        if (matches([0xff, 0xd8, 0xff]))
+            return "image/jpeg";
+        if (matches([0x47, 0x49, 0x46, 0x38]) && (data[4] === 0x37 || data[4] === 0x39) && data[5] === 0x61) {
+            return "image/gif";
+        }
+        if (matches([0x52, 0x49, 0x46, 0x46]) && matches([0x57, 0x45, 0x42, 0x50], 8))
+            return "image/webp";
+    }
     const dot = path.basename(filePath).lastIndexOf(".");
     if (dot <= 0)
         return "image/png";

package/dist/protocol/tools.d.ts

@@ -12,9 +12,12 @@ export type OpencodeToolDef = {
 export type HostFilePathKey = "path" | "filePath";
 /** Host shell tool id. OpenCode 1.x uses `bash`; 2.0 uses `shell`. */
 export type HostShellTool = "bash" | "shell";
+/** OpenCode 1.x skill params use `name`; OpenCode 2.0 uses `id`. */
+export type HostSkillArgKey = "name" | "id";
 export type HostToolDialect = {
     filePathKey: HostFilePathKey;
     shellTool: HostShellTool;
+    skillArgKey: HostSkillArgKey;
 };
 export declare const OPENCODE_1_TOOL_DIALECT: HostToolDialect;
 export declare const OPENCODE_2_TOOL_DIALECT: HostToolDialect;
@@ -23,6 +26,7 @@ export declare function opencodePathArg(args: Record<string, unknown> | undefine
 /**
  * Infer the host tool dialect from advertised AI SDK schemas.
  * OpenCode 2.0 read/edit/write require `path` and rename bash → `shell`.
+ * Skill: OpenCode 1.x requires `name`; OpenCode 2.0 requires `id`.
  */
 export declare function hostToolDialectFromTools(tools: readonly {
     name?: string;