cursor-opencode-provider 0.8.0 → 0.8.3

package/dist/models.js

@@ -1,6 +1,5 @@
 import { MODEL_CACHE_FILE, MODEL_CACHE_SCHEMA_VERSION, MODEL_CACHE_TTL_MS } from "./shared.js";
 import { unaryAvailableModels } from "./transport/connect.js";
-import { buildRequestedModelParams } from "./protocol/thinking.js";
 import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 /** Dedicated OpenCode provider-option key for a selected Cursor variant. */
@@ -59,11 +58,15 @@ export function normalizeModelParameterValues(value) {
     if (!Array.isArray(value))
         return null;
     const parameters = [];
+    const ids = new Set();
     for (const parameter of value) {
         if (!isPlainRecord(parameter))
             return null;
         if (!isNonEmptyString(parameter.id) || typeof parameter.value !== "string")
             return null;
+        if (ids.has(parameter.id))
+            return null;
+        ids.add(parameter.id);
         parameters.push({ id: parameter.id, value: parameter.value });
     }
     return parameters;
@@ -78,10 +81,12 @@ function normalizeVariant(value, fallbackName) {
     const displayName = optionalString(value, ["displayName", "display_name"]);
     const isDefaultNonMax = optionalBoolean(value, ["isDefaultNonMax", "isDefaultNonMaxConfig", "is_default_non_max_config"]);
     const isDefaultMax = optionalBoolean(value, ["isDefaultMax", "isDefaultMaxConfig", "is_default_max_config"]);
+    const isMaxMode = optionalBoolean(value, ["isMaxMode", "is_max_mode"]);
     if (key === null ||
         displayName === null ||
         isDefaultNonMax === null ||
-        isDefaultMax === null) {
+        isDefaultMax === null ||
+        isMaxMode === null) {
         return null;
     }
     if ((key !== undefined && !isNonEmptyString(key)) ||
@@ -94,6 +99,7 @@ function normalizeVariant(value, fallbackName) {
         parameterValues: parameters,
         isDefaultNonMax: isDefaultNonMax ?? false,
         isDefaultMax: isDefaultMax ?? false,
+        ...(isMaxMode === undefined ? {} : { isMaxMode }),
     };
 }
 function normalizeModelInfo(value) {
@@ -111,6 +117,7 @@ function normalizeModelInfo(value) {
     const supportsAgent = optionalBoolean(value, ["supportsAgent", "supports_agent"]);
     const supportsImages = optionalBoolean(value, ["supportsImages", "supports_images"]);
     const supportsMaxMode = optionalBoolean(value, ["supportsMaxMode", "supports_max_mode"]);
+    const supportsNonMaxMode = optionalBoolean(value, ["supportsNonMaxMode", "supports_non_max_mode"]);
     const maxContext = optionalPositiveNumber(value, ["maxContext", "contextTokenLimit", "context_token_limit"]);
     const maxContextForMaxMode = optionalPositiveNumber(value, ["maxContextForMaxMode", "contextTokenLimitForMaxMode", "context_token_limit_for_max_mode"]);
     if (displayName === null ||
@@ -119,6 +126,7 @@ function normalizeModelInfo(value) {
         supportsAgent === null ||
         supportsImages === null ||
         supportsMaxMode === null ||
+        supportsNonMaxMode === null ||
         maxContext === null ||
         maxContextForMaxMode === null) {
         return null;
@@ -133,6 +141,7 @@ function normalizeModelInfo(value) {
         ...(maxContext === undefined ? {} : { maxContext }),
         ...(maxContextForMaxMode === undefined ? {} : { maxContextForMaxMode }),
         ...(supportsMaxMode === undefined ? {} : { supportsMaxMode }),
+        ...(supportsNonMaxMode === undefined ? {} : { supportsNonMaxMode }),
         variants: variants,
     };
 }
@@ -176,17 +185,37 @@ export function resolveCursorWireModelId(providerOptions, fallback) {
     const value = providerOptions?.[CURSOR_WIRE_MODEL_ID_KEY];
     return typeof value === "string" && value.trim() ? value : fallback;
 }
-/** True when resolved params select the long-context (1m) tier. */
+/**
+ * True when resolved params select the long-context (1m) tier. Fallback for
+ * variants without Cursor's `isMaxMode` marker.
+ */
 export function paramsImplyMaxMode(params) {
     return params.some((parameter) => parameter.id === "context" &&
         parseCursorContextLimit(parameter.value) === 1_000_000);
 }
+function sameParameterTuple(a, b) {
+    const byId = new Map(b.map((parameter) => [parameter.id, parameter.value]));
+    return (a.length === b.length &&
+        new Set(a.map((parameter) => parameter.id)).size === a.length &&
+        byId.size === b.length &&
+        a.every((parameter) => byId.get(parameter.id) === parameter.value));
+}
+/** Cursor's per-variant max-mode marker, else the 1m-context fallback. */
+function variantIsMaxMode(v) {
+    return v.isMaxMode ?? paramsImplyMaxMode(v.parameterValues);
+}
 /**
- * Resolve the request-level max_mode bit. An explicit variant pick owns the
- * context tier; otherwise a standalone maxMode hint may select max mode.
+ * Resolve the request-level max_mode bit. Like Cursor CLI, a cataloged variant
+ * requires max mode when Cursor marks it `isMaxMode` (Grok 4.7's 500k tier as
+ * well as 1m tiers) or the model does not support non-max mode. An explicit
+ * variant pick owns the context tier; otherwise a standalone maxMode hint may
+ * select max mode.
  */
 export function resolveVariantMaxMode(params, opts = {}) {
-    return paramsImplyMaxMode(params) || (opts.picked === undefined && opts.maxMode === true);
+    if (opts.model?.supportsNonMaxMode === false)
+        return true;
+    const marked = opts.model?.variants.find((v) => sameParameterTuple(v.parameterValues, params))?.isMaxMode;
+    return (marked ?? paramsImplyMaxMode(params)) || (opts.picked === undefined && opts.maxMode === true);
 }
 // Cursor encodes a model's context window as a variant parameter `id: "context"`
 // whose value is a tier string — the same 200k / 272k / 300k / 1m the IDE's
@@ -212,8 +241,28 @@ function variantContextTokens(v) {
     const raw = v?.parameterValues.find((p) => p.id === "context")?.value;
     return parseCursorContextLimit(raw);
 }
-function isLongContextVariant(v) {
-    return variantContextTokens(v) === 1_000_000;
+/** Same parameters as `target` except the ignored ids. */
+function isTwinOf(v, target, ignored) {
+    return (v.parameterValues.length === target.parameterValues.length &&
+        sameParameterTuple(v.parameterValues.filter((p) => !ignored.includes(p.id)), target.parameterValues.filter((p) => !ignored.includes(p.id))));
+}
+/**
+ * Find Cursor's declared default within a catalog subset, retaining its effort:
+ * the declared variant, else its speed twin, else its twin in another context
+ * tier (a 500k entry when the declared max default is 1m).
+ */
+export function findDefaultVariant(model, candidates, maxMode) {
+    const isDeclared = (v) => maxMode ? v.isDefaultMax : v.isDefaultNonMax;
+    const declared = model.variants.find(isDeclared);
+    return candidates.find(isDeclared) ??
+        (declared === undefined
+            ? undefined
+            : candidates.find((v) => isTwinOf(v, declared, ["fast"])) ??
+                candidates.find((v) => isTwinOf(v, declared, ["fast", "context"])));
+}
+/** Send an advertised tuple verbatim; never rewrite one of its values. */
+function copyParameters(parameters) {
+    return parameters.map((parameter) => ({ ...parameter }));
 }
 function positiveNumber(value) {
     return typeof value === "number" && Number.isFinite(value) && value > 0
@@ -286,27 +335,38 @@ export function mapAvailableModelsResponse(raw) {
             if (!parameterValues) {
                 throw new Error(`AvailableModels returned invalid parameter values for ${name}`);
             }
+            const isMaxMode = optionalBoolean(v, ["isMaxMode", "is_max_mode"]);
+            if (isMaxMode === null) {
+                throw new Error(`AvailableModels returned a non-boolean isMaxMode for ${name}`);
+            }
             variants.push({
                 key: name,
                 parameterValues,
                 displayName: (v.displayName ?? v.display_name ?? name),
                 isDefaultNonMax: apiBoolean(v, ["isDefaultNonMaxConfig", "is_default_non_max_config"]),
                 isDefaultMax: apiBoolean(v, ["isDefaultMaxConfig", "is_default_max_config"]),
+                ...(isMaxMode === undefined ? {} : { isMaxMode }),
             });
         }
         // Derive the context window from the variant `context` param (primary
         // source). Base tier ← default non-max variant; max tier ← default max
         // variant. Fall back to the (often empty) proto fields, then undefined.
-        // Prefer a non-1m context when isDefaultNonMax is missing so a leading
+        // Prefer a non-max context when isDefaultNonMax is missing so a leading
         // max-mode variant cannot inflate the base window.
         const variantBaseContext = variantContextTokens(variants.find((v) => v.isDefaultNonMax)) ??
-            variantContextTokens(variants.find((v) => variantContextTokens(v) !== 1_000_000)) ??
+            variantContextTokens(variants.find((v) => !variantIsMaxMode(v) && variantContextTokens(v) !== undefined &&
+                variantContextTokens(v) !== 1_000_000)) ??
             variantContextTokens(variants.find((v) => v.parameterValues.some((p) => p.id === "context")));
-        const variantMaxContext = variantContextTokens(variants.find((v) => v.isDefaultMax));
+        const variantMaxContext = variantContextTokens(variants.find((v) => v.isDefaultMax)) ??
+            variantContextTokens(variants.find((v) => variantIsMaxMode(v) && variantContextTokens(v) !== undefined));
         const supportsImages = optionalBoolean(e, ["supportsImages", "supports_images"]);
         if (supportsImages === null) {
             throw new Error(`AvailableModels returned invalid supportsImages for ${name}`);
         }
+        const supportsNonMaxMode = optionalBoolean(e, ["supportsNonMaxMode", "supports_non_max_mode"]);
+        if (supportsNonMaxMode === null) {
+            throw new Error(`AvailableModels returned invalid supportsNonMaxMode for ${name}`);
+        }
         models.push({
             id: name,
             displayName: (e.clientDisplayName ?? e.client_display_name ?? name),
@@ -317,6 +377,7 @@ export function mapAvailableModelsResponse(raw) {
             maxContextForMaxMode: variantMaxContext ??
                 positiveNumber(e.contextTokenLimitForMaxMode ?? e.context_token_limit_for_max_mode),
             supportsMaxMode: apiBoolean(e, ["supportsMaxMode", "supports_max_mode"]),
+            ...(supportsNonMaxMode === undefined ? {} : { supportsNonMaxMode }),
             variants,
         });
     }
@@ -344,51 +405,46 @@ export function resolveVariantParameters(model, opts = {}) {
         }
         return opts.reasoningEffort ? [{ id: "effort", value: opts.reasoningEffort }] : [];
     }
-    const effortOf = (v) => v.parameterValues.find((p) => p.id === "effort" || p.id === "reasoning")?.value;
+    const effortOf = (v) => v.parameterValues.find((p) => p.id === "effort" || p.id === "reasoning" || p.id === "reasoning_effort")?.value;
     const isFast = (v) => v.parameterValues.find((p) => p.id === "fast")?.value === "true";
-    const isMaxVariant = (v) => v.isDefaultMax || isLongContextVariant(v);
-    const wantMax = opts.maxMode ?? false;
-    // Non-fast pool for hint-based resolution only. Exact `picked` matching
-    // searches all variants so Fast selections are not silently dropped.
-    const pool = model.variants.filter((v) => !isFast(v));
-    const scoped = pool.length > 0 ? pool : model.variants;
+    const wantMax = (opts.maxMode ?? false) || model.supportsNonMaxMode === false;
     // 1. Variant explicitly picked by opencode (verbatim — preserves context, fast, …).
     if (picked !== undefined) {
-        const pickedById = new Map(picked.map((parameter) => [parameter.id, parameter.value]));
-        const exact = model.variants.find((v) => v.parameterValues.length === picked.length &&
-            pickedById.size === picked.length &&
-            v.parameterValues.every((parameter) => pickedById.get(parameter.id) === parameter.value));
+        const exact = model.variants.find((v) => sameParameterTuple(v.parameterValues, picked));
         if (exact) {
-            return buildRequestedModelParams(exact.parameterValues);
+            return copyParameters(exact.parameterValues);
         }
         throw new CursorVariantSelectionError(`is stale for model ${JSON.stringify(model.id)}: its exact parameter tuple is unavailable`);
     }
-    // When maxMode is requested, prefer max-tier variants for effort matching
-    // so "high + max" lands on 1m high rather than the first 300k high.
-    const maxScoped = wantMax ? scoped.filter(isMaxVariant) : [];
-    const effortPool = maxScoped.length > 0 ? maxScoped : scoped;
-    // 2. Effort hint (e.g. user passed reasoningEffort through the CLI).
+    // Choose the tier before preferring non-Fast variants. Otherwise a Fast-only
+    // max tier disappears, or a leading max variant steals an effort-only hint.
+    // isDefaultMax is a preference, not a requirement to run in max mode.
+    const tier = model.variants.filter((v) => variantIsMaxMode(v) === wantMax);
+    const candidates = tier.length > 0 ? tier : model.variants;
+    const nonFast = candidates.filter((v) => !isFast(v));
+    const scoped = nonFast.length > 0 ? nonFast : candidates;
+    // Cursor can declare a Fast variant as a default (Grok, GPT max defaults);
+    // the tier default retains the declared default's effort when its speed
+    // twin is needed (same parameters except `fast`).
+    const byDefault = (wantMax
+        ? findDefaultVariant(model, scoped, true) ?? scoped.find(variantIsMaxMode)
+        : undefined) ?? findDefaultVariant(model, scoped, false) ?? scoped[0];
+    // 2. Effort hint (e.g. user passed reasoningEffort through the CLI). Like
+    // Cursor CLI, break ties toward the tier default so the hint changes only
+    // effort, not thinking or other parameters (Claude lists thinking=false first).
     if (opts.reasoningEffort) {
-        const match = effortPool.find((v) => effortOf(v) === opts.reasoningEffort);
+        const shared = (v) => v.parameterValues.filter((parameter) => byDefault.parameterValues.some((d) => d.id === parameter.id && d.value === parameter.value)).length;
+        const match = scoped
+            .filter((v) => effortOf(v) === opts.reasoningEffort)
+            .reduce((best, v) => best && shared(best) >= shared(v) ? best : v, undefined);
         if (match) {
-            return buildRequestedModelParams(match.parameterValues, {
-                reasoningEffort: opts.reasoningEffort,
-                maxMode: wantMax,
-            });
+            return copyParameters(match.parameterValues);
         }
     }
-    // 3. Max-mode hint → prefer the default max variant (1m context).
-    if (wantMax) {
-        const max = scoped.find((v) => v.isDefaultMax) ?? scoped.find(isLongContextVariant);
-        if (max)
-            return buildRequestedModelParams(max.parameterValues, { maxMode: true });
-    }
-    // 4. Default non-max variant.
-    const byDefault = scoped.find((v) => v.isDefaultNonMax) ?? scoped[0];
-    return buildRequestedModelParams(byDefault.parameterValues, {
-        reasoningEffort: opts.reasoningEffort,
-        maxMode: false,
-    });
+    // 3. Max-mode hint → the default max variant (the max tier).
+    // 4. Otherwise the default non-max variant, else the first candidate.
+    // An unsupported effort must not synthesize a tuple Cursor never advertised.
+    return copyParameters(byDefault.parameterValues);
 }
 // ── Fetch + cache orchestration ──
 export async function fetchModels(token, options = {}) {

package/dist/opencode2/catalog.d.ts

@@ -36,6 +36,7 @@ export type CatalogModelInfo = {
     modelID: string;
     providerID: string;
     name: string;
+    family?: string;
     capabilities: {
         tools: boolean;
         input: string[];

package/dist/opencode2/catalog.js

@@ -69,6 +69,8 @@ export function modelConfigEntryToInfo(id, entry) {
         time: { released: 0 },
         cost: toOpenCode2Costs(entry.cost),
     };
+    if (typeof entry.family === "string" && entry.family.trim())
+        info.family = entry.family.trim();
     if (options)
         info.settings = { ...options };
     return info;

package/dist/opencode2/image-save-tool.d.ts

@@ -0,0 +1,8 @@
+import type { PluginContext, ToolDraft } from "./types.js";
+/**
+ * Register the handle-only image commit tool on the OpenCode 2.0 direct
+ * catalog. Catalog `permission: "edit"` hides it when the host agent denies
+ * edits. Per-call `ask` is used when the runtime context provides it;
+ * otherwise containment still gates the write (opaque `image_id` only).
+ */
+export declare function registerCursorImageSaveTool(draft: ToolDraft, ctx: PluginContext): void;

package/dist/opencode2/image-save-tool.js

@@ -0,0 +1,84 @@
+import { executeCursorImageSave } from "../image-save.js";
+import { cursorImageSaveTool } from "../image-save-tool.js";
+import { CURSOR_IMAGE_SAVE_TOOL } from "../protocol/generate-image.js";
+import { getSessionDirectory } from "../session-directory.js";
+import { hostHasTool, OPENCODE2_DIRECT_TOOL_OPTIONS } from "./todo-tools.js";
+const IMAGE_SAVE_INPUT_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        image_id: {
+            type: "string",
+            description: "Id of the pending Cursor-generated image to save",
+        },
+    },
+    required: ["image_id"],
+};
+const IMAGE_SAVE_OUTPUT_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        path: { type: "string" },
+        bytes: { type: "number" },
+        message: { type: "string" },
+    },
+    required: ["path", "bytes", "message"],
+};
+function toolAsk(context) {
+    if (!context || typeof context !== "object")
+        return undefined;
+    const ask = context.ask;
+    return typeof ask === "function"
+        ? ask
+        : undefined;
+}
+async function workspaceForSession(ctx, sessionID) {
+    const marked = getSessionDirectory(sessionID);
+    if (marked)
+        return marked;
+    try {
+        return (await ctx.session.get({ sessionID })).location.directory;
+    }
+    catch {
+        return ctx.location?.directory || process.cwd();
+    }
+}
+/**
+ * Register the handle-only image commit tool on the OpenCode 2.0 direct
+ * catalog. Catalog `permission: "edit"` hides it when the host agent denies
+ * edits. Per-call `ask` is used when the runtime context provides it;
+ * otherwise containment still gates the write (opaque `image_id` only).
+ */
+export function registerCursorImageSaveTool(draft, ctx) {
+    if (hostHasTool(draft, CURSOR_IMAGE_SAVE_TOOL))
+        return;
+    draft.add({
+        name: CURSOR_IMAGE_SAVE_TOOL,
+        description: cursorImageSaveTool.description,
+        input: IMAGE_SAVE_INPUT_SCHEMA,
+        output: IMAGE_SAVE_OUTPUT_SCHEMA,
+        options: { ...OPENCODE2_DIRECT_TOOL_OPTIONS, permission: "edit" },
+        execute: async (input, context) => {
+            const sessionID = context.sessionID;
+            if (typeof sessionID !== "string" || !sessionID) {
+                throw new Error("OpenCode 2.0 image-save context did not provide a sessionID");
+            }
+            const directory = await workspaceForSession(ctx, sessionID);
+            const result = await executeCursorImageSave({ image_id: input?.image_id }, {
+                worktree: directory,
+                directory,
+                // The public 2.0 ToolContext has no permission prompt; catalog
+                // `permission: "edit"` and containment gate the write instead.
+                ask: toolAsk(context) ?? null,
+            });
+            return {
+                output: {
+                    path: result.title,
+                    bytes: result.bytes,
+                    message: result.output,
+                },
+                content: result.output,
+            };
+        },
+    });
+}

package/dist/opencode2/tool-results.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Preserve native result status before OpenCode's AI SDK lowers errors to text.
+ * Upstream: https://github.com/anomalyco/opencode/blob/v2.0.27/packages/core/src/aisdk.ts#L652-L685
+ * Native part.providerMetadata becomes SDK part.providerOptions (same file, L717-L720).
+ */
+export type ToolRefusal = "permission_denied" | "rejected";
+export type NativeToolFailure = {
+    type: string;
+    text: string;
+    refusal?: ToolRefusal;
+};
+export declare const TOOL_RESULT_STATUS_KEY = "opencodeToolResult";
+export declare function nativeToolFailure(value: unknown, refusal?: ToolRefusal): NativeToolFailure;
+/** The native tool hook preserves the underlying typed permission cause. */
+export declare function nativeToolRefusal(error: unknown): ToolRefusal | undefined;
+/** Metadata travels with each part, including history and independently loaded SDK copies. */
+export declare function preserveNativeToolResults(messages: readonly unknown[] | undefined, refusals?: ReadonlyMap<string, ToolRefusal>): any[];
+export declare function toolResultFailure(options: unknown, callID: string): NativeToolFailure | undefined;

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/opencode2/types.d.ts

@@ -43,6 +43,7 @@ export type ModelInfo2 = {
     modelID: string;
     providerID: string;
     name: string;
+    family?: string;
     capabilities: {
         tools: boolean;
         input: readonly string[];
@@ -415,6 +416,19 @@ export type McpEditor = {
 export type McpDomain = {
     readonly transform: Transform<McpEditor>;
 };
+/** Only the fields this plugin reads from a registered skill. */
+export type SkillInfo = {
+    readonly id: string;
+    readonly path: string;
+};
+export type SkillDomain = {
+    readonly list: () => Promise<{
+        readonly location: {
+            readonly directory: string;
+        };
+        readonly data: readonly SkillInfo[];
+    }>;
+};
 export type PluginLocation = {
     readonly directory: string;
 };
@@ -429,6 +443,7 @@ export type PluginContext = {
     readonly shell?: ShellDomain;
     readonly websearch?: WebSearchDomain;
     readonly mcp?: McpDomain;
+    readonly skill?: SkillDomain;
 };
 export type Cleanup = () => Promise<void> | void;
 export type Plugin2 = {

package/dist/parallel-step.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Parallel tool-call step boundary for OpenCode's AI SDK step model.
+ *
+ * Cursor fires execs as they are generated; CLI demuxes them concurrently and
+ * has no step boundary. OpenCode needs one `finish: tool-calls` after every
+ * call of the generation. Cursor's `tool_requests_listed` (InteractionUpdate
+ * field 27) carries that count. See tasks/plans/parallel-tool-calls-cli-parity.md.
+ */
+/** Idle without a progress frame while holding → close the step (ms). */
+export declare const PARALLEL_STEP_IDLE_MS = 1500;
+export type ParallelStepState = {
+    /** From field 27; undefined until Cursor lists the count for this step. */
+    listedCount?: number;
+    /** Model tool_call_ids seen this step. */
+    callIds: Set<string>;
+    /** Ids with a final client disposition this step. */
+    resolved: Set<string>;
+    /** Host tool-call parts emitted this step. */
+    emitted: number;
+    /** Wall time of the last progress frame (for the liveness guard). */
+    lastProgressAt: number;
+};
+export declare function noteToolRequestsListedSeen(): void;
+export declare function hasSeenToolRequestsListed(): boolean;
+/** Test-only: reset the process capability gate. */
+export declare function resetToolRequestsListedSeenForTests(): void;
+export declare function createParallelStep(now?: number): ParallelStepState;
+export declare function noteParallelStepProgress(step: ParallelStepState, now?: number): void;
+export declare function noteListedCallCount(step: ParallelStepState, callCount: number, now?: number): void;
+/**
+ * Record a final disposition for `callId`. Returns true when newly resolved.
+ * Empty ids are ignored. Prior-step ids in `prior` are ignored.
+ */
+export declare function resolveParallelStepCall(step: ParallelStepState, callId: string | undefined, prior?: ReadonlySet<string>, now?: number): boolean;
+export declare function recordParallelStepEmission(step: ParallelStepState, now?: number): void;
+/** True when the listed count is known and every listed call is resolved. */
+export declare function parallelStepCountMet(step: ParallelStepState): boolean;
+/**
+ * Whether to keep pumping for more calls of this step instead of finishing.
+ *
+ * - Gate off and no count yet → do not hold (today's one-call finish).
+ * - Human-gated interaction with unknown count → do not hold (prompt must show).
+ * - Otherwise hold until the count is met (or the liveness guard fires).
+ */
+export declare function shouldHoldParallelStep(step: ParallelStepState, options?: {
+    fieldSeen?: boolean;
+    humanGatedWithoutCount?: boolean;
+}): boolean;
+/** True when the hold has made no progress for `idleMs`. */
+export declare function shouldGuardCloseParallelStep(step: ParallelStepState, now?: number, idleMs?: number): boolean;
+/**
+ * Frames that reset the liveness guard while holding. Heartbeat, KV, and
+ * checkpoint are not progress — they say nothing about further tool calls.
+ */
+export declare function isParallelStepProgressFrame(kinds: {
+    toolRequestsListed?: boolean;
+    partialToolCall?: boolean;
+    toolCallDelta?: boolean;
+    toolCallStarted?: boolean;
+    toolCallCompleted?: boolean;
+    exec?: boolean;
+    interactionQuery?: boolean;
+    textDelta?: boolean;
+    thinkingDelta?: boolean;
+}): boolean;