@stablekernel/opencode-cursor 0.1.0-rc.2 → 0.2.0

package/dist/provider/index.js

@@ -93,8 +93,14 @@ function latestUserMessage(prompt) {
 }
 
 // src/provider/stream-map.ts
-var FINISH_STOP = { unified: "stop", raw: void 0 };
-var FINISH_ERROR = { unified: "error", raw: void 0 };
+var FINISH_STOP = {
+  unified: "stop",
+  raw: void 0
+};
+var FINISH_ERROR = {
+  unified: "error",
+  raw: void 0
+};
 function safeJsonString(input) {
   try {
     return typeof input === "string" ? input : JSON.stringify(input ?? {});
@@ -105,50 +111,488 @@ function safeJsonString(input) {
 function blockToolName(name) {
   return `cursor_${name.replace(/[^A-Za-z0-9_-]/g, "_")}`;
 }
-function toolCallPart(id, name, input) {
+function nativeToolCall(id, toolName, input) {
   return {
     type: "tool-call",
     toolCallId: id,
-    toolName: blockToolName(name),
+    toolName,
     input: safeJsonString(input),
     providerExecuted: true,
     dynamic: true
   };
 }
-function toolResultPart(id, name, result, isError) {
+function nativeToolResult(id, toolName, result, isError) {
   return {
     type: "tool-result",
     toolCallId: id,
-    toolName: blockToolName(name),
+    toolName,
     result: result ?? null,
     isError,
     providerExecuted: true,
     dynamic: true
   };
 }
-function toolCallContent(id, name, input) {
+function toolCallObj(id, name, input) {
+  return nativeToolCall(id, blockToolName(name), input);
+}
+function toolResultObj(id, name, result, isError) {
+  return nativeToolResult(id, blockToolName(name), result, isError);
+}
+var EDIT_TOOL_NAME = "edit";
+function isRecord(v) {
+  return typeof v === "object" && v !== null;
+}
+function strField(v, key) {
+  return isRecord(v) && typeof v[key] === "string" ? v[key] : void 0;
+}
+function numField(v, key) {
+  return isRecord(v) && typeof v[key] === "number" ? v[key] : void 0;
+}
+function successValue(result) {
+  return isRecord(result) && result["status"] === "success" ? result["value"] : void 0;
+}
+function flattenMcpContent(value) {
+  if (!isRecord(value) || !Array.isArray(value["content"])) return null;
+  const parts = value["content"].flatMap((item) => {
+    const text = isRecord(item) ? strField(item["text"], "text") : void 0;
+    if (text !== void 0) return [text];
+    if (isRecord(item) && isRecord(item["image"])) return ["[image]"];
+    return [];
+  });
+  return parts.join("\n");
+}
+function mcpFold(result) {
+  const text = flattenMcpContent(successValue(result));
+  if (text === null) return null;
+  return { title: "", metadata: {}, output: text };
+}
+function mcpInputArgs(args) {
+  return isRecord(args) ? args["args"] : void 0;
+}
+function webSearchProvider(args) {
+  const id = (strField(args, "providerIdentifier") ?? "").toLowerCase();
+  if (id.includes("exa")) return "exa";
+  if (id.includes("parallel")) return "parallel";
+  return void 0;
+}
+function isWebSearchName(name) {
+  return /web[_-]?search/i.test(name);
+}
+var WEBSEARCH_ADAPTER = {
+  tool: "websearch",
+  input: (args) => {
+    const query = strField(mcpInputArgs(args), "query");
+    return query !== void 0 ? { query } : {};
+  },
+  result: (value, args) => {
+    const provider = webSearchProvider(args);
+    return {
+      title: "",
+      metadata: provider ? { provider } : {},
+      output: flattenMcpContent(value) ?? ""
+    };
+  }
+};
+function resolveAdapter(name, _input) {
+  const exact = NATIVE_ADAPTERS[name];
+  if (exact) return exact;
+  if (isWebSearchName(name)) return WEBSEARCH_ADAPTER;
+  return void 0;
+}
+function mapTodoStatus(status) {
+  if (status === "inProgress") return "in_progress";
+  return typeof status === "string" ? status : "pending";
+}
+function mapTodos(args) {
+  const todos = isRecord(args) && Array.isArray(args["todos"]) ? args["todos"] : [];
+  return todos.flatMap(
+    (t) => isRecord(t) && typeof t["content"] === "string" ? [
+      {
+        content: t["content"],
+        status: mapTodoStatus(t["status"])
+      }
+    ] : []
+  );
+}
+var NATIVE_ADAPTERS = {
+  // Cursor `shell` → opencode `bash` (console renderer).
+  shell: {
+    tool: "bash",
+    input: (args) => ({ command: strField(args, "command") ?? "" }),
+    result: (value, args) => {
+      if (!isRecord(value)) return null;
+      const command = strField(args, "command") ?? "";
+      const stdout = strField(value, "stdout") ?? "";
+      const stderr = strField(value, "stderr") ?? "";
+      const exit = numField(value, "exitCode");
+      const body = [stdout, stderr].filter((s) => s.length > 0).join("\n");
+      const output = exit !== void 0 && exit !== 0 ? `${body}${body ? "\n" : ""}(exit ${exit})` : body;
+      return {
+        title: command,
+        metadata: { command, output, exit: exit ?? 0 },
+        output
+      };
+    }
+  },
+  // Cursor `read` → opencode `read`.
+  read: {
+    tool: "read",
+    input: (args) => ({ filePath: strField(args, "path") ?? "" }),
+    result: (value, args) => {
+      const content = strField(value, "content");
+      if (content === void 0) return null;
+      const filePath = strField(args, "path") ?? "";
+      const totalLines = numField(value, "totalLines");
+      return {
+        title: filePath,
+        metadata: {
+          preview: content.split("\n").slice(0, 20).join("\n"),
+          loaded: [],
+          ...totalLines !== void 0 ? { totalLines } : {}
+        },
+        output: content
+      };
+    }
+  },
+  // Cursor `write` → opencode `write` (renders input.content as the new file).
+  write: {
+    tool: "write",
+    input: (args) => ({
+      filePath: strField(args, "path") ?? "",
+      content: strField(args, "fileText") ?? ""
+    }),
+    result: (value, args) => {
+      const filePath = strField(args, "path") ?? "";
+      const lines = numField(value, "linesCreated");
+      const output = lines !== void 0 ? `Wrote ${lines} line${lines === 1 ? "" : "s"}.` : "Wrote file successfully.";
+      return {
+        title: filePath,
+        metadata: { diagnostics: {}, filepath: filePath, exists: false },
+        output
+      };
+    }
+  },
+  // Cursor `glob` → opencode `glob`.
+  glob: {
+    tool: "glob",
+    input: (args) => {
+      const pattern = strField(args, "globPattern") ?? "";
+      const dir = strField(args, "targetDirectory");
+      return dir ? { pattern, path: dir } : { pattern };
+    },
+    result: (value) => {
+      if (!isRecord(value) || !Array.isArray(value["files"])) return null;
+      const files = value["files"].filter(
+        (f) => typeof f === "string"
+      );
+      const truncated = value["clientTruncated"] === true || value["ripgrepTruncated"] === true;
+      return {
+        title: "",
+        metadata: { count: files.length, truncated },
+        output: files.length > 0 ? files.join("\n") : "No files found"
+      };
+    }
+  },
+  // Cursor `grep` → opencode `grep` (flatten matches into ripgrep-style text).
+  grep: {
+    tool: "grep",
+    input: (args) => {
+      const out = {
+        pattern: strField(args, "pattern") ?? ""
+      };
+      const p = strField(args, "path");
+      if (p) out["path"] = p;
+      const g = strField(args, "glob");
+      if (g) out["include"] = g;
+      return out;
+    },
+    result: (value) => {
+      if (!isRecord(value)) return null;
+      const unions = [];
+      const ws = value["workspaceResults"];
+      if (isRecord(ws)) unions.push(...Object.values(ws));
+      if (value["activeEditorResult"] !== void 0)
+        unions.push(value["activeEditorResult"]);
+      const lines = [];
+      let total = 0;
+      let current = "";
+      for (const u of unions) {
+        if (!isRecord(u)) continue;
+        const output = u["output"];
+        if (u["type"] === "content" && isRecord(output) && Array.isArray(output["matches"])) {
+          for (const m of output["matches"]) {
+            if (!isRecord(m)) continue;
+            const file = strField(m, "file") ?? "";
+            const line = numField(m, "lineNumber");
+            const text = strField(m, "line") ?? "";
+            if (current !== file) {
+              if (current) lines.push("");
+              current = file;
+              lines.push(`${file}:`);
+            }
+            lines.push(
+              line !== void 0 ? `  Line ${line}: ${text}` : `  ${text}`
+            );
+            total++;
+          }
+        } else if (u["type"] === "files" && isRecord(output) && Array.isArray(output["files"])) {
+          for (const f of output["files"]) {
+            if (typeof f === "string") {
+              lines.push(f);
+              total++;
+            }
+          }
+        }
+      }
+      return {
+        title: "",
+        metadata: { matches: total, truncated: false },
+        output: total > 0 ? [
+          `Found ${total} match${total === 1 ? "" : "es"}`,
+          "",
+          ...lines
+        ].join("\n") : "No matches found"
+      };
+    }
+  },
+  // Cursor `ls` → opencode `list` (flatten the directory tree into paths).
+  ls: {
+    tool: "list",
+    input: (args) => ({ path: strField(args, "path") ?? "" }),
+    result: (value) => {
+      if (!isRecord(value)) return null;
+      const root = value["directoryTreeRoot"];
+      if (!isRecord(root)) return null;
+      const out = [];
+      const walk = (node) => {
+        const base = strField(node, "absPath") ?? "";
+        const files = Array.isArray(node["childrenFiles"]) ? node["childrenFiles"] : [];
+        for (const f of files) {
+          const name = strField(f, "name");
+          if (name) out.push(`${base}/${name}`);
+        }
+        const dirs = Array.isArray(node["childrenDirs"]) ? node["childrenDirs"] : [];
+        for (const d of dirs) {
+          if (!isRecord(d)) continue;
+          out.push(`${strField(d, "absPath") ?? ""}/`);
+          walk(d);
+        }
+      };
+      walk(root);
+      return {
+        title: strField(root, "absPath") ?? "",
+        metadata: {},
+        output: out.length > 0 ? out.join("\n") : "(empty)"
+      };
+    }
+  },
+  // Cursor `updateTodos` → opencode `todowrite` (todo checklist renderer).
+  updateTodos: {
+    tool: "todowrite",
+    input: (args) => ({ todos: mapTodos(args) }),
+    result: (_value, args) => {
+      const todos = mapTodos(args);
+      const done = todos.filter((t) => t.status === "completed").length;
+      return {
+        title: `${done}/${todos.length}`,
+        metadata: { todos },
+        output: `Updated ${todos.length} todo${todos.length === 1 ? "" : "s"}.`
+      };
+    }
+  },
+  // Cursor `task` (subagent) → opencode `task` (agent card: name + description).
+  // Non-clickable here — the subagent ran inside Cursor, not as an opencode
+  // child session — but the native card reads far better than raw JSON.
+  task: {
+    tool: "task",
+    input: (args) => {
+      const description = strField(args, "description") ?? "";
+      const sub = isRecord(args) ? args["subagentType"] : void 0;
+      const subagent = strField(sub, "name") ?? strField(sub, "kind") ?? void 0;
+      return subagent ? { description, subagent_type: subagent } : { description };
+    },
+    result: (value, args) => {
+      const description = strField(args, "description") ?? "";
+      const suffix = strField(value, "resultSuffix");
+      const background = isRecord(value) && value["isBackground"] === true;
+      return {
+        title: description,
+        metadata: background ? { background: true } : {},
+        output: suffix ?? "Subagent task completed."
+      };
+    }
+  },
+  // Cursor `readLints` has no opencode counterpart — format-only: render the
+  // diagnostics as a readable list instead of dumping the nested JSON.
+  readLints: {
+    input: (args) => {
+      const paths = isRecord(args) && Array.isArray(args["paths"]) ? args["paths"] : [];
+      return { paths };
+    },
+    result: (value) => {
+      const files = isRecord(value) && Array.isArray(value["fileDiagnostics"]) ? value["fileDiagnostics"] : [];
+      const lines = [];
+      let total = 0;
+      for (const file of files) {
+        if (!isRecord(file)) continue;
+        const diags = Array.isArray(file["diagnostics"]) ? file["diagnostics"] : [];
+        if (diags.length === 0) continue;
+        lines.push(`${strField(file, "path") ?? ""}`);
+        for (const d of diags) {
+          if (!isRecord(d)) continue;
+          const severity = strField(d, "severity") ?? "info";
+          const start = isRecord(d["range"]) ? d["range"]["start"] : void 0;
+          const line = numField(start, "line");
+          const char = numField(start, "character");
+          const loc = line !== void 0 ? ` L${line + 1}${char !== void 0 ? `:${char + 1}` : ""}` : "";
+          lines.push(`  ${severity}${loc}: ${strField(d, "message") ?? ""}`);
+          total++;
+        }
+      }
+      return {
+        title: total > 0 ? `${total} problem${total === 1 ? "" : "s"}` : "No problems",
+        metadata: { count: total },
+        output: total > 0 ? lines.join("\n") : "No problems found."
+      };
+    }
+  },
+  // Cursor `delete` has no opencode counterpart — format-only: a one-line
+  // confirmation instead of `{"fileSize":N}`.
+  delete: {
+    input: (args) => ({ path: strField(args, "path") ?? "" }),
+    result: (value, args) => {
+      const path = strField(args, "path") ?? "";
+      const size = numField(value, "fileSize");
+      return {
+        title: path,
+        metadata: {},
+        output: size !== void 0 ? `Deleted ${path} (${size} bytes).` : `Deleted ${path}.`
+      };
+    }
+  }
+};
+function editFilePath(input) {
+  return isRecord(input) && typeof input["path"] === "string" ? input["path"] : "";
+}
+function editDiffString(result) {
+  if (!isRecord(result) || result["status"] !== "success") return null;
+  const value = result["value"];
+  if (!isRecord(value)) return null;
+  const diff = value["diffString"];
+  return typeof diff === "string" && diff.length > 0 ? diff : null;
+}
+function reconstructEditStrings(diff) {
+  const oldLines = [];
+  const newLines = [];
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("---") || line.startsWith("+++") || line.startsWith("@@") || line.startsWith("Index:") || line.startsWith("===")) {
+      continue;
+    }
+    if (line.startsWith("-")) oldLines.push(line.slice(1));
+    else if (line.startsWith("+")) newLines.push(line.slice(1));
+  }
+  return { oldString: oldLines.join("\n"), newString: newLines.join("\n") };
+}
+function editCallFields(id, filePath, diff) {
+  const { oldString, newString } = reconstructEditStrings(diff);
   return {
     type: "tool-call",
     toolCallId: id,
-    toolName: blockToolName(name),
-    input: safeJsonString(input),
+    toolName: EDIT_TOOL_NAME,
+    input: safeJsonString({ filePath, oldString, newString }),
     providerExecuted: true,
     dynamic: true
   };
 }
-function toolResultContent(id, name, result, isError) {
+function editResultFields(id, filePath, diff, result) {
+  const value = isRecord(result) ? result["value"] : void 0;
+  const added = isRecord(value) && typeof value["linesAdded"] === "number" ? value["linesAdded"] : void 0;
+  const removed = isRecord(value) && typeof value["linesRemoved"] === "number" ? value["linesRemoved"] : void 0;
+  const counts = added !== void 0 || removed !== void 0 ? ` (+${added ?? 0}/-${removed ?? 0})` : "";
   return {
     type: "tool-result",
     toolCallId: id,
-    toolName: blockToolName(name),
-    result: result ?? null,
-    isError,
+    toolName: EDIT_TOOL_NAME,
+    result: {
+      title: filePath,
+      metadata: { diff, diagnostics: {} },
+      output: `Edit applied${counts}.`
+    },
+    isError: false,
     providerExecuted: true,
     dynamic: true
   };
 }
+function newBlockToolState() {
+  return { open: /* @__PURE__ */ new Map(), pendingEdits: /* @__PURE__ */ new Map() };
+}
+function blockToolCallParts(id, name, input, state) {
+  if (name === EDIT_TOOL_NAME) {
+    state.pendingEdits.set(id, editFilePath(input));
+    return [];
+  }
+  const adapter = resolveAdapter(name, input);
+  if (adapter) {
+    const toolName2 = adapter.tool ?? blockToolName(name);
+    state.open.set(id, { toolName: toolName2, adapter, args: input });
+    return [nativeToolCall(id, toolName2, adapter.input(input))];
+  }
+  const toolName = blockToolName(name);
+  state.open.set(id, { toolName, args: input });
+  return [nativeToolCall(id, toolName, input)];
+}
+function blockToolResultParts(id, name, result, isError, state) {
+  if (state.pendingEdits.has(id)) {
+    const filePath = state.pendingEdits.get(id);
+    state.pendingEdits.delete(id);
+    const diff = isError ? null : editDiffString(result);
+    if (diff && filePath) {
+      return [
+        editCallFields(id, filePath, diff),
+        editResultFields(id, filePath, diff, result)
+      ];
+    }
+    return [
+      toolCallObj(id, EDIT_TOOL_NAME, { path: filePath }),
+      toolResultObj(id, EDIT_TOOL_NAME, result, isError)
+    ];
+  }
+  const open = state.open.get(id);
+  state.open.delete(id);
+  const toolName = open?.toolName ?? blockToolName(name);
+  if (open?.adapter && !isError) {
+    const value = successValue(result);
+    if (value !== void 0) {
+      const folded = open.adapter.result(value, open.args);
+      if (folded) return [nativeToolResult(id, toolName, folded, false)];
+    }
+  }
+  if (!isError) {
+    const folded = mcpFold(result);
+    if (folded) return [nativeToolResult(id, toolName, folded, false)];
+  }
+  return [nativeToolResult(id, toolName, result, isError)];
+}
+function blockDanglingParts(state) {
+  const parts = [];
+  for (const [id, open] of state.open) {
+    parts.push(nativeToolResult(id, open.toolName, DANGLING_TOOL_RESULT, true));
+  }
+  state.open.clear();
+  for (const [id, filePath] of state.pendingEdits) {
+    parts.push(toolCallObj(id, EDIT_TOOL_NAME, { path: filePath }));
+    parts.push(toolResultObj(id, EDIT_TOOL_NAME, DANGLING_TOOL_RESULT, true));
+  }
+  state.pendingEdits.clear();
+  return parts;
+}
 var EMPTY_USAGE = {
-  inputTokens: { total: void 0, noCache: void 0, cacheRead: void 0, cacheWrite: void 0 },
+  inputTokens: {
+    total: void 0,
+    noCache: void 0,
+    cacheRead: void 0,
+    cacheWrite: void 0
+  },
   outputTokens: { total: void 0, text: void 0, reasoning: void 0 }
 };
 function mapUsage(usage) {
@@ -159,14 +603,19 @@ function mapUsage(usage) {
       cacheRead: usage.cacheReadTokens,
       cacheWrite: usage.cacheWriteTokens
     },
-    outputTokens: { total: usage.outputTokens, text: void 0, reasoning: void 0 }
+    outputTokens: {
+      total: usage.outputTokens,
+      text: void 0,
+      reasoning: void 0
+    }
   };
 }
 function formatToolCall(name, input) {
   let arg = "";
   try {
     const s = typeof input === "string" ? input : JSON.stringify(input);
-    if (s && s !== "{}" && s !== '""') arg = ` ${s.length > 120 ? `${s.slice(0, 120)}\u2026` : s}`;
+    if (s && s !== "{}" && s !== '""')
+      arg = ` ${s.length > 120 ? `${s.slice(0, 120)}\u2026` : s}`;
   } catch {
   }
   return `[tool] ${name}${arg}`;
@@ -175,7 +624,7 @@ var DANGLING_TOOL_RESULT = {
   status: "error",
   error: "Cursor run ended before this tool call completed."
 };
-function cursorEventsToStream(events, toolDisplay = "reasoning") {
+function cursorEventsToStream(events, toolDisplay = "blocks") {
   return new ReadableStream({
     async start(controller) {
       controller.enqueue({ type: "stream-start", warnings: [] });
@@ -185,12 +634,11 @@ function cursorEventsToStream(events, toolDisplay = "reasoning") {
       let reasoningCount = 0;
       let usage;
       let streamedText = false;
-      const openToolCalls = /* @__PURE__ */ new Map();
+      const toolState = newBlockToolState();
       const closeDanglingToolCalls = () => {
-        for (const [id, name] of openToolCalls) {
-          controller.enqueue(toolResultPart(id, name, DANGLING_TOOL_RESULT, true));
+        for (const part of blockDanglingParts(toolState)) {
+          controller.enqueue(part);
         }
-        openToolCalls.clear();
       };
       const closeReasoning = () => {
         if (reasoningId) {
@@ -221,22 +669,36 @@ function cursorEventsToStream(events, toolDisplay = "reasoning") {
         return reasoningId;
       };
       const reasoningLine = (text) => {
-        controller.enqueue({ type: "reasoning-delta", id: ensureReasoning(), delta: text });
+        controller.enqueue({
+          type: "reasoning-delta",
+          id: ensureReasoning(),
+          delta: text
+        });
       };
       try {
         for await (const event of events) {
           switch (event.type) {
             case "text-delta":
               streamedText = true;
-              controller.enqueue({ type: "text-delta", id: ensureText(), delta: event.text });
+              controller.enqueue({
+                type: "text-delta",
+                id: ensureText(),
+                delta: event.text
+              });
               break;
             case "reasoning-delta":
               reasoningLine(event.text);
               break;
             case "tool-call":
               if (toolDisplay === "blocks") {
-                openToolCalls.set(event.id, event.name);
-                controller.enqueue(toolCallPart(event.id, event.name, event.input));
+                for (const part of blockToolCallParts(
+                  event.id,
+                  event.name,
+                  event.input,
+                  toolState
+                )) {
+                  controller.enqueue(part);
+                }
               } else {
                 reasoningLine(`
 ${formatToolCall(event.name, event.input)}
@@ -245,10 +707,15 @@ ${formatToolCall(event.name, event.input)}
               break;
             case "tool-result":
               if (toolDisplay === "blocks") {
-                openToolCalls.delete(event.id);
-                controller.enqueue(
-                  toolResultPart(event.id, event.name, event.result, event.isError)
-                );
+                for (const part of blockToolResultParts(
+                  event.id,
+                  event.name,
+                  event.result,
+                  event.isError,
+                  toolState
+                )) {
+                  controller.enqueue(part);
+                }
               } else if (event.isError) {
                 reasoningLine(`[tool] ${event.name} failed
 `);
@@ -259,7 +726,11 @@ ${formatToolCall(event.name, event.input)}
               break;
             case "finish":
               if (!streamedText && event.text) {
-                controller.enqueue({ type: "text-delta", id: ensureText(), delta: event.text });
+                controller.enqueue({
+                  type: "text-delta",
+                  id: ensureText(),
+                  delta: event.text
+                });
               }
               break;
           }
@@ -267,23 +738,31 @@ ${formatToolCall(event.name, event.input)}
         closeDanglingToolCalls();
         closeReasoning();
         closeText();
-        controller.enqueue({ type: "finish", usage: usage ?? EMPTY_USAGE, finishReason: FINISH_STOP });
+        controller.enqueue({
+          type: "finish",
+          usage: usage ?? EMPTY_USAGE,
+          finishReason: FINISH_STOP
+        });
         controller.close();
       } catch (err) {
         controller.enqueue({ type: "error", error: err });
         closeDanglingToolCalls();
         closeReasoning();
         closeText();
-        controller.enqueue({ type: "finish", usage: usage ?? EMPTY_USAGE, finishReason: FINISH_ERROR });
+        controller.enqueue({
+          type: "finish",
+          usage: usage ?? EMPTY_USAGE,
+          finishReason: FINISH_ERROR
+        });
         controller.close();
       }
     }
   });
 }
-async function cursorEventsToContent(events, toolDisplay = "reasoning") {
+async function cursorEventsToContent(events, toolDisplay = "blocks") {
   const content = [];
   const toolParts = [];
-  const openToolCalls = /* @__PURE__ */ new Map();
+  const toolState = newBlockToolState();
   let text = "";
   let reasoning = "";
   let usage = EMPTY_USAGE;
@@ -299,8 +778,14 @@ async function cursorEventsToContent(events, toolDisplay = "reasoning") {
           break;
         case "tool-call":
           if (toolDisplay === "blocks") {
-            openToolCalls.set(event.id, event.name);
-            toolParts.push(toolCallContent(event.id, event.name, event.input));
+            for (const part of blockToolCallParts(
+              event.id,
+              event.name,
+              event.input,
+              toolState
+            )) {
+              toolParts.push(part);
+            }
           } else {
             reasoning += `
 ${formatToolCall(event.name, event.input)}
@@ -309,8 +794,15 @@ ${formatToolCall(event.name, event.input)}
           break;
         case "tool-result":
           if (toolDisplay === "blocks") {
-            openToolCalls.delete(event.id);
-            toolParts.push(toolResultContent(event.id, event.name, event.result, event.isError));
+            for (const part of blockToolResultParts(
+              event.id,
+              event.name,
+              event.result,
+              event.isError,
+              toolState
+            )) {
+              toolParts.push(part);
+            }
           } else if (event.isError) {
             reasoning += `[tool] ${event.name} failed
 `;
@@ -327,10 +819,9 @@ ${formatToolCall(event.name, event.input)}
   } catch {
     finishReason = FINISH_ERROR;
   }
-  for (const [id, name] of openToolCalls) {
-    toolParts.push(toolResultContent(id, name, DANGLING_TOOL_RESULT, true));
+  for (const part of blockDanglingParts(toolState)) {
+    toolParts.push(part);
   }
-  openToolCalls.clear();
   if (reasoning) content.push({ type: "reasoning", text: reasoning });
   content.push(...toolParts);
   if (text) content.push({ type: "text", text });
@@ -385,16 +876,27 @@ var CursorLanguageModel = class {
     });
     const message = acquired.resumed ? latestUserMessage(options.prompt) ?? promptToCursorMessage(options.prompt) : promptToCursorMessage(options.prompt);
     try {
-      yield* streamAgentTurn(acquired.agent, message, { mode, abortSignal: options.abortSignal });
+      yield* streamAgentTurn(acquired.agent, message, {
+        mode,
+        abortSignal: options.abortSignal
+      });
     } finally {
       acquired.release();
     }
   }
   async doStream(options) {
-    return { stream: cursorEventsToStream(this.agentRun(options), this.config.toolDisplay) };
+    return {
+      stream: cursorEventsToStream(
+        this.agentRun(options),
+        this.config.toolDisplay
+      )
+    };
   }
   async doGenerate(options) {
-    const result = await cursorEventsToContent(this.agentRun(options), this.config.toolDisplay);
+    const result = await cursorEventsToContent(
+      this.agentRun(options),
+      this.config.toolDisplay
+    );
     return { ...result, warnings: [] };
   }
 };
@@ -413,7 +915,7 @@ function createCursor(options = {}) {
     ...options.sandbox !== void 0 ? { sandbox: options.sandbox } : {},
     ...options.agents ? { agents: options.agents } : {},
     ...options.session !== void 0 ? { session: options.session } : {},
-    ...options.toolDisplay ? { toolDisplay: options.toolDisplay } : {}
+    toolDisplay: options.toolDisplay ?? "blocks"
   };
   const notImplemented = (kind, modelId) => {
     throw new NoSuchModelError({