@stablekernel/opencode-cursor 0.4.6 → 0.5.0-next.0

package/dist/provider/index.js

@@ -1,5 +1,7 @@
 import {
   acquireAgent,
+  addUsage,
+  classifyError,
   dropSessionRecord,
   extractSystemText,
   getSessionRecord,
@@ -7,8 +9,9 @@ import {
   resolveCursorApiKey,
   resolveSystemDelivery,
   sendAgentTurnSilently,
+  setPreferredTransport,
   streamAgentTurn
-} from "../chunk-734L3SKU.js";
+} from "../chunk-LAOFD3JB.js";
 
 // src/provider/index.ts
 import { NoSuchModelError } from "@ai-sdk/provider";
@@ -420,6 +423,26 @@ var NATIVE_ADAPTERS = {
       };
     }
   },
+  // Cursor `semSearch` has no opencode counterpart — format-only: query title
+  // + results body instead of the raw `{results}` JSON.
+  semSearch: {
+    input: (args) => {
+      const out = { query: strField(args, "query") ?? "" };
+      const dirs = isRecord(args) && Array.isArray(args["targetDirectories"]) ? args["targetDirectories"] : void 0;
+      if (dirs && dirs.length > 0) out["targetDirectories"] = dirs;
+      return out;
+    },
+    result: (value, args) => {
+      const query = strField(args, "query") ?? "";
+      const results = strField(value, "results") ?? "";
+      const count = results ? results.split("\n").filter((l) => l.trim().length > 0).length : 0;
+      return {
+        title: query,
+        metadata: { matches: count, truncated: false },
+        output: results || "No results"
+      };
+    }
+  },
   // Cursor `ls` → opencode `list` (flatten the directory tree into paths).
   ls: {
     tool: "list",
@@ -589,7 +612,39 @@ function editResultFields(id, filePath, diff, result) {
   };
 }
 function newBlockToolState() {
-  return { open: /* @__PURE__ */ new Map(), pendingEdits: /* @__PURE__ */ new Map(), dropped: /* @__PURE__ */ new Set() };
+  return {
+    open: /* @__PURE__ */ new Map(),
+    pendingEdits: /* @__PURE__ */ new Map(),
+    dropped: /* @__PURE__ */ new Set(),
+    partials: /* @__PURE__ */ new Map(),
+    planText: /* @__PURE__ */ new Map()
+  };
+}
+function resolveToolName(name, input) {
+  const adapter = resolveAdapter(name, input);
+  return {
+    toolName: adapter?.tool ?? blockToolName(name),
+    ...adapter ? { adapter } : {}
+  };
+}
+function blockToolInputPartialParts(id, name, input, state) {
+  if (process.env["OPENCODE_CURSOR_TOOL_INPUT_STREAM"] === "0") return [];
+  const serialized = safeJsonString(input);
+  const prev = state.partials.get(id);
+  const toolName = prev?.toolName ?? resolveToolName(name, input).toolName;
+  state.partials.set(id, { toolName, serialized });
+  const parts = [];
+  if (!prev)
+    parts.push({
+      type: "tool-input-start",
+      id,
+      toolName,
+      providerExecuted: true,
+      dynamic: true
+    });
+  const delta = prev && serialized.startsWith(prev.serialized) ? serialized.slice(prev.serialized.length) : serialized;
+  if (delta) parts.push({ type: "tool-input-delta", id, delta });
+  return parts;
 }
 function blockToolCallParts(id, name, input, state) {
   if (name === EDIT_TOOL_NAME) {
@@ -649,6 +704,20 @@ function blockDanglingParts(state) {
     parts.push(toolResultObj(id, EDIT_TOOL_NAME, DANGLING_TOOL_RESULT, true));
   }
   state.pendingEdits.clear();
+  for (const [id, partial] of state.partials) {
+    parts.push({ type: "tool-input-end", id });
+    let args = {};
+    try {
+      args = JSON.parse(partial.serialized);
+    } catch {
+      args = {};
+    }
+    parts.push(nativeToolCall(id, partial.toolName, args));
+    parts.push(
+      nativeToolResult(id, partial.toolName, DANGLING_TOOL_RESULT, true)
+    );
+  }
+  state.partials.clear();
   return parts;
 }
 var EMPTY_USAGE = {
@@ -699,6 +768,8 @@ function cursorEventsToStream(events, toolDisplay = "blocks") {
       let reasoningCount = 0;
       let usage;
       let streamedText = false;
+      let thinkingMs = 0;
+      let compactions = 0;
       const toolState = newBlockToolState();
       const closeDanglingToolCalls = () => {
         for (const part of blockDanglingParts(toolState)) {
@@ -754,22 +825,61 @@ function cursorEventsToStream(events, toolDisplay = "blocks") {
             case "reasoning-delta":
               reasoningLine(event.text);
               break;
+            case "tool-input-partial":
+              if (isCreatePlanTool(event.name)) {
+                const plan = createPlanContent(event.input) ?? "";
+                const prevPlan = toolState.planText.get(event.id) ?? "";
+                if (plan.length > prevPlan.length) {
+                  closeReasoning();
+                  streamedText = true;
+                  controller.enqueue({
+                    type: "text-delta",
+                    id: ensureText(),
+                    delta: plan.slice(prevPlan.length)
+                  });
+                }
+                toolState.planText.set(event.id, plan);
+                toolState.dropped.add(event.id);
+                break;
+              }
+              if (toolDisplay === "blocks" && event.name !== EDIT_TOOL_NAME) {
+                const parts = blockToolInputPartialParts(
+                  event.id,
+                  event.name,
+                  event.input,
+                  toolState
+                );
+                if (parts.length > 0) {
+                  closeText();
+                  closeReasoning();
+                }
+                for (const part of parts) controller.enqueue(part);
+              }
+              break;
             case "tool-call":
               if (isCreatePlanTool(event.name)) {
-                const plan = createPlanContent(event.input);
-                if (plan) {
+                const plan = createPlanContent(event.input) ?? "";
+                const prevPlan = toolState.planText.get(event.id) ?? "";
+                if (plan.length > prevPlan.length) {
                   closeReasoning();
                   streamedText = true;
                   controller.enqueue({
                     type: "text-delta",
                     id: ensureText(),
-                    delta: plan
+                    delta: plan.slice(prevPlan.length)
                   });
                 }
+                toolState.planText.set(event.id, plan);
                 toolState.dropped.add(event.id);
                 break;
               }
               if (toolDisplay === "blocks") {
+                if (toolState.partials.delete(event.id)) {
+                  controller.enqueue({
+                    type: "tool-input-end",
+                    id: event.id
+                  });
+                }
                 const parts = blockToolCallParts(
                   event.id,
                   event.name,
@@ -814,6 +924,14 @@ ${formatToolCall(event.name, event.input)}
             case "usage":
               usage = mapUsage(event.usage);
               break;
+            case "reasoning-complete":
+              closeReasoning();
+              if (typeof event.durationMs === "number")
+                thinkingMs += event.durationMs;
+              break;
+            case "compaction":
+              compactions++;
+              break;
             case "finish":
               if (!streamedText && event.text) {
                 controller.enqueue({
@@ -828,22 +946,34 @@ ${formatToolCall(event.name, event.input)}
         closeDanglingToolCalls();
         closeReasoning();
         closeText();
-        controller.enqueue({
-          type: "finish",
-          usage: usage ?? EMPTY_USAGE,
-          finishReason: FINISH_STOP
-        });
+        {
+          const cursorMeta = {};
+          if (thinkingMs > 0) cursorMeta["thinkingDurationMs"] = thinkingMs;
+          if (compactions > 0) cursorMeta["compactions"] = compactions;
+          controller.enqueue({
+            type: "finish",
+            usage: usage ?? EMPTY_USAGE,
+            finishReason: FINISH_STOP,
+            ...Object.keys(cursorMeta).length > 0 ? { providerMetadata: { cursor: cursorMeta } } : {}
+          });
+        }
         controller.close();
       } catch (err) {
         controller.enqueue({ type: "error", error: err });
         closeDanglingToolCalls();
         closeReasoning();
         closeText();
-        controller.enqueue({
-          type: "finish",
-          usage: usage ?? EMPTY_USAGE,
-          finishReason: FINISH_ERROR
-        });
+        {
+          const cursorMeta = {};
+          if (thinkingMs > 0) cursorMeta["thinkingDurationMs"] = thinkingMs;
+          if (compactions > 0) cursorMeta["compactions"] = compactions;
+          controller.enqueue({
+            type: "finish",
+            usage: usage ?? EMPTY_USAGE,
+            finishReason: FINISH_ERROR,
+            ...Object.keys(cursorMeta).length > 0 ? { providerMetadata: { cursor: cursorMeta } } : {}
+          });
+        }
         controller.close();
       }
     }
@@ -866,6 +996,8 @@ async function cursorEventsToContent(events, toolDisplay = "blocks") {
         case "reasoning-delta":
           reasoning += event.text;
           break;
+        case "tool-input-partial":
+          break;
         case "tool-call":
           if (isCreatePlanTool(event.name)) {
             const plan = createPlanContent(event.input);
@@ -908,6 +1040,10 @@ ${formatToolCall(event.name, event.input)}
         case "usage":
           usage = mapUsage(event.usage);
           break;
+        case "reasoning-complete":
+          break;
+        case "compaction":
+          break;
         case "finish":
           if (!text && event.text) text = event.text;
           break;
@@ -978,6 +1114,9 @@ function classifyTurn(prev, prompt) {
   }
   return { kind: "divergence", fingerprint: fp };
 }
+function sendIdempotencyKey(sessionID, record, messageText) {
+  return createHash("sha256").update(`${sessionID ?? "ephemeral"}|${record?.userHashes.join(",") ?? ""}|${messageText}`).digest("hex").slice(0, 32);
+}
 
 // src/provider/language-model.ts
 var CursorLanguageModel = class {
@@ -1014,9 +1153,18 @@ var CursorLanguageModel = class {
     const providerOptions = options.providerOptions?.[this.provider];
     const { mode, modelSelection } = resolveControls(
       this.modelId,
-      { mode: this.config.mode, params: this.config.params },
+      {
+        mode: this.config.mode,
+        params: this.config.params,
+        defaults: this.config.modelParamDefaults?.[this.modelId]
+      },
       providerOptions
     );
+    if (process.env["OPENCODE_CURSOR_DEBUG"] === "1") {
+      console.error(
+        `[cursor:debug] model=${this.modelId} selection=${JSON.stringify(modelSelection)}`
+      );
+    }
     const sessionID = typeof providerOptions?.["sessionID"] === "string" ? providerOptions["sessionID"] : void 0;
     const dynamicMcp = providerOptions?.["mcpServers"];
     const mcpServers = dynamicMcp ?? this.config.mcpServers;
@@ -1072,6 +1220,12 @@ var CursorLanguageModel = class {
         resumeAgentId = void 0;
       }
     }
+    const latestUser = latestUserMessage(options.prompt);
+    const idempotencyKey = sendIdempotencyKey(
+      sessionID,
+      record,
+      latestUser?.text ?? JSON.stringify(options.prompt)
+    );
     const delivery = resolveSystemDelivery({
       mode: this.config.systemPrompt ?? "rules",
       settingSources: this.config.settingSources,
@@ -1088,6 +1242,7 @@ var CursorLanguageModel = class {
       cwd: this.config.cwd,
       ...settingSources ? { settingSources } : {},
       ...this.config.sandbox !== void 0 ? { sandbox: this.config.sandbox } : {},
+      ...this.config.autoReview !== void 0 ? { autoReview: this.config.autoReview } : {},
       ...mcpServers ? { mcpServers } : {},
       ...this.config.agents ? { agents: this.config.agents } : {},
       ...poolKey ? { name: `opencode/${sessionID.slice(-8)}` } : {},
@@ -1105,21 +1260,45 @@ var CursorLanguageModel = class {
         let delivered = false;
         try {
           let aborted = false;
+          let replayUsage;
           for (let i = 0; i < multiTurns.length - 1; i++) {
             if (options.abortSignal?.aborted) {
               aborted = true;
               break;
             }
-            await sendAgentTurnSilently(acquired.agent, multiTurns[i], {
-              mode,
-              abortSignal: options.abortSignal
-            });
+            replayUsage = addUsage(
+              replayUsage,
+              await sendAgentTurnSilently(acquired.agent, multiTurns[i], {
+                mode,
+                abortSignal: options.abortSignal,
+                idempotencyKey: sendIdempotencyKey(
+                  sessionID,
+                  { userHashes: [...record?.userHashes ?? [], String(i)] },
+                  multiTurns[i].text
+                )
+              })
+            );
           }
           if (!aborted && !options.abortSignal?.aborted) {
             for await (const event of streamAgentTurn(
               acquired.agent,
               multiTurns[multiTurns.length - 1],
-              { mode, abortSignal: options.abortSignal }
+              {
+                mode,
+                abortSignal: options.abortSignal,
+                // Key intentionally diverges from the single-turn key: the multi-replay and single-turn branches are mutually exclusive.
+                idempotencyKey: sendIdempotencyKey(
+                  sessionID,
+                  {
+                    userHashes: [
+                      ...record?.userHashes ?? [],
+                      String(multiTurns.length - 1)
+                    ]
+                  },
+                  multiTurns[multiTurns.length - 1].text
+                ),
+                ...replayUsage ? { usageBase: replayUsage } : {}
+              }
             )) {
               yielded = true;
               yield event;
@@ -1134,13 +1313,22 @@ var CursorLanguageModel = class {
         try {
           for await (const event of streamAgentTurn(acquired.agent, message, {
             mode,
-            abortSignal: options.abortSignal
+            abortSignal: options.abortSignal,
+            idempotencyKey
           })) {
             yielded = true;
             yield event;
           }
         } catch (err) {
-          if (acquired.resumed && !yielded && !options.abortSignal?.aborted) {
+          const classified = classifyError(err);
+          if (classified.kind === "auth" || classified.kind === "config") {
+            throw classified.helpUrl ? new Error(
+              `${classified.message} (see ${classified.helpUrl})`,
+              { cause: err }
+            ) : err;
+          }
+          const replayable = classified.kind === "agent-not-found" || classified.kind === "rate-limit" || classified.kind === "network" || classified.kind === "unknown";
+          if (replayable && acquired.resumed && !yielded && !options.abortSignal?.aborted) {
             if (process.env["OPENCODE_CURSOR_DEBUG"] === "1") {
               console.error(
                 "[cursor:debug] resumed turn failed before emitting; retrying with a fresh agent"
@@ -1166,7 +1354,8 @@ var CursorLanguageModel = class {
               const replay = promptToCursorMessage(options.prompt, systemMode);
               yield* streamAgentTurn(retry.agent, replay, {
                 mode,
-                abortSignal: options.abortSignal
+                abortSignal: options.abortSignal,
+                idempotencyKey
               });
             } finally {
               retry.release();
@@ -1199,6 +1388,7 @@ var CursorLanguageModel = class {
 
 // src/provider/index.ts
 function createCursor(options = {}) {
+  if (options.transport) setPreferredTransport(options.transport);
   const mcpServers = options.mcpServers && Object.keys(options.mcpServers).length > 0 ? options.mcpServers : void 0;
   const config = {
     providerName: options.name ?? "cursor",
@@ -1206,9 +1396,11 @@ function createCursor(options = {}) {
     cwd: options.cwd ?? process.cwd(),
     mode: options.mode ?? "agent",
     ...options.params ? { params: options.params } : {},
+    ...options.modelParamDefaults ? { modelParamDefaults: options.modelParamDefaults } : {},
     ...mcpServers ? { mcpServers } : {},
     ...options.settingSources ? { settingSources: options.settingSources } : {},
     ...options.sandbox !== void 0 ? { sandbox: options.sandbox } : {},
+    ...options.autoReview !== void 0 ? { autoReview: options.autoReview } : {},
     ...options.agents ? { agents: options.agents } : {},
     session: options.session ?? "auto",
     toolDisplay: options.toolDisplay ?? "blocks",