cursor-opencode-provider 0.2.9 → 0.3.1

package/dist/shell-timeout.js

@@ -213,7 +213,7 @@ function ensureShellEnvWrap(toolCallId, policy) {
  * The classic hook replaces it with the original command (bash/zsh) or the
  * shorter wrapper-file command (sh/dash), avoiding duplicate execution.
  */
-export function prepareCursorShellArgs(toolCallId, args) {
+export function prepareCursorShellArgs(toolCallId, args, options = {}) {
     const policy = policies.get(toolCallId);
     if (!policy)
         return;
@@ -226,7 +226,11 @@ export function prepareCursorShellArgs(toolCallId, args) {
         args.timeout = Math.max(OPENCODE_TIMEOUT_GRACE_MS, policy.timeoutMs + OPENCODE_TIMEOUT_GRACE_MS);
     }
     const shellKind = resolveCursorShellKind();
-    if (process.platform === "win32" || shellKind === "bash" || shellKind === "zsh") {
+    // OpenCode 2.0 has no `shell.env` hook, so bash/zsh cannot be wrapped by
+    // sourcing an injector. Callers there opt into the wrapper-file command —
+    // the same mechanism sh/dash already use — which needs no env injection.
+    const envInjectable = !options.preferWrapperCommand && (shellKind === "bash" || shellKind === "zsh");
+    if (process.platform === "win32" || envInjectable) {
         // Native Windows PowerShell/cmd wrapping remains unsupported; do not emit
         // a POSIX /bin/sh command there. Git Bash still uses the env path above.
         args.command = policy.command;
@@ -318,8 +322,12 @@ function lastPrivateMarker(output, marker, valuePattern) {
     return last;
 }
 function parseOpenCodeTimeout(output) {
-    const re = /<shell_metadata>\r?\nshell tool terminated command after exceeding timeout (\d+) ms\.[\s\S]*?<\/shell_metadata>\s*$/;
-    const match = re.exec(output);
+    const closeTag = "</shell_metadata>";
+    const closeAt = output.lastIndexOf(closeTag);
+    if (closeAt === -1 || output.slice(closeAt + closeTag.length).trim() !== "")
+        return undefined;
+    const header = /<shell_metadata>\r?\nshell tool terminated command after exceeding timeout (\d+) ms\./;
+    const match = header.exec(output.slice(0, closeAt));
     if (!match || match.index === undefined)
         return undefined;
     return { output: withoutMarker(output, match.index), timeoutMs: Number(match[1]) };

package/dist/usage.d.ts

@@ -0,0 +1,30 @@
+import type { LanguageModelV3Usage } from "@ai-sdk/provider";
+/** Non-negative integer counter from a Cursor `turn_ended` field. */
+export declare function turnEndedCounter(te: Record<string, unknown>, key: string): number;
+/**
+ * Map authoritative Cursor TurnEnded counters to AI SDK V3 usage (Kilo/OpenCode
+ * flatten via input total = noCache + cacheRead + cacheWrite).
+ *
+ * Contract: `input_tokens` is non-cached input; cache fields are separate.
+ * Cursor's agent wire currently sends `cache_write=0` even when later turns
+ * report large `cache_read`; we still forward the counter when non-zero.
+ * If production semantics differ (input_tokens already total), adjust here.
+ */
+export declare function buildLanguageModelV3UsageFromTurnEnded(te: Record<string, unknown>): LanguageModelV3Usage;
+export type CursorUsageEstimate = {
+    inputTokens: number;
+    outputTokens: number;
+    cacheRead: number;
+    cacheWrite: number;
+    reasoningTokens: number;
+};
+/** Mid-turn finish (e.g. tool-calls) before `turn_ended` — keep non-zero estimates. */
+export declare function buildLanguageModelV3UsageFromEstimate(est: CursorUsageEstimate, promptTokens: number, outputChars: number, estimateCharsToTokens: (chars: number) => number): LanguageModelV3Usage;
+/** Mirror Kilo `Session.getUsage` / AI SDK flat fields from V3 nested usage. */
+export declare function kiloShapedUsageFromV3(usage: LanguageModelV3Usage): {
+    inputTokens: number;
+    outputTokens: number;
+    reasoningTokens: number;
+    cacheReadInputTokens: number;
+    cacheWriteInputTokens: number;
+};

package/dist/usage.js

@@ -0,0 +1,77 @@
+/** Non-negative integer counter from a Cursor `turn_ended` field. */
+export function turnEndedCounter(te, key) {
+    const value = te[key];
+    return typeof value === "number" && Number.isFinite(value) && value >= 0
+        ? Math.trunc(value)
+        : 0;
+}
+/**
+ * Map authoritative Cursor TurnEnded counters to AI SDK V3 usage (Kilo/OpenCode
+ * flatten via input total = noCache + cacheRead + cacheWrite).
+ *
+ * Contract: `input_tokens` is non-cached input; cache fields are separate.
+ * Cursor's agent wire currently sends `cache_write=0` even when later turns
+ * report large `cache_read`; we still forward the counter when non-zero.
+ * If production semantics differ (input_tokens already total), adjust here.
+ */
+export function buildLanguageModelV3UsageFromTurnEnded(te) {
+    const input_tokens = turnEndedCounter(te, "input_tokens");
+    const output_tokens = turnEndedCounter(te, "output_tokens");
+    const cache_read = turnEndedCounter(te, "cache_read");
+    const cache_write = turnEndedCounter(te, "cache_write");
+    const reasoning_tokens = turnEndedCounter(te, "reasoning_tokens");
+    return {
+        inputTokens: {
+            total: input_tokens + cache_read + cache_write,
+            noCache: input_tokens,
+            cacheRead: cache_read,
+            cacheWrite: cache_write,
+        },
+        outputTokens: {
+            total: output_tokens + reasoning_tokens,
+            text: output_tokens,
+            reasoning: reasoning_tokens,
+        },
+    };
+}
+/** Mid-turn finish (e.g. tool-calls) before `turn_ended` — keep non-zero estimates. */
+export function buildLanguageModelV3UsageFromEstimate(est, promptTokens, outputChars, estimateCharsToTokens) {
+    const hasInputBreakdown = est.cacheRead > 0 || est.cacheWrite > 0 || est.inputTokens > 0;
+    const inputNoCache = hasInputBreakdown ? est.inputTokens : promptTokens;
+    const cacheRead = est.cacheRead;
+    const cacheWrite = est.cacheWrite;
+    const outputFromChars = estimateCharsToTokens(outputChars);
+    const outputText = est.outputTokens > 0 ? est.outputTokens : outputFromChars;
+    const reasoning = est.reasoningTokens;
+    const outputTotal = outputText + reasoning;
+    return {
+        inputTokens: {
+            total: inputNoCache + cacheRead + cacheWrite,
+            noCache: inputNoCache,
+            cacheRead,
+            cacheWrite,
+        },
+        outputTokens: {
+            total: outputTotal,
+            text: outputText,
+            reasoning: reasoning > 0 ? reasoning : undefined,
+        },
+    };
+}
+/** Mirror Kilo `Session.getUsage` / AI SDK flat fields from V3 nested usage. */
+export function kiloShapedUsageFromV3(usage) {
+    const input = usage.inputTokens;
+    const output = usage.outputTokens;
+    const noCache = input.noCache ?? 0;
+    const cacheRead = input.cacheRead ?? 0;
+    const cacheWrite = input.cacheWrite ?? 0;
+    const reasoning = output.reasoning ?? 0;
+    const text = output.text ?? Math.max(0, (output.total ?? 0) - reasoning);
+    return {
+        inputTokens: noCache,
+        outputTokens: text,
+        reasoningTokens: reasoning,
+        cacheReadInputTokens: cacheRead,
+        cacheWriteInputTokens: cacheWrite,
+    };
+}

package/dist/web-search-tool.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Classic-plugin web search tool registration.
+ *
+ * Kept apart from `./web-tools.ts` on purpose: this is a *value* import from
+ * `@opencode-ai/plugin`, and the OpenCode 2.0 entrypoint shares the search
+ * implementation in that module. 2.0's package root exports no `tool`, so
+ * importing it from a module on the 2.0 graph would throw during plugin load.
+ * Only `plugin.ts` (classic hooks) may import this file.
+ */
+export declare const openCodeWebSearchTool: {
+    description: string;
+    args: {
+        query: import("zod").ZodString;
+        numResults: import("zod").ZodOptional<import("zod").ZodNumber>;
+        livecrawl: import("zod").ZodOptional<import("zod").ZodEnum<{
+            fallback: "fallback";
+            preferred: "preferred";
+        }>>;
+        type: import("zod").ZodOptional<import("zod").ZodEnum<{
+            fast: "fast";
+            auto: "auto";
+            deep: "deep";
+        }>>;
+        contextMaxCharacters: import("zod").ZodOptional<import("zod").ZodNumber>;
+    };
+    execute(args: {
+        query: string;
+        numResults?: number | undefined;
+        livecrawl?: "fallback" | "preferred" | undefined;
+        type?: "fast" | "auto" | "deep" | undefined;
+        contextMaxCharacters?: number | undefined;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+};

package/dist/web-search-tool.js

@@ -0,0 +1,22 @@
+import { tool } from "@opencode-ai/plugin";
+import { executeOpenCodeWebSearch } from "./web-tools.js";
+/**
+ * Classic-plugin web search tool registration.
+ *
+ * Kept apart from `./web-tools.ts` on purpose: this is a *value* import from
+ * `@opencode-ai/plugin`, and the OpenCode 2.0 entrypoint shares the search
+ * implementation in that module. 2.0's package root exports no `tool`, so
+ * importing it from a module on the 2.0 graph would throw during plugin load.
+ * Only `plugin.ts` (classic hooks) may import this file.
+ */
+export const openCodeWebSearchTool = tool({
+    description: "Search the web for current information using OpenCode's web search backend.",
+    args: {
+        query: tool.schema.string().describe("Web search query"),
+        numResults: tool.schema.number().int().min(1).max(20).optional(),
+        livecrawl: tool.schema.enum(["fallback", "preferred"]).optional(),
+        type: tool.schema.enum(["auto", "fast", "deep"]).optional(),
+        contextMaxCharacters: tool.schema.number().int().positive().optional(),
+    },
+    execute: executeOpenCodeWebSearch,
+});

package/dist/web-tools.d.ts

@@ -1,4 +1,4 @@
-import { type ToolContext, type ToolResult } from "@opencode-ai/plugin";
+import type { ToolContext, ToolResult } from "@opencode-ai/plugin";
 export type OpenCodeWebSearchArgs = {
     query: string;
     numResults?: number;
@@ -7,28 +7,12 @@ export type OpenCodeWebSearchArgs = {
     contextMaxCharacters?: number;
 };
 export declare function parseOpenCodeWebSearchResponse(raw: string): string | undefined;
+/**
+ * Raw Exa web-search call: no host tool context, no permission prompt.
+ *
+ * Split out so both the classic plugin's `custom_websearch` tool and the
+ * OpenCode 2.0 plugin's tool registration share one implementation — 2.0's
+ * ToolContext has no `ask`, permissions being handled by the host instead.
+ */
+export declare function fetchOpenCodeWebSearchText(args: OpenCodeWebSearchArgs, signal: AbortSignal | undefined, fetchImpl?: typeof fetch): Promise<string>;
 export declare function executeOpenCodeWebSearch(args: OpenCodeWebSearchArgs, context: ToolContext, fetchImpl?: typeof fetch): Promise<ToolResult>;
-export declare const openCodeWebSearchTool: {
-    description: string;
-    args: {
-        query: import("zod").ZodString;
-        numResults: import("zod").ZodOptional<import("zod").ZodNumber>;
-        livecrawl: import("zod").ZodOptional<import("zod").ZodEnum<{
-            fallback: "fallback";
-            preferred: "preferred";
-        }>>;
-        type: import("zod").ZodOptional<import("zod").ZodEnum<{
-            fast: "fast";
-            auto: "auto";
-            deep: "deep";
-        }>>;
-        contextMaxCharacters: import("zod").ZodOptional<import("zod").ZodNumber>;
-    };
-    execute(args: {
-        query: string;
-        numResults?: number | undefined;
-        livecrawl?: "fallback" | "preferred" | undefined;
-        type?: "fast" | "auto" | "deep" | undefined;
-        contextMaxCharacters?: number | undefined;
-    }, context: ToolContext): Promise<ToolResult>;
-};

package/dist/web-tools.js

@@ -1,4 +1,3 @@
-import { tool } from "@opencode-ai/plugin";
 const EXA_MCP_URL = "https://mcp.exa.ai/mcp";
 const WEB_SEARCH_TIMEOUT_MS = 25_000;
 function exaMcpUrl() {
@@ -54,26 +53,20 @@ export function parseOpenCodeWebSearchResponse(raw) {
     }
     return undefined;
 }
-export async function executeOpenCodeWebSearch(args, context, fetchImpl = fetch) {
-    await context.ask({
-        permission: "websearch",
-        patterns: [args.query],
-        always: ["*"],
-        metadata: {
-            query: args.query,
-            numResults: args.numResults,
-            livecrawl: args.livecrawl,
-            type: args.type,
-            contextMaxCharacters: args.contextMaxCharacters,
-            provider: "exa",
-        },
-    });
+/**
+ * Raw Exa web-search call: no host tool context, no permission prompt.
+ *
+ * Split out so both the classic plugin's `custom_websearch` tool and the
+ * OpenCode 2.0 plugin's tool registration share one implementation — 2.0's
+ * ToolContext has no `ask`, permissions being handled by the host instead.
+ */
+export async function fetchOpenCodeWebSearchText(args, signal, fetchImpl = fetch) {
     const controller = new AbortController();
-    const abort = () => controller.abort(context.abort.reason);
-    if (context.abort.aborted)
+    const abort = () => controller.abort(signal?.reason);
+    if (signal?.aborted)
         abort();
     else
-        context.abort.addEventListener("abort", abort, { once: true });
+        signal?.addEventListener("abort", abort, { once: true });
     const timeout = setTimeout(() => controller.abort(new Error("Web search timed out")), WEB_SEARCH_TIMEOUT_MS);
     try {
         const response = await fetchImpl(exaMcpUrl(), {
@@ -102,26 +95,31 @@ export async function executeOpenCodeWebSearch(args, context, fetchImpl = fetch)
         const raw = await response.text();
         if (!response.ok)
             throw new Error(`Web search failed (${response.status}): ${raw.slice(0, 500)}`);
-        const output = parseOpenCodeWebSearchResponse(raw) ?? "No search results found. Please try a different query.";
-        return {
-            title: `Exa Web Search: ${args.query}`,
-            output,
-            metadata: { provider: "exa" },
-        };
+        return parseOpenCodeWebSearchResponse(raw) ?? "No search results found. Please try a different query.";
     }
     finally {
         clearTimeout(timeout);
-        context.abort.removeEventListener("abort", abort);
+        signal?.removeEventListener("abort", abort);
     }
 }
-export const openCodeWebSearchTool = tool({
-    description: "Search the web for current information using OpenCode's web search backend.",
-    args: {
-        query: tool.schema.string().describe("Web search query"),
-        numResults: tool.schema.number().int().min(1).max(20).optional(),
-        livecrawl: tool.schema.enum(["fallback", "preferred"]).optional(),
-        type: tool.schema.enum(["auto", "fast", "deep"]).optional(),
-        contextMaxCharacters: tool.schema.number().int().positive().optional(),
-    },
-    execute: executeOpenCodeWebSearch,
-});
+export async function executeOpenCodeWebSearch(args, context, fetchImpl = fetch) {
+    await context.ask({
+        permission: "websearch",
+        patterns: [args.query],
+        always: ["*"],
+        metadata: {
+            query: args.query,
+            numResults: args.numResults,
+            livecrawl: args.livecrawl,
+            type: args.type,
+            contextMaxCharacters: args.contextMaxCharacters,
+            provider: "exa",
+        },
+    });
+    const output = await fetchOpenCodeWebSearchText(args, context.abort, fetchImpl);
+    return {
+        title: `Exa Web Search: ${args.query}`,
+        output,
+        metadata: { provider: "exa" },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-opencode-provider",
-  "version": "0.2.9",
+  "version": "0.3.1",
   "description": "Use Cursor subscription models from OpenCode via Cursor's Connect-RPC agent protocol",
   "type": "module",
   "license": "MIT",
@@ -36,6 +36,10 @@
       "types": "./dist/plugin-v2.d.ts",
       "import": "./dist/plugin-v2.js"
     },
+    "./plugin/opencode2": {
+      "types": "./dist/plugin-opencode2.d.ts",
+      "import": "./dist/plugin-opencode2.js"
+    },
     "./errors": {
       "types": "./dist/errors.d.ts",
       "import": "./dist/errors.js"
@@ -50,15 +54,15 @@
   ],
   "scripts": {
     "build": "tsc",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc --noEmit && tsc -p tsconfig.test.json",
     "test": "bun test",
     "test:node-http2": "bun run build && node test/node-http2-cleanup.mjs",
     "test:watch": "bun test --watch",
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@ai-sdk/provider": "3.0.8",
-    "protobufjs": "^7.4.0"
+    "@ai-sdk/provider": "3.0.14",
+    "protobufjs": "^7.6.5"
   },
   "peerDependencies": {
     "@opencode-ai/plugin": "^1.17.13",
@@ -70,9 +74,10 @@
     }
   },
   "devDependencies": {
-    "@opencode-ai/plugin": "^1.17.13",
-    "@tsconfig/node22": "^22.0.1",
-    "@types/node": "^22.15.3",
-    "typescript": "^5.8.3"
+    "@opencode-ai/plugin": "^1.18.13",
+    "@opencode-ai/plugin-next": "npm:@opencode-ai/plugin@0.0.0-next-16281",
+    "@tsconfig/node22": "^22.0.5",
+    "@types/node": "^22.20.1",
+    "typescript": "^5.9.3"
   }
-}
+}