@cursor/bdk 0.2.2 → 0.2.4

package/src/internal/event-mapper.ts

@@ -1,811 +0,0 @@
-/**
- * Maps the Cursor harness's streaming delta vocabulary
- * (`InteractionUpdate`) onto the framework's channel event vocabulary
- * (`SessionEvent` payloads). One mapper instance covers one turn.
- */
-
-import type { InteractionUpdate as SdkInteractionUpdate, ToolCall } from "@cursor/sdk";
-import type { ActionCall, ActionResult, SessionEventPayload, TurnUsage } from "../types.js";
-
-const CUSTOM_TOOLS_PROVIDER = "custom-user-tools";
-/** Authored server tools on cloud turns; keep in sync with `SERVER_TOOLS_MCP_SERVER_NAME`. */
-const SERVER_TOOLS_PROVIDER = "agentsdk-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: "tool-requests-listed"; callCount: number };
-
-type ToolCallDeltaUpdate = {
-  type: "tool-call-delta";
-  callId: string;
-  modelCallId: string;
-  taskUpdate: NestedTaskUpdate;
-};
-
-type ToolRequestsListedUpdate = {
-  type: "tool-requests-listed";
-  callCount: number;
-};
-
-/** SDK updates plus list-closed / nested task deltas ahead of `@cursor/sdk`. */
-type InteractionUpdate = SdkInteractionUpdate | ToolCallDeltaUpdate | ToolRequestsListedUpdate;
-
-function asToolCallDelta(update: InteractionUpdate): ToolCallDeltaUpdate | undefined {
-  if ((update as { type: string }).type !== "tool-call-delta") {
-    return undefined;
-  }
-  return update as ToolCallDeltaUpdate;
-}
-
-function modelCallIdOf(update: { modelCallId?: unknown }): string | undefined {
-  return typeof update.modelCallId === "string" && update.modelCallId !== ""
-    ? update.modelCallId
-    : undefined;
-}
-
-export interface ToolCallDescription {
-  toolName: string;
-  args?: unknown;
-  subagent?: { name?: string; description?: string };
-}
-
-export interface ToolResultDescription {
-  output?: unknown;
-  isError: boolean;
-}
-
-interface NestedAccumulators {
-  text: string;
-  reasoning: string;
-}
-
-type ToolWave = {
-  key: string;
-  modelCallId?: string;
-  parentCallId?: string;
-  calls: ActionCall[];
-  results: ActionResult[];
-  expectedCalls?: number;
-  requestedEmitted: boolean;
-  completedEmitted: boolean;
-};
-
-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>();
-  /** One wave per model step (or per call when the step id is missing). */
-  private readonly waves = new Map<string, ToolWave>();
-  /**
-   * Keys of waves that already emitted `actions.completed`, plus each
-   * finished call's singleton key. A late duplicate cannot reopen the
-   * batch or emit a second pair for the same callId. A new late callId
-   * still gets its own singleton.
-   */
-  private readonly sealedWaveKeys = new Set<string>();
-  /** Listed-call count from `tool-requests-listed`, keyed by parentCallId. */
-  private readonly listedCounts = new Map<string, number>();
-
-  /**
-   * @param isStubbed Reports whether a finished tool call was answered by the
-   * host rather than executed. The harness reports an answered call exactly
-   * like a real one, so the engine is the only place that knows.
-   */
-  constructor(
-    private readonly emit: (payload: SessionEventPayload) => void,
-    private readonly isStubbed: (callId: string) => boolean = () => false,
-  ) {}
-
-  /** Per-turn token usage summed across model steps. */
-  get usage(): TurnUsage | undefined {
-    return this.usageTotal;
-  }
-
-  /** The final assistant text block of the turn, when one was produced. */
-  get finalText(): string | undefined {
-    return this.lastAssistantText;
-  }
-
-  /**
-   * Unflushed `text-delta` buffer, else the last completed parent block.
-   * Used to recover a text-only run that has not yet emitted
-   * `message.completed`.
-   */
-  get pendingText(): string | undefined {
-    if (this.textAccumulator !== "") {
-      return this.textAccumulator;
-    }
-    return this.lastAssistantText;
-  }
-
-  /**
-   * Drop streamed parent text so a same-turn repair does not concatenate
-   * or recommit the rejected attempt. Does not emit.
-   */
-  clearPendingText(): void {
-    this.textAccumulator = "";
-    this.lastAssistantText = undefined;
-  }
-
-  /**
-   * Drop rejected parent text and emit an empty `stop` `message.completed`.
-   * Slack `finalizeEmpty`s the open stream so a repair starts a new one
-   * instead of appending onto the rejected block. Origin/GitHub skip
-   * empty text and do not post.
-   */
-  abandonPendingText(): void {
-    this.clearPendingText();
-    this.emit({
-      type: "message.completed",
-      data: { text: "", finishReason: "stop" },
-    });
-  }
-
-  /** Conversation summary produced by the harness (used as session title). */
-  get title(): string | undefined {
-    return this.summaryTitle;
-  }
-
-  handleUpdate(update: InteractionUpdate): void {
-    switch (update.type) {
-      case "text-delta": {
-        this.textAccumulator += update.text;
-        this.emit({
-          type: "message.appended",
-          data: { delta: update.text, text: this.textAccumulator },
-        });
-        return;
-      }
-      case "thinking-delta": {
-        this.reasoningAccumulator += update.text;
-        this.emit({
-          type: "reasoning.appended",
-          data: { delta: update.text, text: this.reasoningAccumulator },
-        });
-        return;
-      }
-      case "thinking-completed": {
-        if (this.reasoningAccumulator !== "") {
-          this.reasoningAccumulator = "";
-        }
-        this.emit({
-          type: "reasoning.completed",
-          data: { durationMs: update.thinkingDurationMs },
-        });
-        return;
-      }
-      case "tool-call-started": {
-        this.flushAssistantText("tool_call");
-        this.noteToolStarted(update.callId, update.toolCall, {
-          modelCallId: modelCallIdOf(update),
-        });
-        return;
-      }
-      case "tool-call-completed": {
-        this.noteToolCompleted(update.callId, update.toolCall, {
-          modelCallId: modelCallIdOf(update),
-        });
-        return;
-      }
-      case "step-started": {
-        this.emit({ type: "step.started", data: { stepId: update.stepId } });
-        return;
-      }
-      case "tool-requests-listed": {
-        this.noteRequestsListed(undefined, update.callCount);
-        return;
-      }
-      case "step-completed": {
-        this.emit({
-          type: "step.completed",
-          data: { stepId: update.stepId, durationMs: update.stepDurationMs },
-        });
-        return;
-      }
-      case "turn-ended": {
-        if (update.usage !== undefined) {
-          this.usageTotal = addUsage(this.usageTotal, update.usage);
-        }
-        return;
-      }
-      case "summary": {
-        this.summaryTitle = update.summary;
-        return;
-      }
-      case "user-message-appended":
-      case "partial-tool-call":
-      case "token-delta":
-      case "summary-started":
-      case "summary-completed":
-      case "shell-output-delta":
-        return;
-      default: {
-        // 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;
-      }
-    }
-  }
-
-  /** Close out the turn: finalize any open assistant text block. */
-  finish(): void {
-    this.sealOpenRequests();
-    this.flushOpenResults();
-    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.noteToolStarted(update.callId, update.toolCall, {
-          parentCallId,
-          modelCallId: modelCallIdOf(update),
-        });
-        return;
-      }
-      case "tool-call-completed": {
-        this.noteToolCompleted(update.callId, update.toolCall, {
-          parentCallId,
-          modelCallId: modelCallIdOf(update),
-        });
-        return;
-      }
-      case "partial-tool-call":
-        return;
-      case "step-started":
-        return;
-      case "tool-requests-listed":
-        this.noteRequestsListed(parentCallId, update.callCount);
-        return;
-      case "step-completed":
-        return;
-      default: {
-        return;
-      }
-    }
-  }
-
-  private noteToolStarted(
-    callId: string,
-    toolCall: ToolCall,
-    ids?: { parentCallId?: string; modelCallId?: string },
-  ): void {
-    const parentCallId = ids?.parentCallId;
-    const modelCallId = ids?.modelCallId;
-    const description = describeToolCall(toolCall);
-    const call: ActionCall = {
-      callId,
-      toolName: description.toolName,
-      args: description.args,
-      parentCallId,
-      modelCallId,
-    };
-    if (modelCallId !== undefined) {
-      this.sealOpenRequests({
-        parentCallId,
-        exceptModelCallId: modelCallId,
-      });
-    }
-    const wave = this.waveForStart({ parentCallId, modelCallId, callId });
-    if (wave === undefined) {
-      return;
-    }
-    if (wave.calls.every(existing => existing.callId !== callId)) {
-      wave.calls.push(call);
-    }
-    this.adoptSingletonResults(wave, parentCallId, callId);
-    this.maybeSealListedWave(wave);
-    // 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,
-        },
-      });
-    }
-    if (wave.modelCallId === undefined) {
-      this.sealWaveRequests(wave);
-    }
-  }
-
-  private noteToolCompleted(
-    callId: string,
-    toolCall: ToolCall,
-    ids?: { parentCallId?: string; modelCallId?: string },
-  ): void {
-    const parentCallId = ids?.parentCallId;
-    const modelCallId = ids?.modelCallId;
-    const description = describeToolCall(toolCall);
-    const result = describeToolResult(toolCall);
-    const actionResult: ActionResult = {
-      callId,
-      toolName: description.toolName,
-      output: result.output,
-      isError: result.isError,
-      stubbed: this.isStubbed(callId) ? true : undefined,
-      parentCallId,
-      modelCallId,
-    };
-    const wave = this.waveForComplete({ parentCallId, modelCallId, callId });
-    if (wave === undefined) {
-      return;
-    }
-    const isNew = wave.results.every(existing => existing.callId !== callId);
-    if (isNew) {
-      wave.results.push(actionResult);
-    }
-    if (wave.requestedEmitted && isNew) {
-      this.emit({
-        type: "action.result",
-        data: actionResult,
-      });
-      this.maybeEmitActionsCompleted(wave);
-    }
-    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 callBelongsToWave(wave: ToolWave, callId: string): boolean {
-    return (
-      wave.calls.some(existing => existing.callId === callId) ||
-      wave.results.some(existing => existing.callId === callId)
-    );
-  }
-
-  private singletonWave(parentCallId: string | undefined, callId: string): ToolWave | undefined {
-    const key = waveKey({ parentCallId, callId });
-    if (this.sealedWaveKeys.has(key) && !this.waves.has(key)) {
-      return undefined;
-    }
-    return this.ensureWave(key, { parentCallId });
-  }
-
-  /**
-   * Starts join the open model-step wave until `actions.requested` seals.
-   * A later start for that same step is its own singleton pair so completed
-   * cannot list tools the matching requested envelope never had.
-   */
-  private waveForStart(ids: {
-    parentCallId?: string;
-    modelCallId?: string;
-    callId: string;
-  }): ToolWave | undefined {
-    const groupedKey = waveKey(ids);
-    const grouped = this.waves.get(groupedKey);
-    if (grouped !== undefined && !grouped.requestedEmitted) {
-      return grouped;
-    }
-    if (grouped !== undefined && this.callBelongsToWave(grouped, ids.callId)) {
-      return grouped;
-    }
-    if (grouped !== undefined && grouped.requestedEmitted) {
-      return this.singletonWave(ids.parentCallId, ids.callId);
-    }
-    if (this.sealedWaveKeys.has(groupedKey)) {
-      return this.singletonWave(ids.parentCallId, ids.callId);
-    }
-    return this.ensureWave(groupedKey, {
-      modelCallId: ids.modelCallId,
-      parentCallId: ids.parentCallId,
-    });
-  }
-
-  /**
-   * Completes join a model-step wave only when that call already started
-   * there. A start-less complete on an open sibling batch would flush with
-   * `actions.requested` and then block `actions.completed` forever.
-   */
-  private waveForComplete(ids: {
-    parentCallId?: string;
-    modelCallId?: string;
-    callId: string;
-  }): ToolWave | undefined {
-    const groupedKey = waveKey(ids);
-    const grouped = this.waves.get(groupedKey);
-    if (grouped !== undefined && this.callBelongsToWave(grouped, ids.callId)) {
-      return grouped;
-    }
-    if (grouped !== undefined) {
-      return this.singletonWave(ids.parentCallId, ids.callId);
-    }
-    if (this.sealedWaveKeys.has(groupedKey)) {
-      return this.waves.get(waveKey({ parentCallId: ids.parentCallId, callId: ids.callId }));
-    }
-    return this.ensureWave(groupedKey, {
-      modelCallId: ids.modelCallId,
-      parentCallId: ids.parentCallId,
-    });
-  }
-
-  private adoptSingletonResults(
-    wave: ToolWave,
-    parentCallId: string | undefined,
-    callId: string,
-  ): void {
-    const singletonKey = waveKey({ parentCallId, callId });
-    if (singletonKey === wave.key) {
-      return;
-    }
-    const singleton = this.waves.get(singletonKey);
-    if (singleton === undefined) {
-      return;
-    }
-    for (const result of singleton.results) {
-      if (wave.results.every(existing => existing.callId !== result.callId)) {
-        wave.results.push(result);
-      }
-    }
-    this.waves.delete(singletonKey);
-  }
-
-  private ensureWave(key: string, ids: { modelCallId?: string; parentCallId?: string }): ToolWave {
-    let wave = this.waves.get(key);
-    if (wave === undefined) {
-      const expectedCalls = this.listedCounts.get(ids.parentCallId ?? "");
-      wave = {
-        key,
-        modelCallId: ids.modelCallId,
-        parentCallId: ids.parentCallId,
-        expectedCalls,
-        calls: [],
-        results: [],
-        requestedEmitted: false,
-        completedEmitted: false,
-      };
-      this.waves.set(key, wave);
-    }
-    return wave;
-  }
-
-  private noteRequestsListed(parentCallId: string | undefined, callCount: number): void {
-    const listed = Math.max(0, callCount);
-    if (listed === 0) {
-      this.sealOpenRequests({ parentCallId });
-      this.listedCounts.delete(parentCallId ?? "");
-      return;
-    }
-    this.listedCounts.set(parentCallId ?? "", listed);
-    for (const wave of this.waves.values()) {
-      if (wave.parentCallId !== parentCallId || wave.requestedEmitted) {
-        continue;
-      }
-      wave.expectedCalls = listed;
-      this.maybeSealListedWave(wave);
-    }
-  }
-
-  private maybeSealListedWave(wave: ToolWave): void {
-    const expected = wave.expectedCalls ?? this.listedCounts.get(wave.parentCallId ?? "");
-    if (expected !== undefined && wave.calls.length >= expected) {
-      this.sealWaveRequests(wave);
-    }
-  }
-
-  private sealOpenRequests(ids?: { parentCallId?: string; exceptModelCallId?: string }): void {
-    const parentCallId = ids?.parentCallId;
-    const exceptModelCallId = ids?.exceptModelCallId;
-    for (const wave of this.waves.values()) {
-      if (wave.parentCallId !== parentCallId) {
-        continue;
-      }
-      if (exceptModelCallId !== undefined && wave.modelCallId === exceptModelCallId) {
-        continue;
-      }
-      this.sealWaveRequests(wave);
-    }
-  }
-
-  private sealWaveRequests(wave: ToolWave): void {
-    if (wave.requestedEmitted || wave.calls.length === 0) {
-      return;
-    }
-    wave.requestedEmitted = true;
-    this.listedCounts.delete(wave.parentCallId ?? "");
-    this.emit({
-      type: "actions.requested",
-      data: {
-        calls: wave.calls,
-        parentCallId: wave.parentCallId,
-        modelCallId: wave.modelCallId,
-      },
-    });
-    for (const result of wave.results) {
-      this.emit({
-        type: "action.result",
-        data: result,
-      });
-    }
-    this.maybeEmitActionsCompleted(wave);
-  }
-
-  private maybeEmitActionsCompleted(wave: ToolWave): void {
-    if (
-      wave.completedEmitted ||
-      !wave.requestedEmitted ||
-      wave.calls.length === 0 ||
-      wave.results.length < wave.calls.length
-    ) {
-      return;
-    }
-    const callIds = new Set(wave.calls.map(call => call.callId));
-    if (!wave.results.every(result => callIds.has(result.callId))) {
-      return;
-    }
-    if (!wave.calls.every(call => wave.results.some(result => result.callId === call.callId))) {
-      return;
-    }
-    this.emitActionsCompleted(wave);
-  }
-
-  private emitActionsCompleted(wave: ToolWave): void {
-    wave.completedEmitted = true;
-    this.emit({
-      type: "actions.completed",
-      data: {
-        results: wave.results,
-        parentCallId: wave.parentCallId,
-        modelCallId: wave.modelCallId,
-      },
-    });
-    this.forgetWave(wave);
-  }
-
-  private forgetWave(wave: ToolWave): void {
-    this.waves.delete(wave.key);
-    this.sealedWaveKeys.add(wave.key);
-    for (const callId of new Set([
-      ...wave.calls.map(call => call.callId),
-      ...wave.results.map(result => result.callId),
-    ])) {
-      this.sealedWaveKeys.add(waveKey({ parentCallId: wave.parentCallId, callId }));
-    }
-    wave.calls = [];
-    wave.results = [];
-  }
-
-  private flushOpenResults(): void {
-    for (const wave of [...this.waves.values()]) {
-      if (wave.calls.length === 0 && wave.results.length > 0) {
-        wave.calls = wave.results.map(result => ({
-          callId: result.callId,
-          toolName: result.toolName,
-          parentCallId: result.parentCallId,
-          modelCallId: result.modelCallId,
-        }));
-      }
-      this.sealWaveRequests(wave);
-      this.maybeEmitActionsCompleted(wave);
-      if (!wave.completedEmitted) {
-        this.forgetWave(wave);
-      }
-    }
-  }
-
-  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 {
-    if (this.textAccumulator === "") {
-      return;
-    }
-    const text = this.textAccumulator;
-    this.textAccumulator = "";
-    this.lastAssistantText = text;
-    this.emit({
-      type: "message.completed",
-      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 },
-    });
-  }
-}
-
-/**
- * Human-meaningful tool identity for stream events. Authored server tools
- * arrive as MCP calls against `custom-user-tools` (local) or `agentsdk-tools`
- * (cloud); both surface under the customer's bare tool name.
- */
-export function describeToolCall(toolCall: ToolCall): ToolCallDescription {
-  switch (toolCall.type) {
-    case "mcp": {
-      const providerIdentifier = toolCall.args.providerIdentifier;
-      const toolName = toolCall.args.toolName;
-      if (
-        providerIdentifier === CUSTOM_TOOLS_PROVIDER ||
-        providerIdentifier === SERVER_TOOLS_PROVIDER
-      ) {
-        return {
-          toolName: toolName ?? "custom-tool",
-          args: toolCall.args.args,
-        };
-      }
-      const bareName = toolName ?? "tool";
-      return {
-        toolName:
-          providerIdentifier === undefined || providerIdentifier === ""
-            ? bareName
-            : `${providerIdentifier}:${bareName}`,
-        args: toolCall.args.args,
-      };
-    }
-    case "task": {
-      const subagentType = toolCall.args.subagentType;
-      const subagentName = subagentType?.name ?? subagentType?.kind;
-      return {
-        toolName: "task",
-        args: {
-          description: toolCall.args.description,
-          subagentType: subagentName,
-        },
-        subagent: {
-          name: subagentName,
-          description: toolCall.args.description,
-        },
-      };
-    }
-    default: {
-      return {
-        toolName: toolCall.type,
-        args: (toolCall as { args?: unknown }).args,
-      };
-    }
-  }
-}
-
-export function describeToolResult(toolCall: ToolCall): ToolResultDescription {
-  const result = (toolCall as { result?: unknown }).result as
-    | { status: "success"; value: unknown }
-    | { status: "error"; error: unknown }
-    | undefined;
-  if (result === undefined || result === null) {
-    return { isError: false };
-  }
-  if (result.status === "error") {
-    return { output: result.error, isError: true };
-  }
-
-  if (toolCall.type === "mcp") {
-    const value = result.value as {
-      content?: Array<{ text?: { text: string } }>;
-      isError?: boolean;
-    };
-    const text = (value.content ?? [])
-      .map(item => item.text?.text ?? "")
-      .filter(part => part !== "")
-      .join("\n");
-    return {
-      output: text === "" ? value : text,
-      isError: value.isError === true,
-    };
-  }
-
-  return { output: result.value, isError: false };
-}
-
-function waveKey(ids: { parentCallId?: string; modelCallId?: string; callId: string }): string {
-  return `${ids.parentCallId ?? ""}:${ids.modelCallId ?? `call:${ids.callId}`}`;
-}
-
-function addUsage(total: TurnUsage | undefined, usage: TurnUsage): TurnUsage {
-  if (total === undefined) {
-    return { ...usage };
-  }
-  return {
-    inputTokens: total.inputTokens + usage.inputTokens,
-    outputTokens: total.outputTokens + usage.outputTokens,
-    cacheReadTokens: total.cacheReadTokens + usage.cacheReadTokens,
-    cacheWriteTokens: total.cacheWriteTokens + usage.cacheWriteTokens,
-    ...(total.reasoningTokens !== undefined || usage.reasoningTokens !== undefined
-      ? {
-          reasoningTokens: (total.reasoningTokens ?? 0) + (usage.reasoningTokens ?? 0),
-        }
-      : {}),
-  };
-}