@cursor/bdk 0.2.1 → 0.2.2

package/src/internal/session-engine.ts

@@ -644,6 +644,16 @@ export class SessionEngine {
       agentName: options.project.name,
       config: options.project.artifacts,
       sink: managedV2Files?.(),
+      // v1 and self-hosted v2 still evict oldest-updated rows past max.
+      // Hosted v2 does not: the installation file store keeps every row,
+      // and tag must not list the prefix. Read per tag so a generation
+      // env bound after serve start takes effect.
+      enforceCap: () => {
+        const hosting = resolveAgentV2Hosting({
+          architecture: options.project.agent.architecture,
+        });
+        return hosting.kind !== "cursor-managed" && hosting.kind !== "cursor-managed-persistent";
+      },
     });
     // Peer and Cursor-account transports are symbolic until the serve host
     // resolves them; the host-side MCP registry starts with the concrete
@@ -3813,7 +3823,7 @@ export class SessionEngine {
    *
    * With `options.sessionId` the tool runs inside that session (its info
    * and materialized workspace) and the call is recorded on the session's
-   * event stream as `actions.requested` / `action.result` under a
+   * event stream as `actions.requested` / `actions.completed` under a
    * per-call `turnId` (the call id), so it shows up in trajectories.
    * While a model turn is running, a read-effect call runs alongside it
    * (the turn's workspace is read as-is) and a write-effect call is
@@ -4258,16 +4268,22 @@ export class SessionEngine {
     this.logger(`[session] tool ${toolName} done (direct ${callId}, ${durationMs}ms)`);
 
     if (record !== undefined) {
+      const resultData = {
+        callId,
+        toolName,
+        output: result,
+        isError,
+        stubbed: stubbed ? (true as const) : undefined,
+      };
       await this.appendEvent(record.sessionId, {
         type: "action.result",
         turnId: callId,
-        data: {
-          callId,
-          toolName,
-          output: result,
-          isError,
-          ...(stubbed ? { stubbed: true as const } : {}),
-        },
+        data: resultData,
+      });
+      await this.appendEvent(record.sessionId, {
+        type: "actions.completed",
+        turnId: callId,
+        data: { results: [resultData] },
       });
     }
 

package/src/types.ts

@@ -834,7 +834,7 @@ export interface HostOtelApi {
 
 /** Runtime context handed to a tool's `execute`. */
 export interface ToolContext {
-  /** Correlates with `actions.requested` / `action.result` stream events. */
+  /** Correlates with `actions.requested` / `actions.completed` stream events. */
   toolCallId?: string;
   /** The session this tool call runs inside. */
   session: SessionInfo;
@@ -1547,6 +1547,22 @@ export interface ActionCall {
    * parent `task` tool call id is `parentCallId`.
    */
   parentCallId?: string;
+  /**
+   * Model generation that requested this call. Every tool from one
+   * `runStep` shares the same id (the step's invocation id).
+   */
+  modelCallId?: string;
+}
+
+/** One tool result inside an {@link SessionEventPayload} `actions.completed` batch. */
+export interface ActionResult {
+  callId: string;
+  toolName: string;
+  output?: unknown;
+  isError: boolean;
+  stubbed?: true;
+  parentCallId?: string;
+  modelCallId?: string;
 }
 
 /** Human decision for a parked {@link ToolConfig.needsApproval} tool call. */
@@ -1613,7 +1629,16 @@ export type SessionEventPayload =
     }
   | {
       type: "actions.requested";
-      data: { calls: ActionCall[]; parentCallId?: string };
+      data: {
+        calls: ActionCall[];
+        parentCallId?: string;
+        /**
+         * Same id as {@link ActionCall.modelCallId} on every call.
+         * One envelope per model step (a single tool is a batch of one)
+         * once that step has finished listing tools.
+         */
+        modelCallId?: string;
+      };
     }
   | {
       /**
@@ -1679,6 +1704,21 @@ export type SessionEventPayload =
          */
         stubbed?: true;
         parentCallId?: string;
+        /** Same id as the matching {@link ActionCall.modelCallId}. */
+        modelCallId?: string;
+      };
+    }
+  | {
+      /**
+       * Every result for one {@link SessionEventPayload} `actions.requested`
+       * batch. Pair these two events; `action.result` stays the live
+       * per-call envelope for chips and spans.
+       */
+      type: "actions.completed";
+      data: {
+        results: ActionResult[];
+        parentCallId?: string;
+        modelCallId?: string;
       };
     }
   | {
@@ -2678,8 +2718,9 @@ export interface ArtifactsConfig {
    */
   agentTool?: boolean;
   /**
-   * Retention cap (default 1000). On insert past the cap, the
-   * oldest-updated artifact is evicted.
+   * Retention cap (default 1000). Architecture v1 and self-hosted v2
+   * evict the oldest-updated artifact on insert past the cap. Hosted
+   * architecture v2 does not evict; the installation store keeps every row.
    */
   max?: number;
 }