@cursor/july 0.1.2 → 0.1.4

package/src/internal/trajectory.ts

@@ -17,6 +17,16 @@ export interface TrajectoryToolCall {
   isError: boolean;
   /** Present when the tool required human approval before execute. */
   approvalDecision?: "approve" | "deny";
+  /** Parent task/subagent call id when this tool ran inside a subagent. */
+  parentCallId?: string;
+}
+
+export interface TrajectorySubagent {
+  callId: string;
+  name?: string;
+  description?: string;
+  /** Nested tool calls streamed while this subagent was running. */
+  toolCalls: TrajectoryToolCall[];
 }
 
 export interface TrajectoryTurn {
@@ -25,7 +35,7 @@ export interface TrajectoryTurn {
   assistantText: string;
   reasoningText?: string;
   toolCalls: TrajectoryToolCall[];
-  subagents: Array<{ callId: string; name?: string; description?: string }>;
+  subagents: TrajectorySubagent[];
   usage?: TurnUsage;
   result?: string;
   failed: boolean;
@@ -95,12 +105,20 @@ export function buildTrajectory(events: SessionEvent[]): Trajectory {
         break;
       }
       case "message.completed": {
+        // Nested subagent text must not overwrite the parent turn reply.
+        if (event.data.parentCallId !== undefined) {
+          break;
+        }
         if (event.turnId !== undefined && event.data.text !== "") {
           ensureTurn(event.turnId).assistantText = event.data.text;
         }
         break;
       }
       case "reasoning.appended": {
+        // Nested subagent thinking stays off the parent turn transcript.
+        if (event.data.parentCallId !== undefined) {
+          break;
+        }
         if (event.turnId !== undefined) {
           ensureTurn(event.turnId).reasoningText = event.data.text;
         }
@@ -112,14 +130,28 @@ export function buildTrajectory(events: SessionEvent[]): Trajectory {
         }
         const turn = ensureTurn(event.turnId);
         for (const call of event.data.calls) {
+          const parentCallId = call.parentCallId ?? event.data.parentCallId;
+          // Keep bare top-level `task` in toolCalls so evals like
+          // `calledTool("task")` / `notCalledTool("task")` keep working.
+          // Nested progress also appears under `subagents`.
           const entry: TrajectoryToolCall = {
             callId: call.callId,
             toolName: call.toolName,
             isError: false,
-            ...(call.args === undefined ? {} : { args: call.args }),
+            args: call.args,
+            parentCallId,
           };
           pendingCalls.set(call.callId, entry);
-          turn.toolCalls.push(entry);
+          if (parentCallId !== undefined) {
+            let sub = turn.subagents.find((s) => s.callId === parentCallId);
+            if (sub === undefined) {
+              sub = { callId: parentCallId, toolCalls: [] };
+              turn.subagents.push(sub);
+            }
+            sub.toolCalls.push(entry);
+          } else {
+            turn.toolCalls.push(entry);
+          }
         }
         break;
       }
@@ -141,24 +173,49 @@ export function buildTrajectory(events: SessionEvent[]): Trajectory {
           pending.isError = event.data.isError;
           pending.toolName = event.data.toolName;
         } else if (event.turnId !== undefined) {
-          ensureTurn(event.turnId).toolCalls.push({
+          const turn = ensureTurn(event.turnId);
+          const entry: TrajectoryToolCall = {
             callId: event.data.callId,
             toolName: event.data.toolName,
             output: event.data.output,
             isError: event.data.isError,
-          });
+            parentCallId: event.data.parentCallId,
+          };
+          if (event.data.parentCallId !== undefined) {
+            let sub = turn.subagents.find(
+              (s) => s.callId === event.data.parentCallId
+            );
+            if (sub === undefined) {
+              sub = {
+                callId: event.data.parentCallId,
+                toolCalls: [],
+              };
+              turn.subagents.push(sub);
+            }
+            sub.toolCalls.push(entry);
+          } else {
+            turn.toolCalls.push(entry);
+          }
         }
         break;
       }
       case "subagent.called": {
         if (event.turnId !== undefined) {
-          ensureTurn(event.turnId).subagents.push({
-            callId: event.data.callId,
-            ...(event.data.name === undefined ? {} : { name: event.data.name }),
-            ...(event.data.description === undefined
-              ? {}
-              : { description: event.data.description }),
-          });
+          const turn = ensureTurn(event.turnId);
+          const existing = turn.subagents.find(
+            (s) => s.callId === event.data.callId
+          );
+          if (existing !== undefined) {
+            existing.name = event.data.name;
+            existing.description = event.data.description;
+          } else {
+            turn.subagents.push({
+              callId: event.data.callId,
+              name: event.data.name,
+              description: event.data.description,
+              toolCalls: [],
+            });
+          }
         }
         break;
       }
@@ -202,7 +259,13 @@ export function buildTrajectory(events: SessionEvent[]): Trajectory {
 
   const turns = turnOrder.map((id) => turnsById.get(id)!);
   const turnsFailed = turns.filter((t) => t.failed).length;
-  const toolCallCount = turns.reduce((n, t) => n + t.toolCalls.length, 0);
+  const toolCallCount = turns.reduce(
+    (n, t) =>
+      n +
+      t.toolCalls.length +
+      t.subagents.reduce((m, s) => m + s.toolCalls.length, 0),
+    0
+  );
   const lastGood = [...turns].reverse().find((t) => t.assistantText !== "");
   return {
     sessionId,
@@ -270,6 +333,21 @@ export function formatTrajectoryText(trajectory: Trajectory): string {
         lines.push(`    ${truncate(stringify(call.output), 160)}`);
       }
     }
+    for (const sub of turn.subagents) {
+      const label = sub.name ?? "subagent";
+      const detail =
+        sub.description !== undefined
+          ? ` — ${truncate(sub.description, 80)}`
+          : "";
+      lines.push(`  task ${label}${detail}`);
+      for (const call of sub.toolCalls) {
+        const mark = call.isError ? "✗" : "→";
+        lines.push(`    ${mark} ${call.toolName}${formatArgs(call.args)}`);
+        if (call.output !== undefined) {
+          lines.push(`      ${truncate(stringify(call.output), 160)}`);
+        }
+      }
+    }
     if (turn.assistantText.length > 0) {
       lines.push(`  agent: ${truncate(turn.assistantText, 400)}`);
     }