@cursor/july 0.1.2 → 0.1.4

package/src/internal/eval-run-store.ts

@@ -185,7 +185,7 @@ export class EvalRunStore {
     await this.pruneOldRuns(config);
     await this.enqueuePersist(snapshot, this.resolvePersist(config));
     this.logger(
-      `[agent-serve] eval run ${runId}: starting ${cases.length} case(s)`
+      `[agentkit] eval run ${runId}: starting ${cases.length} case(s)`
     );
 
     void this.execute(runId, {
@@ -235,7 +235,7 @@ export class EvalRunStore {
       const loaded = await persist.load({ projectRoot: this.projectRoot });
       if (!Array.isArray(loaded)) {
         this.logger(
-          "[agent-serve] eval persistRuns.load() did not return an array; ignoring"
+          "[agentkit] eval persistRuns.load() did not return an array; ignoring"
         );
         this.hydrated = true;
         return;
@@ -262,12 +262,12 @@ export class EvalRunStore {
       }
       await this.pruneOldRuns(config);
       this.logger(
-        `[agent-serve] hydrated ${this.runs.size} playground eval run(s) from persistRuns`
+        `[agentkit] hydrated ${this.runs.size} playground eval run(s) from persistRuns`
       );
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       this.logger(
-        `[agent-serve] failed to hydrate playground eval runs: ${message}`
+        `[agentkit] failed to hydrate playground eval runs: ${message}`
       );
     } finally {
       this.hydrated = true;
@@ -319,7 +319,7 @@ export class EvalRunStore {
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       this.logger(
-        `[agent-serve] persistRuns.save(${run.runId}) failed: ${message}`
+        `[agentkit] persistRuns.save(${run.runId}) failed: ${message}`
       );
     }
   }
@@ -335,9 +335,7 @@ export class EvalRunStore {
       await persist.delete(runId, { projectRoot: this.projectRoot });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      this.logger(
-        `[agent-serve] persistRuns.delete(${runId}) failed: ${message}`
-      );
+      this.logger(`[agentkit] persistRuns.delete(${runId}) failed: ${message}`);
     }
   }
 
@@ -400,7 +398,8 @@ export class EvalRunStore {
           }
           if (
             event.type === "message.completed" &&
-            typeof event.data?.text === "string"
+            typeof event.data?.text === "string" &&
+            event.data.parentCallId === undefined
           ) {
             c.finalText = event.data.text;
           }
@@ -421,7 +420,7 @@ export class EvalRunStore {
       run.finishedAt = new Date().toISOString();
       await this.enqueuePersist(run, this.resolvePersist(opts.config));
       this.logger(
-        `[agent-serve] eval run ${runId}: done — ${run.summary.passed} passed, ${run.summary.failed} failed`
+        `[agentkit] eval run ${runId}: done — ${run.summary.passed} passed, ${run.summary.failed} failed`
       );
     } catch (error) {
       const run = this.runs.get(runId);
@@ -432,7 +431,7 @@ export class EvalRunStore {
       run.finishedAt = new Date().toISOString();
       run.error = error instanceof Error ? error.message : String(error);
       await this.enqueuePersist(run, this.resolvePersist(opts.config));
-      this.logger(`[agent-serve] eval run ${runId}: failed — ${run.error}`);
+      this.logger(`[agentkit] eval run ${runId}: failed — ${run.error}`);
     } finally {
       if (this.activeRunId === runId) {
         this.activeRunId = undefined;

package/src/internal/eval-runner.ts

@@ -76,6 +76,8 @@ export interface RunEvalsOptions extends EvalSelectionOptions {
   baseUrl: string;
   timeoutMs?: number;
   bearerToken?: string;
+  /** Extra request headers (e.g. hosted engineAccess). */
+  headers?: Record<string, string>;
   verbose?: boolean;
   onEvent?: (event: SessionEvent) => void;
   /** Fired when a case begins executing (after concurrency slot acquired). */
@@ -240,6 +242,7 @@ export async function runDiscoveredEvals(
       baseUrl: options.baseUrl,
       defaultTimeoutMs,
       bearerToken: options.bearerToken,
+      headers: options.headers,
       verbose: Boolean(options.verbose),
       onEvent: (event) => {
         options.onCaseEvent?.(discovered.id, event);
@@ -268,6 +271,7 @@ async function runOneEval(
     baseUrl: string;
     defaultTimeoutMs: number;
     bearerToken?: string;
+    headers?: Record<string, string>;
     verbose: boolean;
     onEvent?: (event: SessionEvent) => void;
   }
@@ -330,6 +334,7 @@ async function runOneEval(
         // Keep defineEval traffic out of live defineAB enrollment/metrics.
         purpose: "eval",
         bearerToken: opts.bearerToken,
+        headers: opts.headers,
         workspaceDir: options.workspaceDir,
         workspaceFiles: options.workspaceFiles,
         timeoutMs,

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 },
+    });
+  }
 }
 
 /**

package/src/internal/github-fanout.ts

@@ -136,14 +136,14 @@ export async function fanoutDelivery(
         });
         if (!response.ok) {
           log(
-            `[agent-serve] delivery to ${label} failed: HTTP ${response.status}\n`
+            `[agentkit] delivery to ${label} failed: HTTP ${response.status}\n`
           );
           return;
         }
         delivered.push(label);
       } catch (error) {
         log(
-          `[agent-serve] delivery to ${label} failed: ${
+          `[agentkit] delivery to ${label} failed: ${
             error instanceof Error ? error.message : String(error)
           }\n`
         );

package/src/internal/host-platforms.ts

@@ -114,7 +114,7 @@ export async function warmupHostGitHubAuth(options: {
   const source = options.authSource ?? (await resolveHostGitHubAuthSource());
   if (source === "unavailable") {
     options.logger(
-      "[agent-serve] GitHub auth: unavailable (set GITHUB_APP_ID + GITHUB_APP_PRIVATE_KEY + GITHUB_APP_INSTALLATION_ID, or GITHUB_TOKEN / GH_TOKEN, or run `gh auth login`)"
+      "[agentkit] GitHub auth: unavailable (set GITHUB_APP_ID + GITHUB_APP_PRIVATE_KEY + GITHUB_APP_INSTALLATION_ID, or GITHUB_TOKEN / GH_TOKEN, or run `gh auth login`)"
     );
     return source;
   }
@@ -125,7 +125,7 @@ export async function warmupHostGitHubAuth(options: {
       exportedGhToken = await ensureGhCliTokenEnv();
     } catch (error) {
       options.logger(
-        `[agent-serve] GitHub auth: failed to export GH_TOKEN for gh CLI: ${
+        `[agentkit] GitHub auth: failed to export GH_TOKEN for gh CLI: ${
           error instanceof Error ? error.message : String(error)
         }`
       );
@@ -143,16 +143,16 @@ export async function warmupHostGitHubAuth(options: {
           ? "GITHUB_TOKEN/GH_TOKEN"
           : "gh auth token";
   if (options.github === undefined) {
-    options.logger(`[agent-serve] GitHub auth: ${label}`);
+    options.logger(`[agentkit] GitHub auth: ${label}`);
     return source;
   }
 
   try {
     await options.github.getOctokit();
-    options.logger(`[agent-serve] GitHub auth: ${label}`);
+    options.logger(`[agentkit] GitHub auth: ${label}`);
   } catch (error) {
     options.logger(
-      `[agent-serve] GitHub auth: ${label} resolved but Octokit warmup failed: ${
+      `[agentkit] GitHub auth: ${label} resolved but Octokit warmup failed: ${
         error instanceof Error ? error.message : String(error)
       }`
     );