@love-moon/ai-sdk 0.15.2 → 0.16.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @love-moon/ai-sdk
 
+## 0.16.0
+
+### Patch Changes
+
+- 5c81d06: Claude turns that wait on background subagents now report their full token
+  usage. Such a turn emits one result per segment and the task card used to show
+  only the last segment; it now sums the result's `modelUsage`, which covers
+  every segment, every subagent and small side calls. `conductor serve-ai`'s
+  `prompt_tokens` / `completion_tokens` come from the same usage, so they now
+  include those too. A turn cut off after an earlier segment keeps that
+  segment's usage.
+- b69d665: Codex turns that spawn sub-agents now include the sub-agents' tokens in the
+  turn usage. Their `thread/tokenUsage/updated` notifications carry the
+  sub-agent's own thread id and were dropped with its other events. A
+  sub-agent's replayed total is not counted, and whatever it spends after the
+  parent turn ends goes to the next turn.
+
 ## 0.15.2
 
 ## 0.15.1

package/dist/providers/claude-agent-sdk-session.js

@@ -32,12 +32,15 @@ function createTurnError(message, extras = {}) {
     }
     return error;
 }
-/** Per-turn usage summed from streamed assistant messages (one entry per API response). */
-function sumStreamedUsage(usageByMessageId) {
+/**
+ * Per-turn usage summed from streamed assistant messages (one entry per API
+ * response), on top of `base` (what an earlier result of the turn covered).
+ */
+function sumStreamedUsage(usageByMessageId, base = null) {
     if (!usageByMessageId.size) {
-        return null;
+        return base;
     }
-    const total = {};
+    const total = { ...base };
     for (const usage of usageByMessageId.values()) {
         for (const key of ["input_tokens", "cache_creation_input_tokens", "cache_read_input_tokens", "output_tokens"]) {
             const value = Number(usage?.[key]);
@@ -48,6 +51,31 @@ function sumStreamedUsage(usageByMessageId) {
     }
     return total;
 }
+/**
+ * A finished turn's usage. A turn that waits on background tasks emits one result per
+ * segment, and `usage` covers only the last one; `modelUsage` accumulates every API call
+ * the query's process made (all segments and subagents), so prefer its sum.
+ */
+function resultUsage(resultMessage) {
+    const total = {};
+    for (const entry of Object.values(resultMessage.modelUsage || {})) {
+        for (const [from, to] of [
+            ["inputTokens", "input_tokens"],
+            ["cacheCreationInputTokens", "cache_creation_input_tokens"],
+            ["cacheReadInputTokens", "cache_read_input_tokens"],
+            ["outputTokens", "output_tokens"],
+        ]) {
+            const value = Number(entry?.[from]);
+            if (Number.isFinite(value)) {
+                total[to] = (total[to] || 0) + value;
+            }
+        }
+    }
+    if (Object.keys(total).length) {
+        return total;
+    }
+    return resultMessage.usage ? { ...resultMessage.usage } : null;
+}
 function normalizeClaudeBackend(backend) {
     const normalized = String(backend || "").trim().toLowerCase();
     if (normalized === "claude-code") {
@@ -853,6 +881,8 @@ export class ClaudeAgentSdkSession extends EventEmitter {
                 this.updateSessionInfo(message.session_id || message.sessionId);
                 this.lastResult = message;
                 currentTurn.resultMessage = message;
+                // Its modelUsage covers everything streamed so far.
+                currentTurn.usageByMessageId.clear();
                 return;
             default:
                 return;
@@ -982,7 +1012,7 @@ export class ClaudeAgentSdkSession extends EventEmitter {
                         ? [...resultMessage.permission_denials]
                         : [],
                     // A failed turn still spent tokens.
-                    usage: resultMessage.usage ? { ...resultMessage.usage } : null,
+                    usage: resultUsage(resultMessage),
                 });
             }
             const structuredOutput = jsonSchema && resultMessage.structured_output && typeof resultMessage.structured_output === "object"
@@ -1007,7 +1037,7 @@ export class ClaudeAgentSdkSession extends EventEmitter {
             }, onProgress);
             return {
                 text: responseText,
-                usage: resultMessage.usage ? { ...resultMessage.usage } : null,
+                usage: resultUsage(resultMessage),
                 items: currentTurn.items,
                 events: [],
                 provider: this.backend,
@@ -1027,8 +1057,9 @@ export class ClaudeAgentSdkSession extends EventEmitter {
         }
         catch (error) {
             // A failed turn still spent tokens; an interrupted query ends without a
-            // result, so fall back to the usage streamed so far.
-            const usage = error?.usage ?? sumStreamedUsage(currentTurn.usageByMessageId);
+            // (final) result, so fall back to the last result plus what streamed since.
+            const usage = error?.usage ??
+                sumStreamedUsage(currentTurn.usageByMessageId, currentTurn.resultMessage ? resultUsage(currentTurn.resultMessage) : null);
             if (error?.reason === "turn_timeout") {
                 await this.interruptCurrentTurn();
             }

package/dist/providers/codex-app-server-session.d.ts

@@ -46,6 +46,10 @@ export class CodexAppServerSession extends EventEmitter<[never]> {
         totalTokens: number;
     } | null;
     turnTokensSeen: boolean;
+    subThreadTokenTotals: Map<any, any>;
+    subThreadTokenBaselines: Map<any, any>;
+    subThreadTokensReported: Map<any, any>;
+    subThreadTurnIds: Map<any, any>;
     currentTurnStatus: any;
     currentTurnActivityAt: number;
     now: any;
@@ -160,6 +164,12 @@ export class CodexAppServerSession extends EventEmitter<[never]> {
     applySessionConfigured(params: any): void;
     /** Start counting a turn's tokens from the thread total known right now. */
     beginTurnTokenAccounting(): void;
+    /**
+     * Track a spawned sub-agent thread's total. Its first update fixes its
+     * baseline: `total - last`, or the whole total when it is a replay (a turn id
+     * we never saw start), like the main thread's after thread/resume.
+     */
+    noteSubThreadTokenUsage(threadId: any, { turnId, tokenUsage }?: {}): void;
     /**
      * Thread token usage plus `turnTotalTokens` (and its `turnInputTokens` /
      * `turnCachedInputTokens` split): tokens spent since the current turn (or

package/dist/providers/codex-app-server-session.js

@@ -88,6 +88,15 @@ function subtractTokenCounts(a, b) {
             : {}),
     };
 }
+function addTokenCounts(a, b) {
+    const split = a.inputTokens !== undefined && b.inputTokens !== undefined;
+    return {
+        totalTokens: a.totalTokens + b.totalTokens,
+        ...(split
+            ? { inputTokens: a.inputTokens + b.inputTokens, cachedInputTokens: a.cachedInputTokens + b.cachedInputTokens }
+            : {}),
+    };
+}
 /**
  * Adds tokens spent outside the reported attempt (an overflowed first try) to a
  * turn result or error. Only the total grows: the input split, and so the cache
@@ -276,6 +285,13 @@ export class CodexAppServerSession extends EventEmitter {
         // its own usage has arrived since; see snapshotTokenUsage().
         this.turnTokenBaseline = null;
         this.turnTokensSeen = false;
+        // Spawned sub-agent threads report their own thread totals: the latest one
+        // per thread, the part already counted (or not theirs to count), what the
+        // last snapshot reported, and each thread's running turn id.
+        this.subThreadTokenTotals = new Map();
+        this.subThreadTokenBaselines = new Map();
+        this.subThreadTokensReported = new Map();
+        this.subThreadTurnIds = new Map();
         this.currentTurnStatus = null;
         this.currentTurnActivityAt = 0;
         this.now = typeof options.now === "function" ? options.now : () => Date.now();
@@ -533,6 +549,28 @@ export class CodexAppServerSession extends EventEmitter {
     beginTurnTokenAccounting() {
         this.turnTokenBaseline = readTokenCounts(this.tokenUsage?.total);
         this.turnTokensSeen = false;
+        // What the previous turn reported is counted; sub-agent spend after that
+        // (including between turns) goes to this one.
+        for (const [threadId, reported] of this.subThreadTokensReported) {
+            this.subThreadTokenBaselines.set(threadId, reported);
+        }
+        this.subThreadTokensReported = new Map();
+    }
+    /**
+     * Track a spawned sub-agent thread's total. Its first update fixes its
+     * baseline: `total - last`, or the whole total when it is a replay (a turn id
+     * we never saw start), like the main thread's after thread/resume.
+     */
+    noteSubThreadTokenUsage(threadId, { turnId, tokenUsage } = {}) {
+        const total = readTokenCounts(tokenUsage?.total);
+        if (!total) {
+            return;
+        }
+        if (!this.subThreadTokenBaselines.has(threadId)) {
+            const replay = !turnId || turnId !== this.subThreadTurnIds.get(threadId);
+            this.subThreadTokenBaselines.set(threadId, replay ? total : subtractTokenCounts(total, readTokenCounts(tokenUsage.last)));
+        }
+        this.subThreadTokenTotals.set(threadId, total);
     }
     /**
      * Thread token usage plus `turnTotalTokens` (and its `turnInputTokens` /
@@ -545,9 +583,17 @@ export class CodexAppServerSession extends EventEmitter {
         if (!this.tokenUsage) {
             return null;
         }
-        const turn = this.turnTokensSeen
+        let turn = this.turnTokensSeen
             ? subtractTokenCounts(readTokenCounts(this.tokenUsage.total), this.turnTokenBaseline)
             : null;
+        for (const [threadId, baseline] of this.subThreadTokenBaselines) {
+            const latest = this.subThreadTokenTotals.get(threadId);
+            const spent = subtractTokenCounts(latest, baseline);
+            if (spent) {
+                turn = turn ? addTokenCounts(turn, spent) : spent;
+                this.subThreadTokensReported.set(threadId, latest);
+            }
+        }
         return {
             ...this.tokenUsage,
             ...(turn
@@ -625,6 +671,10 @@ export class CodexAppServerSession extends EventEmitter {
         this.tokenUsage = null;
         this.turnTokenBaseline = null;
         this.turnTokensSeen = false;
+        this.subThreadTokenTotals = new Map();
+        this.subThreadTokenBaselines = new Map();
+        this.subThreadTokensReported = new Map();
+        this.subThreadTurnIds = new Map();
         this.booted = false;
         this.bootPromise = null;
     }
@@ -914,6 +964,12 @@ export class CodexAppServerSession extends EventEmitter {
         const threadId = typeof params?.threadId === "string" ? params.threadId.trim() : "";
         if (threadId && this.sessionId && threadId !== this.sessionId) {
             this.touchTurnActivity();
+            if (method === "turn/started" && typeof params?.turn?.id === "string") {
+                this.subThreadTurnIds.set(threadId, params.turn.id);
+            }
+            else if (method === "thread/tokenUsage/updated") {
+                this.noteSubThreadTokenUsage(threadId, params);
+            }
             return;
         }
         switch (method) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/ai-sdk",
-  "version": "0.15.2",
+  "version": "0.16.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lovemoon-ai/conductor.git"
@@ -53,12 +53,12 @@
     "zod": "^4.1.5"
   },
   "optionalDependencies": {
-    "@love-moon/chat-web": "^0.15.2"
+    "@love-moon/chat-web": "^0.16.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
     "tsx": "^4.20.6",
     "typescript": "^5.6.3"
   },
-  "gitCommitId": "f795a61"
+  "gitCommitId": "77239b9"
 }