@cursor/july 0.1.2 → 0.1.3

package/src/internal/event-mapper.ts

@@ -4,11 +4,63 @@
  * (`SessionEvent` payloads). One mapper instance covers one turn.
  */
 
-import type { InteractionUpdate, ToolCall } from "@cursor/sdk";
+import type {
+  InteractionUpdate as SdkInteractionUpdate,
+  ToolCall,
+} from "@cursor/sdk";
 import type { SessionEventPayload, TurnUsage } from "../types.js";
 
 const CUSTOM_TOOLS_PROVIDER = "custom-user-tools";
 
+/**
+ * Nested interaction updates from a task/subagent tool-call-delta.
+ * Mirrored locally so agent-serve typechecks against published `@cursor/sdk`
+ * versions that do not yet export `NestedTaskUpdate` / `tool-call-delta`.
+ */
+type NestedTaskUpdate =
+  | { type: "text-delta"; text: string }
+  | { type: "thinking-delta"; text: string }
+  | { type: "thinking-completed"; thinkingDurationMs: number }
+  | {
+      type: "tool-call-started";
+      callId: string;
+      toolCall: ToolCall;
+      modelCallId: string;
+    }
+  | {
+      type: "tool-call-completed";
+      callId: string;
+      toolCall: ToolCall;
+      modelCallId: string;
+    }
+  | {
+      type: "partial-tool-call";
+      callId: string;
+      toolCall: ToolCall;
+      modelCallId: string;
+    }
+  | { type: "step-started"; stepId: number }
+  | { type: "step-completed"; stepId: number; stepDurationMs: number };
+
+type ToolCallDeltaUpdate = {
+  type: "tool-call-delta";
+  callId: string;
+  modelCallId: string;
+  taskUpdate: NestedTaskUpdate;
+};
+
+/** SDK updates plus nested task deltas once the SDK exposes them. */
+type InteractionUpdate = SdkInteractionUpdate | ToolCallDeltaUpdate;
+
+function asToolCallDelta(
+  update: InteractionUpdate
+): ToolCallDeltaUpdate | undefined {
+  if ((update as { type: string }).type !== "tool-call-delta") {
+    return undefined;
+  }
+  return update as ToolCallDeltaUpdate;
+}
+
 export interface ToolCallDescription {
   toolName: string;
   args?: unknown;
@@ -20,12 +72,19 @@ export interface ToolResultDescription {
   isError: boolean;
 }
 
+interface NestedAccumulators {
+  text: string;
+  reasoning: string;
+}
+
 export class TurnEventMapper {
   private textAccumulator = "";
   private reasoningAccumulator = "";
   private usageTotal: TurnUsage | undefined;
   private lastAssistantText: string | undefined;
   private summaryTitle: string | undefined;
+  /** Per-parent-call accumulators for nested subagent streams. */
+  private readonly nested = new Map<string, NestedAccumulators>();
 
   constructor(private readonly emit: (payload: SessionEventPayload) => void) {}
 
@@ -74,49 +133,11 @@ export class TurnEventMapper {
       }
       case "tool-call-started": {
         this.flushAssistantText("tool_call");
-        const description = describeToolCall(update.toolCall);
-        this.emit({
-          type: "actions.requested",
-          data: {
-            calls: [
-              {
-                callId: update.callId,
-                toolName: description.toolName,
-                args: description.args,
-              },
-            ],
-          },
-        });
-        if (description.subagent !== undefined) {
-          this.emit({
-            type: "subagent.called",
-            data: {
-              callId: update.callId,
-              name: description.subagent.name,
-              description: description.subagent.description,
-            },
-          });
-        }
+        this.emitToolStarted(update.callId, update.toolCall);
         return;
       }
       case "tool-call-completed": {
-        const description = describeToolCall(update.toolCall);
-        const result = describeToolResult(update.toolCall);
-        this.emit({
-          type: "action.result",
-          data: {
-            callId: update.callId,
-            toolName: description.toolName,
-            output: result.output,
-            isError: result.isError,
-          },
-        });
-        if (description.subagent !== undefined) {
-          this.emit({
-            type: "subagent.completed",
-            data: { callId: update.callId, name: description.subagent.name },
-          });
-        }
+        this.emitToolCompleted(update.callId, update.toolCall);
         return;
       }
       case "step-started": {
@@ -148,7 +169,13 @@ export class TurnEventMapper {
       case "shell-output-delta":
         return;
       default: {
-        // Future harness update types are ignored rather than fatal.
+        // Nested task/subagent progress (tool-call-delta) — accepted via
+        // structural check so we typecheck against older published SDKs.
+        const delta = asToolCallDelta(update);
+        if (delta !== undefined) {
+          this.handleNestedTaskUpdate(delta.callId, delta.taskUpdate);
+          return;
+        }
         return;
       }
     }
@@ -157,6 +184,143 @@ export class TurnEventMapper {
   /** Close out the turn: finalize any open assistant text block. */
   finish(): void {
     this.flushAssistantText("stop");
+    for (const parentCallId of this.nested.keys()) {
+      this.flushNestedAssistantText(parentCallId, "stop");
+    }
+  }
+
+  private handleNestedTaskUpdate(
+    parentCallId: string,
+    update: NestedTaskUpdate
+  ): void {
+    switch (update.type) {
+      case "text-delta": {
+        const acc = this.ensureNested(parentCallId);
+        acc.text += update.text;
+        this.emit({
+          type: "message.appended",
+          data: {
+            delta: update.text,
+            text: acc.text,
+            parentCallId,
+          },
+        });
+        return;
+      }
+      case "thinking-delta": {
+        const acc = this.ensureNested(parentCallId);
+        acc.reasoning += update.text;
+        this.emit({
+          type: "reasoning.appended",
+          data: {
+            delta: update.text,
+            text: acc.reasoning,
+            parentCallId,
+          },
+        });
+        return;
+      }
+      case "thinking-completed": {
+        const acc = this.nested.get(parentCallId);
+        if (acc !== undefined && acc.reasoning !== "") {
+          acc.reasoning = "";
+        }
+        this.emit({
+          type: "reasoning.completed",
+          data: {
+            durationMs: update.thinkingDurationMs,
+            parentCallId,
+          },
+        });
+        return;
+      }
+      case "tool-call-started": {
+        this.flushNestedAssistantText(parentCallId, "tool_call");
+        this.emitToolStarted(update.callId, update.toolCall, parentCallId);
+        return;
+      }
+      case "tool-call-completed": {
+        this.emitToolCompleted(update.callId, update.toolCall, parentCallId);
+        return;
+      }
+      case "partial-tool-call":
+      case "step-started":
+      case "step-completed":
+        return;
+      default: {
+        return;
+      }
+    }
+  }
+
+  private emitToolStarted(
+    callId: string,
+    toolCall: ToolCall,
+    parentCallId?: string
+  ): void {
+    const description = describeToolCall(toolCall);
+    this.emit({
+      type: "actions.requested",
+      data: {
+        calls: [
+          {
+            callId,
+            toolName: description.toolName,
+            args: description.args,
+            parentCallId,
+          },
+        ],
+        parentCallId,
+      },
+    });
+    // Subagent bookends only fire for the top-level task tool, not nested
+    // tools inside a subagent (nested subagents aren't supported).
+    if (description.subagent !== undefined && parentCallId === undefined) {
+      this.emit({
+        type: "subagent.called",
+        data: {
+          callId,
+          name: description.subagent.name,
+          description: description.subagent.description,
+        },
+      });
+    }
+  }
+
+  private emitToolCompleted(
+    callId: string,
+    toolCall: ToolCall,
+    parentCallId?: string
+  ): void {
+    const description = describeToolCall(toolCall);
+    const result = describeToolResult(toolCall);
+    this.emit({
+      type: "action.result",
+      data: {
+        callId,
+        toolName: description.toolName,
+        output: result.output,
+        isError: result.isError,
+        parentCallId,
+      },
+    });
+    if (description.subagent !== undefined && parentCallId === undefined) {
+      this.flushNestedAssistantText(callId, "stop");
+      this.nested.delete(callId);
+      this.emit({
+        type: "subagent.completed",
+        data: { callId, name: description.subagent.name },
+      });
+    }
+  }
+
+  private ensureNested(parentCallId: string): NestedAccumulators {
+    let acc = this.nested.get(parentCallId);
+    if (acc === undefined) {
+      acc = { text: "", reasoning: "" };
+      this.nested.set(parentCallId, acc);
+    }
+    return acc;
   }
 
   private flushAssistantText(finishReason: "stop" | "tool_call"): void {
@@ -171,6 +335,22 @@ export class TurnEventMapper {
       data: { text, finishReason },
     });
   }
+
+  private flushNestedAssistantText(
+    parentCallId: string,
+    finishReason: "stop" | "tool_call"
+  ): void {
+    const acc = this.nested.get(parentCallId);
+    if (acc === undefined || acc.text === "") {
+      return;
+    }
+    const text = acc.text;
+    acc.text = "";
+    this.emit({
+      type: "message.completed",
+      data: { text, finishReason, parentCallId },
+    });
+  }
 }
 
 /**