@stablekernel/opencode-cursor 0.7.1-next.2 → 0.8.0

package/dist/provider/index.js

@@ -1,20 +1,26 @@
 import {
   acquireAgent,
+  activityLine,
   addUsage,
   classifyError,
   dropSessionRecord,
   extractSystemText,
   getSessionRecord,
   linkSubagentSession,
+  linkSubagentSessionLive,
   pluginLog,
+  registerSubagentCall,
+  renderConversationSteps,
   resolveControls,
   resolveCursorApiKey,
   resolveSystemDelivery,
+  resultText,
   sendAgentTurnSilently,
   setPreferredTransport,
   streamAgentTurn,
+  unregisterSubagentCall,
   withSessionLock
-} from "../chunk-RDY3H2LE.js";
+} from "../chunk-YIEC27VB.js";
 
 // src/provider/index.ts
 import { NoSuchModelError } from "@ai-sdk/provider";
@@ -134,6 +140,203 @@ function trailingUserMessages(prompt, count) {
   return collected.reverse();
 }
 
+// src/provider/subagent-stream.ts
+var TITLE_KEYS = ["path", "command", "pattern", "query", "server"];
+function toolTitle(input) {
+  if (typeof input !== "object" || input === null) return void 0;
+  const record = input;
+  for (const key of TITLE_KEYS) {
+    const value = record[key];
+    if (typeof value === "string" && value) return value;
+  }
+  return void 0;
+}
+var SubagentTranscriptSink = class _SubagentTranscriptSink {
+  /** Flush when this much time has elapsed since the last flush. */
+  static FLUSH_INTERVAL_MS = 1500;
+  session;
+  text = "";
+  reasoning = "";
+  tools = [];
+  pending = false;
+  lastFlush = 0;
+  timer;
+  done = false;
+  /** Nested call id → the running tool part written for it. */
+  partHandles = /* @__PURE__ */ new Map();
+  /** Serialises tool-part writes so a result never overtakes its start. */
+  partChain = Promise.resolve();
+  anonSeq = 0;
+  /** Correlation key for a nested event that arrived without a call id. */
+  nestedKey(id) {
+    return id || `anon-${++this.anonSeq}`;
+  }
+  /** Enqueue a tool-part write; fire-and-forget, never throws. */
+  enqueuePart(write) {
+    this.partChain = this.partChain.then(async () => {
+      await write();
+    }).catch(() => void 0);
+  }
+  constructor(session) {
+    this.session = session;
+  }
+  /** The linked child session id (for stamping the task card's sessionId). */
+  get childId() {
+    return this.session.childId;
+  }
+  /** Feed a normalized nested subagent event into the sink. */
+  push(event) {
+    if (this.done) return;
+    switch (event.type) {
+      case "text":
+        this.text += event.text;
+        this.pending = true;
+        break;
+      case "reasoning":
+        this.reasoning += event.text;
+        this.pending = true;
+        break;
+      case "tool-start": {
+        this.tools.push(`**\`${event.name}\`** ${formatArgs(event.input)}`);
+        this.pending = true;
+        const key = this.nestedKey(event.id);
+        const start = Date.now();
+        this.enqueuePart(async () => {
+          const partID = await this.session.toolPart({
+            callID: key,
+            tool: event.name,
+            status: "running",
+            title: toolTitle(event.input),
+            input: event.input,
+            start
+          });
+          if (partID) {
+            this.partHandles.set(key, {
+              partID,
+              callID: key,
+              tool: event.name,
+              title: toolTitle(event.input),
+              input: event.input,
+              start
+            });
+          }
+        });
+        break;
+      }
+      case "tool-result": {
+        this.tools.push(formatResult(event.name, event.result, event.isError));
+        this.pending = true;
+        const key = event.id || `result-${++this.anonSeq}`;
+        this.enqueuePart(async () => {
+          const handle = this.partHandles.get(key);
+          this.partHandles.delete(key);
+          await this.session.toolPart({
+            callID: handle?.callID ?? key,
+            tool: event.name,
+            status: "completed",
+            title: handle?.title,
+            input: handle?.input,
+            partID: handle?.partID,
+            start: handle?.start ?? Date.now(),
+            end: Date.now()
+          });
+        });
+        this.flushNow();
+        return;
+      }
+    }
+    this.armTimer();
+  }
+  /**
+   * Flush any buffered content, then append the subagent's final answer
+   * (`resultSuffix`), a render of its `conversationSteps` (its own
+   * text/thinking/tool activity), and the optional activity line, and mark
+   * the sink done. Further pushes and flushes become no-ops.
+   */
+  async finalize(resultValue, activity) {
+    if (this.done) return;
+    this.done = true;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = void 0;
+    const body = this.render();
+    if (body) await this.session.flush(body);
+    const suffix = typeof resultValue === "object" && resultValue !== null ? resultValue["resultSuffix"] : void 0;
+    if (typeof suffix === "string" && suffix) await this.session.flush(suffix);
+    const steps = renderConversationSteps(resultValue);
+    if (steps) await this.session.flush(steps);
+    await this.partChain;
+    for (const [, handle] of this.partHandles) {
+      await this.session.toolPart({
+        callID: handle.callID,
+        tool: handle.tool,
+        status: "completed",
+        title: handle.title,
+        input: handle.input,
+        partID: handle.partID,
+        start: handle.start,
+        end: Date.now()
+      });
+    }
+    this.partHandles.clear();
+    if (activity) await this.session.finalize(activity);
+    else await this.session.finalize();
+  }
+  armTimer() {
+    if (this.done || this.timer) return;
+    const elapsed = Date.now() - this.lastFlush;
+    const delay = Math.max(0, _SubagentTranscriptSink.FLUSH_INTERVAL_MS - elapsed);
+    this.timer = setTimeout(() => {
+      this.timer = void 0;
+      this.flushNow();
+    }, delay);
+    this.timer.unref?.();
+  }
+  flushNow() {
+    if (this.done) return;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    if (!this.pending) return;
+    const body = this.render();
+    this.pending = false;
+    this.lastFlush = Date.now();
+    if (body) void this.session.flush(body);
+  }
+  /** Render the accumulated activity into a single markdown message. */
+  render() {
+    const parts = [];
+    if (this.text.trim()) parts.push(this.text.trim());
+    if (this.reasoning.trim()) parts.push(`> ${this.reasoning.trim()}`);
+    if (this.tools.length > 0) parts.push(this.tools.join("\n\n"));
+    const body = parts.join("\n\n").trim();
+    this.text = "";
+    this.reasoning = "";
+    this.tools.length = 0;
+    return body;
+  }
+};
+function formatArgs(input) {
+  let s = "";
+  try {
+    s = typeof input === "string" ? input : JSON.stringify(input);
+  } catch {
+    return "";
+  }
+  if (!s || s === "{}" || s === '""') return "";
+  return s;
+}
+function formatResult(name, result, isError) {
+  if (isError) return `**\`${name}\`** \u2014 _failed_`;
+  const text = resultText(result);
+  if (!text) return `**\`${name}\`** \u2014 _done_`;
+  return `**\`${name}\`**
+
+\`\`\`
+${text}
+\`\`\``;
+}
+
 // src/provider/stream-map.ts
 var TASK_TOOL_NAME = "task";
 function injectSubagentSessionId(parts, sessionId) {
@@ -213,7 +416,10 @@ 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;
+  if (!isRecord(result) || result["status"] !== "success") return void 0;
+  const value = result["value"];
+  if (value === void 0) return void 0;
+  return value;
 }
 function subagentTypeField(args) {
   const sub = isRecord(args) ? args["subagentType"] : void 0;
@@ -238,7 +444,7 @@ function mcpFold(result) {
   return { title: "", metadata: {}, output: text };
 }
 function mcpInputArgs(args) {
-  return isRecord(args) ? args["args"] : void 0;
+  return isRecord(args) && isRecord(args["args"]) ? args["args"] : void 0;
 }
 function webSearchProvider(args) {
   const id = (strField(args, "providerIdentifier") ?? "").toLowerCase();
@@ -253,7 +459,7 @@ var WEBSEARCH_ADAPTER = {
   tool: "websearch",
   input: (args) => {
     const query = strField(mcpInputArgs(args), "query");
-    return query !== void 0 ? { query } : {};
+    return query === void 0 ? {} : { query };
   },
   result: (value, args) => {
     const provider = webSearchProvider(args);
@@ -325,15 +531,15 @@ var NATIVE_ADAPTERS = {
       const totalLines = numField(value, "totalLines");
       const fileSize = numField(value, "fileSize");
       const linesReturned = content.split("\n").length;
-      const lineLabel = totalLines !== void 0 ? `${linesReturned}/${totalLines} lines` : `${linesReturned} lines`;
+      const lineLabel = totalLines === void 0 ? `${linesReturned} lines` : `${linesReturned}/${totalLines} lines`;
       return {
         title: `${filePath} (${lineLabel})`,
         metadata: {
           preview: content.split("\n").slice(0, 20).join("\n"),
           loaded: [],
           linesReturned,
-          ...totalLines !== void 0 ? { totalLines } : {},
-          ...fileSize !== void 0 ? { fileSize } : {}
+          ...totalLines === void 0 ? {} : { totalLines },
+          ...fileSize === void 0 ? {} : { fileSize }
         },
         output: content
       };
@@ -349,7 +555,7 @@ var NATIVE_ADAPTERS = {
     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.";
+      const output = lines === void 0 ? "Wrote file successfully." : `Wrote ${lines} line${lines === 1 ? "" : "s"}.`;
       return {
         title: filePath,
         metadata: { diagnostics: {}, filepath: filePath, exists: false },
@@ -417,9 +623,7 @@ var NATIVE_ADAPTERS = {
               current = file;
               lines.push(`${file}:`);
             }
-            lines.push(
-              line !== void 0 ? `  Line ${line}: ${text}` : `  ${text}`
-            );
+            lines.push(line === void 0 ? `  ${text}` : `  Line ${line}: ${text}`);
             total++;
           }
         } else if (u["type"] === "files" && isRecord(output) && Array.isArray(output["files"])) {
@@ -440,11 +644,9 @@ var NATIVE_ADAPTERS = {
       return {
         title,
         metadata: { matches: total, truncated: false },
-        output: total > 0 ? [
-          `Found ${total} match${total === 1 ? "" : "es"}`,
-          "",
-          ...lines
-        ].join("\n") : "No matches found"
+        output: total > 0 ? [`Found ${total} match${total === 1 ? "" : "es"}`, "", ...lines].join(
+          "\n"
+        ) : "No matches found"
       };
     }
   },
@@ -452,7 +654,9 @@ var NATIVE_ADAPTERS = {
   // + results body instead of the raw `{results}` JSON.
   semSearch: {
     input: (args) => {
-      const out = { query: strField(args, "query") ?? "" };
+      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;
@@ -557,7 +761,7 @@ var NATIVE_ADAPTERS = {
           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}` : ""}` : "";
+          const loc = line === void 0 ? "" : ` L${line + 1}${char === void 0 ? "" : `:${char + 1}`}`;
           lines.push(`  ${severity}${loc}: ${strField(d, "message") ?? ""}`);
           total++;
         }
@@ -579,7 +783,7 @@ var NATIVE_ADAPTERS = {
       return {
         title: path,
         metadata: {},
-        output: size !== void 0 ? `Deleted ${path} (${size} bytes).` : `Deleted ${path}.`
+        output: size === void 0 ? `Deleted ${path}.` : `Deleted ${path} (${size} bytes).`
       };
     }
   }
@@ -668,7 +872,8 @@ function blockToolInputPartialParts(id, name, input, state) {
       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 });
+  if (delta)
+    parts.push({ type: "tool-input-delta", id, delta });
   return parts;
 }
 function blockToolCallParts(id, name, input, state) {
@@ -796,6 +1001,7 @@ function cursorEventsToStream(events, toolDisplay = "blocks", ctx = {}) {
       let thinkingMs = 0;
       let compactions = 0;
       const toolState = newBlockToolState();
+      const subagentSinks = /* @__PURE__ */ new Map();
       const closeDanglingToolCalls = () => {
         for (const part of blockDanglingParts(toolState)) {
           controller.enqueue(part);
@@ -898,6 +1104,16 @@ function cursorEventsToStream(events, toolDisplay = "blocks", ctx = {}) {
                 toolState.dropped.add(event.id);
                 break;
               }
+              if (toolDisplay === "blocks" && event.name === TASK_TOOL_NAME && !subagentSinks.has(event.id) && ctx.sessionID) {
+                const live = await linkSubagentSessionLive({
+                  parentSessionID: ctx.sessionID,
+                  args: event.input
+                });
+                if (live) {
+                  subagentSinks.set(event.id, new SubagentTranscriptSink(live));
+                  registerSubagentCall(event.id, live.childId);
+                }
+              }
               if (toolDisplay === "blocks") {
                 if (toolState.partials.delete(event.id)) {
                   controller.enqueue({
@@ -915,9 +1131,7 @@ function cursorEventsToStream(events, toolDisplay = "blocks", ctx = {}) {
                   closeText();
                   closeReasoning();
                 }
-                for (const part of parts) {
-                  controller.enqueue(part);
-                }
+                for (const part of parts) controller.enqueue(part);
               } else {
                 reasoningLine(`
 ${formatToolCall(event.name, event.input)}
@@ -939,13 +1153,25 @@ ${formatToolCall(event.name, event.input)}
                   closeText();
                   closeReasoning();
                 }
-                if (event.name === TASK_TOOL_NAME && !event.isError && ctx.sessionID) {
-                  const childId = await linkSubagentSession({
-                    parentSessionID: ctx.sessionID,
-                    args: taskArgs,
-                    result: event.result
-                  });
-                  if (childId) injectSubagentSessionId(parts, childId);
+                if (event.name === TASK_TOOL_NAME && !event.isError) {
+                  const sink = subagentSinks.get(event.id);
+                  if (sink) {
+                    const value = isRecord(event.result) && event.result["status"] === "success" ? event.result["value"] : void 0;
+                    await sink.finalize(value, activityLine(value));
+                    injectSubagentSessionId(parts, sink.childId);
+                    subagentSinks.delete(event.id);
+                    unregisterSubagentCall(event.id);
+                  } else if (ctx.sessionID) {
+                    const childId = await linkSubagentSession({
+                      parentSessionID: ctx.sessionID,
+                      args: taskArgs,
+                      result: event.result
+                    });
+                    if (childId) injectSubagentSessionId(parts, childId);
+                  }
+                } else if (event.name === TASK_TOOL_NAME) {
+                  subagentSinks.delete(event.id);
+                  unregisterSubagentCall(event.id);
                 }
                 for (const part of parts) {
                   controller.enqueue(part);
@@ -955,13 +1181,17 @@ ${formatToolCall(event.name, event.input)}
 `);
               }
               break;
+            case "subagent-event": {
+              const sink = subagentSinks.get(event.callId);
+              if (sink) sink.push(event.event);
+              break;
+            }
             case "usage":
               usage = mapUsage(event.usage);
               break;
             case "reasoning-complete":
               closeReasoning();
-              if (typeof event.durationMs === "number")
-                thinkingMs += event.durationMs;
+              if (typeof event.durationMs === "number") thinkingMs += event.durationMs;
               break;
             case "compaction":
               compactions++;
@@ -1078,6 +1308,8 @@ ${formatToolCall(event.name, event.input)}
           break;
         case "compaction":
           break;
+        case "subagent-event":
+          break;
         case "finish":
           if (!text && event.text) text = event.text;
           break;