@caupulican/pi-adaptative 0.80.57 → 0.80.58

package/dist/core/agent-session.js

@@ -59,6 +59,8 @@ export function parseSkillBlock(text) {
         userMessage: match[4]?.trim() || undefined,
     };
 }
+/** customType for spawned-usage roll-up entries (Cost Aggregation, Model A). */
+export const SPAWNED_USAGE_CUSTOM_TYPE = "spawned_usage";
 // ============================================================================
 // Constants
 // ============================================================================
@@ -2082,6 +2084,9 @@ export class AgentSession {
             setThinkingLevel: (level) => this.setThinkingLevel(level),
             getExternalResourceRoots: () => this.settingsManager.getEffectiveExternalResourceRoots(),
             registerMemoryProvider: (provider) => this.registerMemoryProvider(provider),
+            reportSpawnedUsage: (usage, opts) => {
+                this.addSpawnedUsage(usage, opts);
+            },
         }, {
             getModel: () => this.model,
             isIdle: () => !this.isStreaming,
@@ -3089,6 +3094,116 @@ export class AgentSession {
             contextUsage: this.getContextUsage(),
         };
     }
+    /**
+     * Cumulative usage (full breakdown) for this session's entire spawn subtree: its own
+     * assistant messages PLUS every `spawned_usage` report it has rolled up. Single source of
+     * truth for "how much did this session and everything it spawned spend" — used by print-mode
+     * to emit a child's total so a spawner can roll it up via {@link addSpawnedUsage}.
+     *
+     * Including the `spawned_usage` reports is what keeps the single-hop invariant intact: a child
+     * that itself spawned grandchildren must report own + sub-usage in one number, or the parent
+     * silently under-counts the grandchildren.
+     */
+    getCumulativeUsage() {
+        let input = 0;
+        let output = 0;
+        let cacheRead = 0;
+        let cacheWrite = 0;
+        let totalTokens = 0;
+        let costInput = 0;
+        let costOutput = 0;
+        let costCacheRead = 0;
+        let costCacheWrite = 0;
+        let costTotal = 0;
+        const add = (usage) => {
+            input += usage.input;
+            output += usage.output;
+            cacheRead += usage.cacheRead;
+            cacheWrite += usage.cacheWrite;
+            totalTokens += usage.totalTokens;
+            costInput += usage.cost.input;
+            costOutput += usage.cost.output;
+            costCacheRead += usage.cost.cacheRead;
+            costCacheWrite += usage.cost.cacheWrite;
+            costTotal += usage.cost.total;
+        };
+        for (const message of this.state.messages) {
+            if (message.role !== "assistant")
+                continue;
+            const usage = message.usage;
+            if (!usage)
+                continue;
+            add(usage);
+        }
+        // Roll up usage this session attributed to its own spawned children (single-hop).
+        for (const entry of this.sessionManager.getEntries()) {
+            if (entry.type !== "custom" || entry.customType !== SPAWNED_USAGE_CUSTOM_TYPE)
+                continue;
+            const data = entry.data;
+            if (data?.usage)
+                add(data.usage);
+        }
+        return {
+            input,
+            output,
+            cacheRead,
+            cacheWrite,
+            totalTokens,
+            cost: {
+                input: costInput,
+                output: costOutput,
+                cacheRead: costCacheRead,
+                cacheWrite: costCacheWrite,
+                total: costTotal,
+            },
+        };
+    }
+    /**
+     * Record usage spent by a spawned/subagent session so the footer can roll it into the
+     * displayed cost. Persisted as a `CustomEntry` (`customType: "spawned_usage"`, Model A) so
+     * it survives reload and is reconstructed exactly like main usage; a new/forked session
+     * starts fresh because it owns a new log file.
+     *
+     * Idempotent on `opts.reportId`: a re-report (retry, duplicate `agent_end`) with a
+     * previously-seen id is ignored, so cost cannot be double-counted. Honors the single-hop
+     * invariant documented on {@link SpawnedUsageReport}.
+     *
+     * @returns the id of the appended entry, or `undefined` if the report was a duplicate.
+     */
+    addSpawnedUsage(usage, opts) {
+        const reportId = opts?.reportId;
+        if (reportId) {
+            for (const entry of this.sessionManager.getEntries()) {
+                if (entry.type === "custom" &&
+                    entry.customType === SPAWNED_USAGE_CUSTOM_TYPE &&
+                    entry.data?.reportId === reportId) {
+                    return undefined;
+                }
+            }
+        }
+        const report = {
+            usage,
+            label: opts?.label,
+            sourceSessionId: opts?.sourceSessionId,
+            reportId,
+        };
+        return this.sessionManager.appendCustomEntry(SPAWNED_USAGE_CUSTOM_TYPE, report);
+    }
+    /** Aggregate all recorded spawned-usage reports (see {@link addSpawnedUsage}). */
+    getSpawnedUsage() {
+        let cost = 0;
+        let reports = 0;
+        for (const entry of this.sessionManager.getEntries()) {
+            if (entry.type !== "custom" || entry.customType !== SPAWNED_USAGE_CUSTOM_TYPE)
+                continue;
+            const data = entry.data;
+            if (!data?.usage)
+                continue;
+            cost += data.usage.cost.total;
+            reports += 1;
+        }
+        return { cost, reports };
+    }
     getContextUsage() {
         const model = this.model;
         if (!model)