praxis-agent 0.16.0 → 0.17.0

package/README.md

@@ -15,10 +15,15 @@ Anthropic/OpenAI-compatible model access. Praxis deliberately excludes
 accounts, organizations, billing, managed enterprise policy, remote control,
 IDE surfaces, and telemetry control planes.
 
-Claude Code 2.1.208 is the compatibility, architecture, and design baseline.
-Every single-user CLI capability remains required unless it falls inside an
-explicit exclusion above. A similar Praxis surface is not a substitute for the
-corresponding Claude command or runtime contract.
+Claude Code 2.1.208 remains the architecture, design, and observable
+compatibility baseline for included and required single-user developer
+capabilities. Only entries classified `required` block developer-core
+closure; `deferred` entries are optional and demand-driven. Exclusions cover
+the existing enterprise, authentication, hosted, and client surfaces plus the
+explicitly classified subscription-bound integration, campaign, hidden
+maintainer diagnostic, and build-experimental commands. A similar Praxis
+surface is not a substitute for the corresponding Claude command or runtime
+contract.
 
 ## Requirements
 
@@ -98,7 +103,8 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   skills/hooks flow, provider-free per-session `/color` prompt-bar styling,
   `/mcp`, `/memory` shared instruction and auto-memory
   access, and live extension-reload controls,
-  cursor/history composer, per-session model/effort/permission controls,
+  cursor/history composer, provider-free `/cost` usage and pricing summaries,
+  interactive `/doctor` diagnostics, per-session model/effort/permission controls,
   context/status/skill/task dashboards, prompt stash and continuation shortcuts,
   filterable `@` file and agent references, composer undo, `Ctrl+G` external
   editing, shared `/keybindings` creation/editing and supported-action remapping,

package/dist/application/background-agent-manager.d.ts

@@ -1,7 +1,10 @@
-import type { ModelUsage } from '../core/runtime.js';
+import type { ModelUsage, ModelUsageByModel } from '../core/runtime.js';
 export interface BackgroundAgentRunResult {
     text: string;
     usage: ModelUsage;
+    modelUsage?: ModelUsageByModel;
+    durationApiMs?: number;
+    durationApiWithoutRetriesMs?: number;
     toolUseCount: number;
     durationMs: number;
     isolationPath?: string;
@@ -57,6 +60,9 @@ export declare class BackgroundAgentManager {
     }): Promise<{
         messages: string[];
         usage: ModelUsage;
+        modelUsage?: ModelUsageByModel;
+        durationApiMs?: number;
+        durationApiWithoutRetriesMs?: number;
     }>;
     private start;
     private resolveOptional;

package/dist/application/background-agent-manager.js

@@ -34,6 +34,118 @@ function waitBounded(operation, milliseconds) {
         });
     });
 }
+const modelUsageCounterFields = [
+    'inputTokens',
+    'outputTokens',
+    'cacheReadInputTokens',
+    'cacheCreationInputTokens',
+    'webSearchRequests',
+];
+const modelUsageMetadataFields = ['contextWindow', 'maxOutputTokens'];
+function assertValidModelUsageEntry(model, usage) {
+    if (model.trim() === '') {
+        throw new Error('Model usage breakdown contains a blank model name');
+    }
+    for (const field of modelUsageCounterFields) {
+        const value = usage[field];
+        if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
+            throw new Error(`Model usage for "${model}" has an invalid ${field} counter`);
+        }
+    }
+    for (const field of modelUsageMetadataFields) {
+        const value = usage[field];
+        if (value !== undefined && (!Number.isSafeInteger(value) || value < 1)) {
+            throw new Error(`Model usage for "${model}" has an invalid ${field} metadata value`);
+        }
+    }
+}
+function mergeModelUsageMetadata(model, left, right) {
+    const contextWindow = mergeModelUsageMetadataField(model, 'contextWindow', left.contextWindow, right.contextWindow);
+    const maxOutputTokens = mergeModelUsageMetadataField(model, 'maxOutputTokens', left.maxOutputTokens, right.maxOutputTokens);
+    return {
+        ...(contextWindow === undefined ? {} : { contextWindow }),
+        ...(maxOutputTokens === undefined ? {} : { maxOutputTokens }),
+    };
+}
+function mergeModelUsageMetadataField(model, field, left, right) {
+    if (left === undefined)
+        return right;
+    if (right === undefined)
+        return left;
+    if (left !== right) {
+        throw new Error(`Model usage for "${model}" has conflicting ${field} values: ${left} vs ${right}`);
+    }
+    return left;
+}
+function addUsageChecked(model, left, right) {
+    const inputTokens = left.inputTokens + right.inputTokens;
+    const outputTokens = left.outputTokens + right.outputTokens;
+    const cacheReadInputTokens = (left.cacheReadInputTokens ?? 0) + (right.cacheReadInputTokens ?? 0);
+    const cacheCreationInputTokens = (left.cacheCreationInputTokens ?? 0) + (right.cacheCreationInputTokens ?? 0);
+    const webSearchRequests = (left.webSearchRequests ?? 0) + (right.webSearchRequests ?? 0);
+    if (!Number.isSafeInteger(inputTokens) ||
+        !Number.isSafeInteger(outputTokens) ||
+        !Number.isSafeInteger(cacheReadInputTokens) ||
+        !Number.isSafeInteger(cacheCreationInputTokens) ||
+        !Number.isSafeInteger(webSearchRequests)) {
+        throw new Error('Model usage total overflow');
+    }
+    // Aggregates without a model stay counter-only; per-model rows merge their
+    // capability metadata with conflict rejection.
+    const metadata = model === undefined ? {} : mergeModelUsageMetadata(model, left, right);
+    return {
+        inputTokens,
+        outputTokens,
+        ...(cacheReadInputTokens === 0 ? {} : { cacheReadInputTokens }),
+        ...(cacheCreationInputTokens === 0 ? {} : { cacheCreationInputTokens }),
+        ...(webSearchRequests === 0 ? {} : { webSearchRequests }),
+        ...metadata,
+    };
+}
+function assertValidResultUsage(usage) {
+    for (const field of modelUsageCounterFields) {
+        const value = usage[field];
+        if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
+            throw new Error(`Model usage total has an invalid ${field} counter`);
+        }
+    }
+}
+function addApiDuration(value, total, field) {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new TypeError(`${field} must be a finite nonnegative number`);
+    }
+    const next = total + value;
+    if (!Number.isFinite(next) || next < 0) {
+        throw new TypeError(`${field} total overflow`);
+    }
+    return next;
+}
+function mergeModelUsageEntry(map, model, usage) {
+    assertValidModelUsageEntry(model, usage);
+    const existing = map.get(model);
+    if (existing === undefined) {
+        map.set(model, { ...usage });
+        return;
+    }
+    map.set(model, addUsageChecked(model, existing, usage));
+}
+function mergeToolModelUsage(map, breakdown) {
+    const entries = Object.entries(breakdown);
+    if (entries.length === 0)
+        return;
+    // Validate every key, counter, metadata, and merged sum before adding any
+    // entry from this breakdown so malformed or conflicting data never merges
+    // partially.
+    for (const [model, usage] of entries) {
+        assertValidModelUsageEntry(model, usage);
+        const existing = map.get(model);
+        if (existing !== undefined)
+            addUsageChecked(model, existing, usage);
+    }
+    for (const [model, usage] of entries) {
+        mergeModelUsageEntry(map, model, usage);
+    }
+}
 export class BackgroundAgentManager {
     tasks = new Map();
     names = new Map();
@@ -203,15 +315,46 @@ export class BackgroundAgentManager {
                 await Promise.race(running);
         }
         const notifications = [];
-        const usage = { inputTokens: 0, outputTokens: 0 };
+        let usage = { inputTokens: 0, outputTokens: 0 };
+        const modelUsageByModel = new Map();
+        let durationApiMs = 0;
+        let durationApiWithoutRetriesMs = 0;
+        let durationSeen = false;
+        const consumedTasks = [];
         for (const [, task] of eligibleTasks) {
-            for (const notification of task.notifications.splice(0)) {
+            if (task.notifications.length === 0)
+                continue;
+            for (const notification of task.notifications) {
                 notifications.push(this.formatNotification(task, notification));
-                usage.inputTokens += notification.result?.usage.inputTokens ?? 0;
-                usage.outputTokens += notification.result?.usage.outputTokens ?? 0;
+                if (notification.result) {
+                    assertValidResultUsage(notification.result.usage);
+                    usage = addUsageChecked(undefined, usage, notification.result.usage);
+                }
+                if (notification.result?.modelUsage) {
+                    mergeToolModelUsage(modelUsageByModel, notification.result.modelUsage);
+                }
+                if (notification.result?.durationApiMs !== undefined ||
+                    notification.result?.durationApiWithoutRetriesMs !== undefined) {
+                    durationSeen = true;
+                    const total = notification.result.durationApiMs ?? 0;
+                    durationApiMs = addApiDuration(total, durationApiMs, 'durationApiMs');
+                    durationApiWithoutRetriesMs = addApiDuration(notification.result.durationApiWithoutRetriesMs ?? total, durationApiWithoutRetriesMs, 'durationApiWithoutRetriesMs');
+                }
             }
+            consumedTasks.push(task);
         }
-        return { messages: notifications, usage };
+        const modelUsage = modelUsageByModel.size === 0
+            ? undefined
+            : Object.fromEntries(modelUsageByModel);
+        const result = {
+            messages: notifications,
+            usage,
+            ...(modelUsage === undefined ? {} : { modelUsage }),
+            ...(durationSeen ? { durationApiMs, durationApiWithoutRetriesMs } : {}),
+        };
+        for (const task of consumedTasks)
+            task.notifications.splice(0);
+        return result;
     }
     start(task, message, continuation, toolUseId) {
         task.generation += 1;

package/dist/application/metered-model-completion.d.ts

@@ -0,0 +1,15 @@
+import { type ModelProvider, type ModelRequest, type ModelToolCall, type ModelUsage } from '../core/runtime.js';
+export interface MeteredModelCompletion {
+    text: string;
+    toolCalls: readonly ModelToolCall[];
+    usage: ModelUsage;
+    model?: string;
+    durationApiMs: number;
+    durationApiWithoutRetriesMs: number;
+}
+export interface MeteredModelRequestOptions {
+    onTextDelta?: (delta: string) => void;
+    onMetrics?: (metrics: MeteredModelCompletion) => void;
+}
+export declare function completeMeteredModelRequest(provider: ModelProvider, request: ModelRequest, options?: MeteredModelRequestOptions): Promise<MeteredModelCompletion>;
+//# sourceMappingURL=metered-model-completion.d.ts.map

package/dist/application/metered-model-completion.js

@@ -0,0 +1,76 @@
+import { AgentRunCancelledError, } from '../core/runtime.js';
+function nonblankModel(provider) {
+    if (provider.model === undefined)
+        return undefined;
+    return provider.model.trim() === '' ? undefined : provider.model;
+}
+function enrichCapabilityMetadata(usage, value, field) {
+    if (usage[field] !== undefined)
+        return usage;
+    if (value === undefined || !Number.isSafeInteger(value) || value < 1) {
+        return usage;
+    }
+    return { ...usage, [field]: value };
+}
+function enrichedUsage(provider, usage) {
+    return enrichCapabilityMetadata(enrichCapabilityMetadata(usage, provider.capabilities.contextWindowTokens, 'contextWindow'), provider.capabilities.maxOutputTokens, 'maxOutputTokens');
+}
+export async function completeMeteredModelRequest(provider, request, options = {}) {
+    const { onTextDelta, onMetrics } = options;
+    if (request.signal?.aborted)
+        throw new AgentRunCancelledError();
+    let text = '';
+    const toolCalls = [];
+    let usage = { inputTokens: 0, outputTokens: 0 };
+    let attemptDurationMs;
+    let attemptDurationSeen = false;
+    const apiStartedAt = performance.now();
+    let metrics;
+    try {
+        for await (const event of provider.complete(request)) {
+            if (request.signal?.aborted)
+                throw new AgentRunCancelledError();
+            if (event.type === 'api-retry')
+                continue;
+            if (event.type === 'api-attempt-duration') {
+                if (attemptDurationSeen) {
+                    throw new Error('Provider emitted multiple api-attempt-duration events in one attempt');
+                }
+                attemptDurationSeen = true;
+                const { durationMs } = event;
+                if (typeof durationMs !== 'number' ||
+                    !Number.isFinite(durationMs) ||
+                    durationMs < 0) {
+                    throw new TypeError('api-attempt-duration durationMs must be a finite nonnegative number');
+                }
+                attemptDurationMs = durationMs;
+                continue;
+            }
+            if (event.type === 'text-delta') {
+                text += event.delta;
+                onTextDelta?.(event.delta);
+            }
+            else if (event.type === 'usage') {
+                usage = event.usage;
+            }
+            else if (event.type === 'tool-call') {
+                toolCalls.push(event.call);
+            }
+        }
+    }
+    finally {
+        const model = nonblankModel(provider);
+        const durationApiMs = Math.max(0, performance.now() - apiStartedAt);
+        metrics = {
+            text,
+            toolCalls,
+            usage: enrichedUsage(provider, usage),
+            ...(model === undefined ? {} : { model }),
+            durationApiMs,
+            durationApiWithoutRetriesMs: attemptDurationMs ?? durationApiMs,
+        };
+        onMetrics?.(metrics);
+    }
+    return metrics;
+}
+//# sourceMappingURL=metered-model-completion.js.map

package/dist/application/model-compactor.js

@@ -41,6 +41,8 @@ export class ModelCompactor {
         const startedAt = Date.now();
         let summary = '';
         let usage = { inputTokens: 0, outputTokens: 0 };
+        let attemptDurationMs;
+        let attemptDurationSeen = false;
         const providerRequest = {
             messages,
             ...(request.signal ? { signal: request.signal } : {}),
@@ -51,6 +53,20 @@ export class ModelCompactor {
             if (event.type === 'tool-call') {
                 throw new Error('Compaction model must not call tools');
             }
+            if (event.type === 'api-attempt-duration') {
+                if (attemptDurationSeen) {
+                    throw new Error('Provider emitted multiple api-attempt-duration events in one attempt');
+                }
+                attemptDurationSeen = true;
+                const { durationMs } = event;
+                if (typeof durationMs !== 'number' ||
+                    !Number.isFinite(durationMs) ||
+                    durationMs < 0) {
+                    throw new TypeError('api-attempt-duration durationMs must be a finite nonnegative number');
+                }
+                attemptDurationMs = durationMs;
+                continue;
+            }
             if (event.type === 'text-delta')
                 summary += event.delta;
             else if (event.type === 'usage')
@@ -64,7 +80,15 @@ export class ModelCompactor {
         if (summaryTokens > targetTokens) {
             throw new Error(`Compaction summary exceeded ${targetTokens} tokens (estimated ${summaryTokens})`);
         }
-        return { summary, usage, durationMs: Date.now() - startedAt };
+        const durationMs = Date.now() - startedAt;
+        const model = this.provider.model;
+        return {
+            summary,
+            usage,
+            durationMs,
+            durationWithoutRetriesMs: attemptDurationMs ?? durationMs,
+            ...(model !== undefined && model.trim() !== '' ? { model } : {}),
+        };
     }
 }
 //# sourceMappingURL=model-compactor.js.map

package/dist/application/session-cost-tracker.d.ts

@@ -0,0 +1,50 @@
+import type { ModelUsage } from '../core/runtime.js';
+import type { ClaudeSessionCostState } from '../persistence/claude-cost-state-store.js';
+export interface ClaudeSessionCostTrackerOptions {
+    readonly sessionId: string;
+    readonly restored?: ClaudeSessionCostState | null;
+    readonly now?: () => number;
+}
+export interface ClaudeSessionTurnInput {
+    readonly model: string;
+    readonly usage: ModelUsage;
+    readonly costUsd?: number;
+    readonly webSearchRequests?: number;
+    readonly apiDurationMs?: number;
+    readonly apiDurationWithoutRetriesMs?: number;
+    readonly toolDurationMs?: number;
+    readonly linesAdded?: number;
+    readonly linesRemoved?: number;
+}
+export interface ClaudeLineChangesInput {
+    readonly linesAdded?: number;
+    readonly linesRemoved?: number;
+}
+export interface ClaudeSessionDurationsInput {
+    readonly apiDurationMs?: number;
+    readonly apiDurationWithoutRetriesMs?: number;
+    readonly toolDurationMs?: number;
+}
+export interface ClaudeSessionCostSnapshot extends ClaudeSessionCostState {
+    readonly hasUnknownModelCost: boolean;
+}
+export declare class ClaudeSessionCostTracker {
+    private readonly sessionId;
+    private readonly now;
+    private readonly modelUsage;
+    private totalCostUsd;
+    private apiDurationMs;
+    private apiDurationWithoutRetriesMs;
+    private toolDurationMs;
+    private linesAdded;
+    private linesRemoved;
+    private hasUnknownModelCost;
+    private startTime;
+    constructor(options: ClaudeSessionCostTrackerOptions);
+    recordTurn(input: ClaudeSessionTurnInput): void;
+    recordDurations(input: ClaudeSessionDurationsInput): void;
+    private durationTotals;
+    recordLineChanges(input: ClaudeLineChangesInput): void;
+    snapshot(): ClaudeSessionCostSnapshot;
+}
+//# sourceMappingURL=session-cost-tracker.d.ts.map

package/dist/application/session-cost-tracker.js

@@ -0,0 +1,254 @@
+function requireNonBlank(value, field) {
+    if (typeof value !== 'string' || value.trim() === '') {
+        throw new TypeError(`${field} must not be blank`);
+    }
+    return value;
+}
+function requireCounter(value, field) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new TypeError(`${field} must be a nonnegative safe integer`);
+    }
+    return value;
+}
+function requireMetric(value, field) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+        throw new TypeError(`${field} must be a finite nonnegative number`);
+    }
+    return value;
+}
+function requireCounterTotal(value, field) {
+    if (!Number.isSafeInteger(value)) {
+        throw new TypeError(`${field} total must be a safe integer`);
+    }
+}
+function requireMetricTotal(value, field) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+        throw new TypeError(`${field} total must be a finite nonnegative number`);
+    }
+}
+function emptyModelUsage() {
+    return {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadInputTokens: 0,
+        cacheCreationInputTokens: 0,
+        webSearchRequests: 0,
+        costUsd: 0,
+    };
+}
+export class ClaudeSessionCostTracker {
+    sessionId;
+    now;
+    modelUsage = new Map();
+    totalCostUsd;
+    apiDurationMs;
+    apiDurationWithoutRetriesMs;
+    toolDurationMs;
+    linesAdded;
+    linesRemoved;
+    hasUnknownModelCost = false;
+    startTime;
+    constructor(options) {
+        this.sessionId = requireNonBlank(options.sessionId, 'sessionId');
+        this.now = options.now ?? Date.now;
+        const restored = options.restored ?? null;
+        if (restored === null) {
+            this.totalCostUsd = 0;
+            this.apiDurationMs = 0;
+            this.apiDurationWithoutRetriesMs = 0;
+            this.toolDurationMs = 0;
+            this.linesAdded = 0;
+            this.linesRemoved = 0;
+            this.startTime = this.now();
+            return;
+        }
+        if (restored.sessionId !== this.sessionId) {
+            throw new TypeError('restored sessionId does not match the tracker sessionId');
+        }
+        this.totalCostUsd = restored.totalCostUsd;
+        this.apiDurationMs = restored.apiDurationMs;
+        this.apiDurationWithoutRetriesMs = restored.apiDurationWithoutRetriesMs;
+        this.toolDurationMs = restored.toolDurationMs;
+        this.linesAdded = restored.linesAdded;
+        this.linesRemoved = restored.linesRemoved;
+        for (const [model, usage] of Object.entries(restored.modelUsage)) {
+            this.modelUsage.set(model, {
+                inputTokens: usage.inputTokens,
+                outputTokens: usage.outputTokens,
+                cacheReadInputTokens: usage.cacheReadInputTokens,
+                cacheCreationInputTokens: usage.cacheCreationInputTokens,
+                webSearchRequests: usage.webSearchRequests,
+                costUsd: usage.costUsd,
+            });
+        }
+        const current = this.now();
+        this.startTime =
+            restored.wallDurationMs !== 0
+                ? current - restored.wallDurationMs
+                : current;
+    }
+    recordTurn(input) {
+        const model = requireNonBlank(input.model, 'model');
+        const inputTokens = requireCounter(input.usage.inputTokens, 'usage.inputTokens');
+        const outputTokens = requireCounter(input.usage.outputTokens, 'usage.outputTokens');
+        const cacheReadInputTokens = input.usage.cacheReadInputTokens === undefined
+            ? 0
+            : requireCounter(input.usage.cacheReadInputTokens, 'usage.cacheReadInputTokens');
+        const cacheCreationInputTokens = input.usage.cacheCreationInputTokens === undefined
+            ? 0
+            : requireCounter(input.usage.cacheCreationInputTokens, 'usage.cacheCreationInputTokens');
+        const webSearchRequests = input.webSearchRequests === undefined
+            ? 0
+            : requireCounter(input.webSearchRequests, 'webSearchRequests');
+        const costUsd = input.costUsd === undefined
+            ? undefined
+            : requireMetric(input.costUsd, 'costUsd');
+        const apiDurationMs = input.apiDurationMs === undefined
+            ? 0
+            : requireMetric(input.apiDurationMs, 'apiDurationMs');
+        const apiDurationWithoutRetriesMs = input.apiDurationWithoutRetriesMs === undefined
+            ? apiDurationMs
+            : requireMetric(input.apiDurationWithoutRetriesMs, 'apiDurationWithoutRetriesMs');
+        const toolDurationMs = input.toolDurationMs === undefined
+            ? 0
+            : requireMetric(input.toolDurationMs, 'toolDurationMs');
+        const linesAdded = input.linesAdded === undefined
+            ? 0
+            : requireCounter(input.linesAdded, 'linesAdded');
+        const linesRemoved = input.linesRemoved === undefined
+            ? 0
+            : requireCounter(input.linesRemoved, 'linesRemoved');
+        const existing = this.modelUsage.get(model) ?? emptyModelUsage();
+        const newInputTokens = existing.inputTokens + inputTokens;
+        const newOutputTokens = existing.outputTokens + outputTokens;
+        const newCacheReadInputTokens = existing.cacheReadInputTokens + cacheReadInputTokens;
+        const newCacheCreationInputTokens = existing.cacheCreationInputTokens + cacheCreationInputTokens;
+        const newWebSearchRequests = existing.webSearchRequests + webSearchRequests;
+        requireCounterTotal(newInputTokens, 'inputTokens');
+        requireCounterTotal(newOutputTokens, 'outputTokens');
+        requireCounterTotal(newCacheReadInputTokens, 'cacheReadInputTokens');
+        requireCounterTotal(newCacheCreationInputTokens, 'cacheCreationInputTokens');
+        requireCounterTotal(newWebSearchRequests, 'webSearchRequests');
+        const hasUsage = inputTokens > 0 ||
+            outputTokens > 0 ||
+            cacheReadInputTokens > 0 ||
+            cacheCreationInputTokens > 0 ||
+            webSearchRequests > 0;
+        const newCostUsd = costUsd === undefined ? existing.costUsd : existing.costUsd + costUsd;
+        requireMetricTotal(newCostUsd, 'costUsd');
+        const newTotalCostUsd = costUsd === undefined ? this.totalCostUsd : this.totalCostUsd + costUsd;
+        requireMetricTotal(newTotalCostUsd, 'totalCostUsd');
+        const durationTotals = this.durationTotals({
+            apiDurationMs,
+            apiDurationWithoutRetriesMs,
+            toolDurationMs,
+        });
+        const newLinesAdded = this.linesAdded + linesAdded;
+        const newLinesRemoved = this.linesRemoved + linesRemoved;
+        requireCounterTotal(newLinesAdded, 'linesAdded');
+        requireCounterTotal(newLinesRemoved, 'linesRemoved');
+        // Every metric validated; commit atomically.
+        if (costUsd === undefined && hasUsage) {
+            this.hasUnknownModelCost = true;
+        }
+        this.modelUsage.set(model, {
+            inputTokens: newInputTokens,
+            outputTokens: newOutputTokens,
+            cacheReadInputTokens: newCacheReadInputTokens,
+            cacheCreationInputTokens: newCacheCreationInputTokens,
+            webSearchRequests: newWebSearchRequests,
+            costUsd: newCostUsd,
+        });
+        this.totalCostUsd = newTotalCostUsd;
+        this.apiDurationMs = durationTotals.apiDurationMs;
+        this.apiDurationWithoutRetriesMs =
+            durationTotals.apiDurationWithoutRetriesMs;
+        this.toolDurationMs = durationTotals.toolDurationMs;
+        this.linesAdded = newLinesAdded;
+        this.linesRemoved = newLinesRemoved;
+    }
+    recordDurations(input) {
+        const apiDurationMs = input.apiDurationMs === undefined
+            ? undefined
+            : requireMetric(input.apiDurationMs, 'apiDurationMs');
+        const apiDurationWithoutRetriesMs = input.apiDurationWithoutRetriesMs === undefined
+            ? undefined
+            : requireMetric(input.apiDurationWithoutRetriesMs, 'apiDurationWithoutRetriesMs');
+        const toolDurationMs = input.toolDurationMs === undefined
+            ? undefined
+            : requireMetric(input.toolDurationMs, 'toolDurationMs');
+        // Legacy fallback: a supplied API duration implies the retry-free total
+        // when the retry-free value is absent.
+        const resolvedApiDurationWithoutRetriesMs = apiDurationMs !== undefined && apiDurationWithoutRetriesMs === undefined
+            ? apiDurationMs
+            : apiDurationWithoutRetriesMs;
+        const durationTotals = this.durationTotals({
+            apiDurationMs,
+            apiDurationWithoutRetriesMs: resolvedApiDurationWithoutRetriesMs,
+            toolDurationMs,
+        });
+        this.apiDurationMs = durationTotals.apiDurationMs;
+        this.apiDurationWithoutRetriesMs =
+            durationTotals.apiDurationWithoutRetriesMs;
+        this.toolDurationMs = durationTotals.toolDurationMs;
+    }
+    durationTotals(options) {
+        const { apiDurationMs, apiDurationWithoutRetriesMs, toolDurationMs } = options;
+        const newApiDurationMs = apiDurationMs === undefined
+            ? this.apiDurationMs
+            : this.apiDurationMs + apiDurationMs;
+        const newApiDurationWithoutRetriesMs = apiDurationWithoutRetriesMs === undefined
+            ? this.apiDurationWithoutRetriesMs
+            : this.apiDurationWithoutRetriesMs + apiDurationWithoutRetriesMs;
+        const newToolDurationMs = toolDurationMs === undefined
+            ? this.toolDurationMs
+            : this.toolDurationMs + toolDurationMs;
+        if (apiDurationMs !== undefined) {
+            requireMetricTotal(newApiDurationMs, 'apiDurationMs');
+        }
+        if (apiDurationWithoutRetriesMs !== undefined) {
+            requireMetricTotal(newApiDurationWithoutRetriesMs, 'apiDurationWithoutRetriesMs');
+        }
+        if (toolDurationMs !== undefined) {
+            requireMetricTotal(newToolDurationMs, 'toolDurationMs');
+        }
+        return {
+            apiDurationMs: newApiDurationMs,
+            apiDurationWithoutRetriesMs: newApiDurationWithoutRetriesMs,
+            toolDurationMs: newToolDurationMs,
+        };
+    }
+    recordLineChanges(input) {
+        const linesAdded = input.linesAdded === undefined
+            ? 0
+            : requireCounter(input.linesAdded, 'linesAdded');
+        const linesRemoved = input.linesRemoved === undefined
+            ? 0
+            : requireCounter(input.linesRemoved, 'linesRemoved');
+        const newLinesAdded = this.linesAdded + linesAdded;
+        const newLinesRemoved = this.linesRemoved + linesRemoved;
+        requireCounterTotal(newLinesAdded, 'linesAdded');
+        requireCounterTotal(newLinesRemoved, 'linesRemoved');
+        this.linesAdded = newLinesAdded;
+        this.linesRemoved = newLinesRemoved;
+    }
+    snapshot() {
+        const modelUsage = {};
+        for (const [model, usage] of this.modelUsage) {
+            modelUsage[model] = { ...usage };
+        }
+        return {
+            sessionId: this.sessionId,
+            totalCostUsd: this.totalCostUsd,
+            apiDurationMs: this.apiDurationMs,
+            apiDurationWithoutRetriesMs: this.apiDurationWithoutRetriesMs,
+            toolDurationMs: this.toolDurationMs,
+            wallDurationMs: this.now() - this.startTime,
+            linesAdded: this.linesAdded,
+            linesRemoved: this.linesRemoved,
+            modelUsage,
+            hasUnknownModelCost: this.hasUnknownModelCost,
+        };
+    }
+}
+//# sourceMappingURL=session-cost-tracker.js.map