@mduan/paseo-cli 0.11.0-fork.1 → 0.11.0-fork.3

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/claude/subagents/live-source.js

@@ -1,3 +1,4 @@
+import { rollupProviderSubagentCosts } from "../../../provider-subagents/cost.js";
 import { resolveObservedClaudeModelId } from "../models.js";
 import { buildClaudeSubagentSubtitle, } from "./presentation.js";
 /** Task-tool subagents. Backgrounded shell commands announce as `local_bash`. */
@@ -85,6 +86,8 @@ export class ClaudeTaskProtocolSource {
         this.lastStatusById = new Map();
         /** Claude facts stay inside the provider boundary; clients receive one compact subtitle. */
         this.presentationById = new Map();
+        this.parentSubagentIdById = new Map();
+        this.directCostUsdById = new Map();
         this.lastSubtitleById = new Map();
         this.sawTaskStarted = false;
         this.sawAnyTask = false;
@@ -111,6 +114,9 @@ export class ClaudeTaskProtocolSource {
     get announcesTasks() {
         return this.sawAnyTask;
     }
+    get costTaskIds() {
+        return new Set(this.subagentIdByTaskId.keys());
+    }
     /**
      * Whether this source declared the given subagent. Callers route frames through this before
      * attributing anything to an id: a frame for a task that was never declared belongs to work
@@ -172,6 +178,8 @@ export class ClaudeTaskProtocolSource {
         this.backgroundedIds.clear();
         this.lastStatusById.clear();
         this.presentationById.clear();
+        this.parentSubagentIdById.clear();
+        this.directCostUsdById.clear();
         this.lastSubtitleById.clear();
         this.sawTaskStarted = false;
         this.sawAnyTask = false;
@@ -252,6 +260,8 @@ export class ClaudeTaskProtocolSource {
         this.canonicalIdByToolUseId.set(id, id);
         this.declaredIds.add(id);
         this.lastStatusById.set(id, "running");
+        if (parentSubagentId)
+            this.parentSubagentIdById.set(id, parentSubagentId);
         // An explicit `name` on the Task call wins over the agent type, matching how replay titles the
         // same subagent. Without it a fan-out of five Explores reads as five identical rows.
         const isWorkflow = message.task_type === CLAUDE_WORKFLOW_TASK_TYPE;
@@ -335,6 +345,29 @@ export class ClaudeTaskProtocolSource {
             return [];
         return this.updatePresentation(id, { usage });
     }
+    /** Cost estimated from the subagent's transcript, which the session reads as usage grows. */
+    observeCost(taskId, costUsd) {
+        const id = this.subagentIdByTaskId.get(taskId);
+        if (!id)
+            return [];
+        this.directCostUsdById.set(id, costUsd);
+        const costs = this.costRollup();
+        const observations = [];
+        for (const [subagentId, cost] of costs.byId) {
+            observations.push(...this.updatePresentation(subagentId, {
+                costUsd: this.directCostUsdById.get(subagentId),
+                subagentCostUsd: cost.subagentCostUsd,
+            }));
+        }
+        return observations;
+    }
+    costRollup() {
+        return rollupProviderSubagentCosts([...this.declaredIds].map((id) => ({
+            id,
+            parentSubagentId: this.parentSubagentIdById.get(id) ?? null,
+            ownCostUsd: this.directCostUsdById.get(id) ?? 0,
+        })));
+    }
     /**
      * Effort as reported by a hook firing inside a subagent.
      *

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/claude/subagents/presentation.d.ts

@@ -6,6 +6,10 @@ export interface ClaudeSubagentPresentationFacts {
     model?: string;
     effort?: string;
     usage?: ClaudeSubagentUsage;
+    /** Estimated from list prices; Claude reports no cost per subagent. */
+    costUsd?: number;
+    /** Recursive cost of provider-native descendants, excluding this subagent. */
+    subagentCostUsd?: number;
 }
 /** Build the complete compact subtitle Claude exposes to provider-neutral clients. */
 export declare function buildClaudeSubagentSubtitle(facts: ClaudeSubagentPresentationFacts): string | undefined;

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/claude/subagents/presentation.js

@@ -1,3 +1,4 @@
+import { formatSubagentCosts, formatSubagentTokens, } from "../../../provider-subagents/subtitle-format.js";
 import { findClaudeModel } from "../models.js";
 /** Build the complete compact subtitle Claude exposes to provider-neutral clients. */
 export function buildClaudeSubagentSubtitle(facts) {
@@ -5,7 +6,11 @@ export function buildClaudeSubagentSubtitle(facts) {
         readPart(facts.title),
         formatModel(facts.model),
         formatEffort(facts.effort),
-        formatTokens(facts.usage?.totalTokens),
+        formatSubagentTokens(facts.usage?.totalTokens),
+        ...formatSubagentCosts({
+            ownCostUsd: facts.costUsd,
+            subagentCostUsd: facts.subagentCostUsd,
+        }),
     ].filter((part) => part !== undefined);
     return parts.length > 0 ? parts.join(" · ") : undefined;
 }
@@ -31,11 +36,4 @@ function formatEffort(effort) {
         .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
         .join(" ");
 }
-function formatTokens(totalTokens) {
-    if (typeof totalTokens !== "number" || totalTokens <= 0)
-        return undefined;
-    if (totalTokens < 1000)
-        return `${Math.round(totalTokens)} tokens`;
-    return `${Math.round(totalTokens / 100) / 10}k tokens`;
-}
 //# sourceMappingURL=presentation.js.map

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/claude/subagents/replay-source.d.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import type { AgentTimelineItem } from "../../../agent-sdk-types.js";
 import type { SubagentObservation } from "./observation.js";
+import { type ClaudeSubagentPresentationFacts } from "./presentation.js";
 /**
  * Rebuilds subagent observations from a persisted session, producing the same vocabulary the
  * live task-protocol source produces. Identical observations in means identical descriptor
@@ -58,13 +59,25 @@ export interface ClaudeReplayParentFacts {
         failed: boolean;
     }>;
 }
+/** A replayed subagent whose subtitle gains a cost once its transcript is priced. */
+export interface ClaudeReplaySubagentCostTarget {
+    id: string;
+    taskId: string;
+    parentSubagentId?: string;
+    facts: ClaudeSubagentPresentationFacts;
+    timestamp?: string;
+}
+/** Rebuild replayed subtitles with each transcript's own cost and its descendants' rollup. */
+export declare function observeReplaySubagentCosts(targets: readonly ClaudeReplaySubagentCostTarget[], costUsdByTaskId: ReadonlyMap<string, number>): SubagentObservation[];
 export declare function observeReplaySubagents(input: {
     subagents: readonly ClaudeReplaySubagentInput[];
     parent: ClaudeReplayParentFacts;
     convertEntry: (entry: ClaudeReplayEntry) => AgentTimelineItem[];
 }): {
     observations: SubagentObservation[];
+    taskIds: ReadonlySet<string>;
     toolOwners: ReadonlyMap<string, string>;
+    costTargets: readonly ClaudeReplaySubagentCostTarget[];
 };
 export {};
 //# sourceMappingURL=replay-source.d.ts.map

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/claude/subagents/replay-source.js

@@ -1,7 +1,8 @@
 import { z } from "zod";
 import { normalizeProviderReplayTimestamp } from "../../../provider-history-timestamps.js";
 import { resolveObservedClaudeModelId } from "../models.js";
-import { buildClaudeSubagentSubtitle } from "./presentation.js";
+import { rollupProviderSubagentCosts } from "../../../provider-subagents/cost.js";
+import { buildClaudeSubagentSubtitle, } from "./presentation.js";
 /**
  * Rebuilds subagent observations from a persisted session, producing the same vocabulary the
  * live task-protocol source produces. Identical observations in means identical descriptor
@@ -191,30 +192,39 @@ function declareSubagent(subagent, link, toolCall, parentSubagentId) {
         ...(firstTimestamp ? { timestamp: firstTimestamp } : {}),
     };
 }
-function observeSubtitle(subagent, link, title) {
-    const runtime = readRuntime(subagent.entries);
+function readSubtitleFacts(subagent, title) {
     const usage = readUsage(subagent.entries);
-    const hasDetails = runtime.model !== undefined ||
-        runtime.effort !== undefined ||
-        (usage?.totalTokens !== undefined && usage.totalTokens > 0);
+    return { title, ...readRuntime(subagent.entries), ...(usage ? { usage } : {}) };
+}
+function buildSubtitleObservation(id, facts, timestamp) {
+    const hasDetails = facts.model !== undefined ||
+        facts.effort !== undefined ||
+        (facts.usage?.totalTokens !== undefined && facts.usage.totalTokens > 0) ||
+        facts.costUsd !== undefined;
     if (!hasDetails)
         return null;
-    const subtitle = buildClaudeSubagentSubtitle({
-        title,
-        ...runtime,
-        ...(usage ? { usage } : {}),
-    });
+    const subtitle = buildClaudeSubagentSubtitle(facts);
     if (!subtitle)
         return null;
-    const timestamp = normalizeProviderReplayTimestamp(subagent.entries.at(-1)?.timestamp);
-    return {
-        kind: "subtitle",
-        id: link.id,
-        subtitle,
-        ...(timestamp ? { timestamp } : {}),
-    };
+    return { kind: "subtitle", id, subtitle, ...(timestamp ? { timestamp } : {}) };
 }
-function observeSubagent(subagent, parent, convertEntry, parentSubagentId) {
+/** Rebuild replayed subtitles with each transcript's own cost and its descendants' rollup. */
+export function observeReplaySubagentCosts(targets, costUsdByTaskId) {
+    const costs = rollupProviderSubagentCosts(targets.map((target) => ({
+        id: target.id,
+        parentSubagentId: target.parentSubagentId ?? null,
+        ownCostUsd: costUsdByTaskId.get(target.taskId) ?? 0,
+    })));
+    return targets.flatMap((target) => {
+        const costUsd = costUsdByTaskId.get(target.taskId);
+        const subagentCostUsd = costs.byId.get(target.id)?.subagentCostUsd ?? 0;
+        if (costUsd === undefined && subagentCostUsd <= 0)
+            return [];
+        const observation = buildSubtitleObservation(target.id, { ...target.facts, costUsd: costUsd ?? 0, subagentCostUsd }, target.timestamp);
+        return observation ? [observation] : [];
+    });
+}
+function observeSubagent(subagent, parent, convertEntry, costTargets, parentSubagentId) {
     const link = resolveParentLink(subagent, parent);
     if (!link)
         return [];
@@ -222,9 +232,18 @@ function observeSubagent(subagent, parent, convertEntry, parentSubagentId) {
     const observations = [
         declareSubagent(subagent, link, toolCall, parentSubagentId),
     ];
-    const subtitle = observeSubtitle(subagent, link, toolCall?.title ?? subagent.meta?.agentType);
+    const facts = readSubtitleFacts(subagent, toolCall?.title ?? subagent.meta?.agentType);
+    const subtitleTimestamp = normalizeProviderReplayTimestamp(subagent.entries.at(-1)?.timestamp) ?? undefined;
+    const subtitle = buildSubtitleObservation(link.id, facts, subtitleTimestamp);
     if (subtitle)
         observations.push(subtitle);
+    costTargets.push({
+        id: link.id,
+        taskId: subagent.agentId,
+        ...(parentSubagentId ? { parentSubagentId } : {}),
+        facts,
+        ...(subtitleTimestamp ? { timestamp: subtitleTimestamp } : {}),
+    });
     for (const entry of subagent.entries) {
         const timestamp = normalizeProviderReplayTimestamp(entry.timestamp);
         for (const item of convertEntry(entry)) {
@@ -263,6 +282,8 @@ function recordReplayToolOwners(owners, entries, subagentId) {
 }
 export function observeReplaySubagents(input) {
     const observations = [];
+    const costTargets = [];
+    const taskIds = new Set();
     const toolOwners = new Map();
     const unresolved = [...input.subagents].sort((left, right) => (left.meta?.spawnDepth ?? 1) - (right.meta?.spawnDepth ?? 1));
     const resolvedParents = new Map();
@@ -281,15 +302,16 @@ export function observeReplaySubagents(input) {
                 continue;
             const { ownerId, parent, link } = resolved;
             // Only proven descendants may own notifications; ambient sidecars cannot claim them.
+            taskIds.add(subagent.agentId);
             recordReplayToolOwners(toolOwners, subagent.entries, link.id);
-            observations.push(...observeSubagent(subagent, parent, input.convertEntry, ownerId));
+            observations.push(...observeSubagent(subagent, parent, input.convertEntry, costTargets, ownerId));
             if (subagent.parentFacts)
                 resolvedParents.set(link.id, subagent.parentFacts);
             unresolved.splice(index, 1);
             madeProgress = true;
         }
     }
-    return { observations, toolOwners };
+    return { observations, taskIds, toolOwners, costTargets };
 }
 function resolveReplayOwner(subagent, rootParent, resolvedParents) {
     const rootLink = resolveParentLink(subagent, rootParent);

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/claude/subagents/transcript-cost.d.ts

@@ -0,0 +1,18 @@
+import type { CodexPrices } from "../../codex/pricing.js";
+/**
+ * Sums the estimated cost of every model request recorded in a Claude subagent transcript.
+ *
+ * Claude Code reports only a token count per subagent, but its transcript records each request's
+ * model and usage split into input, cache writes, cache reads, and output, which is what a price
+ * needs. One request can span several entries that share a message id, so each id is priced once,
+ * from its latest entry.
+ */
+export declare class ClaudeTranscriptCost {
+    private readonly lines;
+    private readonly costByMessageId;
+    constructor(filePath: string);
+    /** Returns the cost so far, or undefined when no request used a priced model. */
+    read(prices: CodexPrices): Promise<number | undefined>;
+    private applyLine;
+}
+//# sourceMappingURL=transcript-cost.d.ts.map

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/claude/subagents/transcript-cost.js

@@ -0,0 +1,50 @@
+import { AppendedLinesReader, parseRecordLine, readCount, toRecord, } from "../../appended-lines-reader.js";
+/**
+ * Sums the estimated cost of every model request recorded in a Claude subagent transcript.
+ *
+ * Claude Code reports only a token count per subagent, but its transcript records each request's
+ * model and usage split into input, cache writes, cache reads, and output, which is what a price
+ * needs. One request can span several entries that share a message id, so each id is priced once,
+ * from its latest entry.
+ */
+export class ClaudeTranscriptCost {
+    constructor(filePath) {
+        this.costByMessageId = new Map();
+        this.lines = new AppendedLinesReader(filePath);
+    }
+    /** Returns the cost so far, or undefined when no request used a priced model. */
+    async read(prices) {
+        await this.lines.read((line) => this.applyLine(line, prices));
+        if (this.costByMessageId.size === 0)
+            return undefined;
+        let total = 0;
+        for (const cost of this.costByMessageId.values())
+            total += cost;
+        return total;
+    }
+    applyLine(line, prices) {
+        // Skip user entries and tool results without parsing them.
+        if (!line.includes('"assistant"') || !line.includes('"usage"'))
+            return;
+        const entry = parseRecordLine(line);
+        if (entry?.type !== "assistant")
+            return;
+        const message = toRecord(entry.message);
+        const usage = toRecord(message?.usage);
+        if (typeof message?.id !== "string" || !usage)
+            return;
+        const cacheWrite = readCount(usage.cache_creation_input_tokens);
+        const cacheWrite1h = readCount(toRecord(usage.cache_creation)?.ephemeral_1h_input_tokens);
+        const cost = prices.claudeRequestCostUsd({
+            model: typeof message.model === "string" ? message.model : undefined,
+            inputTokens: readCount(usage.input_tokens),
+            cacheWrite5mTokens: Math.max(0, cacheWrite - cacheWrite1h),
+            cacheWrite1hTokens: cacheWrite1h,
+            cacheReadTokens: readCount(usage.cache_read_input_tokens),
+            outputTokens: readCount(usage.output_tokens),
+        });
+        if (cost !== undefined)
+            this.costByMessageId.set(message.id, cost);
+    }
+}
+//# sourceMappingURL=transcript-cost.js.map

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/codex/pricing.d.ts

@@ -6,12 +6,25 @@ export interface CodexRequestUsage {
     cachedInputTokens: number;
     outputTokens: number;
 }
-/** OpenAI list prices for one model request, keyed by Codex model slug. */
+export interface ClaudeRequestUsage {
+    model: string | undefined;
+    inputTokens: number;
+    cacheWrite5mTokens: number;
+    cacheWrite1hTokens: number;
+    cacheReadTokens: number;
+    outputTokens: number;
+}
+/** List prices for one model request, keyed by Codex model slug or Claude model id. */
 export declare class CodexPrices {
     private readonly entries;
     constructor(entries: Record<string, unknown>);
     /** Returns undefined for a model missing from the price list. */
     requestCostUsd({ model, serviceTier, inputTokens, cachedInputTokens, outputTokens, }: CodexRequestUsage): number | undefined;
+    /**
+     * Returns undefined for a model missing from the price list.
+     * ponytail: ignores Anthropic's long-context rate, which LiteLLM lists only for some models.
+     */
+    claudeRequestCostUsd({ model, inputTokens, cacheWrite5mTokens, cacheWrite1hTokens, cacheReadTokens, outputTokens, }: ClaudeRequestUsage): number | undefined;
 }
 export interface CodexPriceListOptions {
     logger: Logger;
@@ -39,4 +52,5 @@ export declare class CodexPriceList {
     private load;
     private readSavedCopy;
 }
+export declare function getSharedCodexPriceList(logger: Logger): CodexPriceList;
 //# sourceMappingURL=pricing.d.ts.map

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/codex/pricing.js

@@ -13,7 +13,7 @@ const FETCH_TIMEOUT_MS = 15000;
 const LONG_CONTEXT_THRESHOLD_TOKENS = 272000;
 const LONG_CONTEXT_SUFFIX = "_above_272k_tokens";
 const PRIORITY_SUFFIX = "_priority";
-/** OpenAI list prices for one model request, keyed by Codex model slug. */
+/** List prices for one model request, keyed by Codex model slug or Claude model id. */
 export class CodexPrices {
     constructor(entries) {
         this.entries = entries;
@@ -38,6 +38,31 @@ export class CodexPrices {
             cachedInputTokens * cachedInputRate +
             outputTokens * outputRate);
     }
+    /**
+     * Returns undefined for a model missing from the price list.
+     * ponytail: ignores Anthropic's long-context rate, which LiteLLM lists only for some models.
+     */
+    claudeRequestCostUsd({ model, inputTokens, cacheWrite5mTokens, cacheWrite1hTokens, cacheReadTokens, outputTokens, }) {
+        const entry = model ? toRecord(this.entries[model]) : undefined;
+        if (!entry)
+            return undefined;
+        const inputRate = readNumber(entry.input_cost_per_token);
+        const outputRate = readNumber(entry.output_cost_per_token);
+        if (inputRate === undefined || outputRate === undefined)
+            return undefined;
+        const cacheWrite5mRate = readNumber(entry.cache_creation_input_token_cost) ?? inputRate;
+        const cacheWrite1hRate = readNumber(entry.cache_creation_input_token_cost_above_1hr) ?? cacheWrite5mRate;
+        const cacheReadRate = readNumber(entry.cache_read_input_token_cost) ?? inputRate;
+        // Anthropic counts cache reads and writes apart from input tokens.
+        return (inputTokens * inputRate +
+            cacheWrite5mTokens * cacheWrite5mRate +
+            cacheWrite1hTokens * cacheWrite1hRate +
+            cacheReadTokens * cacheReadRate +
+            outputTokens * outputRate);
+    }
+}
+function readNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
 // Prefer the most specific rate LiteLLM lists: a model without a long-context or priority variant
 // bills that request at its plain rate.
@@ -123,6 +148,12 @@ export class CodexPriceList {
         }
     }
 }
+let sharedCodexPriceList;
+// One price list per daemon, so every session that estimates cost shares one fetch.
+export function getSharedCodexPriceList(logger) {
+    sharedCodexPriceList ?? (sharedCodexPriceList = new CodexPriceList({ logger }));
+    return sharedCodexPriceList;
+}
 function parsePriceList(text) {
     const entries = toRecord(JSON.parse(text));
     if (!entries) {

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/codex/rollout-cost.d.ts

@@ -5,19 +5,16 @@ import type { CodexPrices } from "./pricing.js";
  * Codex writes each request's token counts and the model of each turn to the rollout, and the file
  * survives compaction, resume, and daemon restarts. Pricing request by request applies the
  * long-context rate and mid-session model switches, which pricing the thread total cannot.
- * Each read parses only the bytes appended since the previous read.
  */
 export declare class CodexRolloutCost {
-    private readonly filePath;
-    private offset;
-    private readonly decoder;
-    private pendingLine;
-    private model;
+    private readonly lines;
+    private currentModel;
     private highestTotalTokens;
     private costUsd;
     private pricedRequests;
-    private queue;
     constructor(filePath: string);
+    /** The model of the latest turn read so far. */
+    get model(): string | undefined;
     /**
      * Returns the session cost so far, or undefined when no request used a priced model.
      * ponytail: prices every request at the current service tier; the rollout does not record it.
@@ -26,7 +23,6 @@ export declare class CodexRolloutCost {
         prices: CodexPrices;
         serviceTier: string | null;
     }): Promise<number | undefined>;
-    private readAppended;
     private applyLine;
 }
 //# sourceMappingURL=rollout-cost.d.ts.map

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/codex/rollout-cost.js

@@ -1,62 +1,39 @@
-import fs from "node:fs/promises";
-import { StringDecoder } from "node:string_decoder";
+import { AppendedLinesReader, parseRecordLine, readCount, toRecord, } from "../appended-lines-reader.js";
 /**
  * Sums the estimated cost of every model request recorded in a Codex rollout file.
  *
  * Codex writes each request's token counts and the model of each turn to the rollout, and the file
  * survives compaction, resume, and daemon restarts. Pricing request by request applies the
  * long-context rate and mid-session model switches, which pricing the thread total cannot.
- * Each read parses only the bytes appended since the previous read.
  */
 export class CodexRolloutCost {
     constructor(filePath) {
-        this.filePath = filePath;
-        this.offset = 0;
-        this.decoder = new StringDecoder("utf8");
-        this.pendingLine = "";
         this.highestTotalTokens = -1;
         this.costUsd = 0;
         this.pricedRequests = 0;
-        this.queue = Promise.resolve();
+        this.lines = new AppendedLinesReader(filePath);
+    }
+    /** The model of the latest turn read so far. */
+    get model() {
+        return this.currentModel;
     }
     /**
      * Returns the session cost so far, or undefined when no request used a priced model.
      * ponytail: prices every request at the current service tier; the rollout does not record it.
      */
-    read({ prices, serviceTier, }) {
-        const result = this.queue.then(() => this.readAppended(prices, serviceTier));
-        this.queue = result.catch(() => undefined);
-        return result;
-    }
-    async readAppended(prices, serviceTier) {
-        const handle = await fs.open(this.filePath, "r");
-        try {
-            const { size } = await handle.stat();
-            if (size > this.offset) {
-                const buffer = Buffer.alloc(size - this.offset);
-                const { bytesRead } = await handle.read(buffer, 0, buffer.length, this.offset);
-                this.offset += bytesRead;
-                const lines = (this.pendingLine + this.decoder.write(buffer.subarray(0, bytesRead))).split("\n");
-                this.pendingLine = lines.pop() ?? "";
-                for (const line of lines) {
-                    this.applyLine(line, prices, serviceTier);
-                }
-            }
-        }
-        finally {
-            await handle.close();
-        }
+    async read({ prices, serviceTier, }) {
+        await this.lines.read((line) => this.applyLine(line, prices, serviceTier));
         return this.pricedRequests > 0 ? this.costUsd : undefined;
     }
     applyLine(line, prices, serviceTier) {
         // Skip the bulk of the rollout (messages, tool output) without parsing it.
         if (!line.includes('"turn_context"') && !line.includes('"token_count"'))
             return;
-        const entry = parseRecord(line);
+        const entry = parseRecordLine(line);
         const payload = toRecord(entry?.payload);
         if (entry?.type === "turn_context") {
             if (typeof payload?.model === "string")
-                this.model = payload.model;
+                this.currentModel = payload.model;
             return;
         }
         if (payload?.type !== "token_count")
@@ -71,7 +48,7 @@ export class CodexRolloutCost {
             return;
         this.highestTotalTokens = totalTokens;
         const cost = prices.requestCostUsd({
-            model: this.model,
+            model: this.currentModel,
             serviceTier,
             inputTokens: readCount(last.input_tokens),
             cachedInputTokens: readCount(last.cached_input_tokens),
@@ -83,21 +60,4 @@ export class CodexRolloutCost {
         this.pricedRequests += 1;
     }
 }
-function parseRecord(line) {
-    try {
-        return toRecord(JSON.parse(line));
-    }
-    catch {
-        // A torn or foreign line only drops that line from an estimate.
-        return undefined;
-    }
-}
-function toRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value)
-        ? value
-        : undefined;
-}
-function readCount(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
 //# sourceMappingURL=rollout-cost.js.map

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/codex-app-server-agent.d.ts

@@ -2,7 +2,7 @@ import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOpt
 import type { Logger } from "pino";
 import type { ChildProcessWithoutNullStreams } from "node:child_process";
 import { Dirent } from "node:fs";
-import { CodexPriceList } from "./codex/pricing.js";
+import { type CodexPriceList } from "./codex/pricing.js";
 import { type ProviderRuntimeSettings } from "../provider-launch-config.js";
 import { type CodexThreadForkParams, type CodexThreadForkResponse, type CodexThreadRollbackParams, type CodexThreadRollbackResponse, type CodexAppServerTraceContext } from "./codex/app-server-transport.js";
 import type { WorkspaceGitService } from "../../workspace-git-service.js";
@@ -173,6 +173,7 @@ export declare class CodexAppServerAgentSession implements AgentSession {
     private emittedProviderSubagentUserMessageKeys;
     private subAgentCallsByCallId;
     private subAgentCallIdByChildThreadId;
+    private subAgentUsageByThreadId;
     private pendingSubAgentNotificationsByThreadId;
     private warnedUnknownNotificationMethods;
     private warnedInvalidNotificationPayloads;
@@ -336,6 +337,11 @@ export declare class CodexAppServerAgentSession implements AgentSession {
     private resetTurnTrackingState;
     private handlePlanUpdatedNotification;
     private handleTokenUsageUpdatedNotification;
+    private handleSubAgentTokenUsage;
+    private refreshSubAgentCost;
+    private emitSubAgentSubtitle;
+    private subagentCostRollup;
+    private refreshCostPresentation;
     private refreshRolloutCost;
     private applyCostEstimate;
     private openRolloutCost;