agent-afk 5.320.5 → 5.321.1

package/dist/agent/provider.d.ts

@@ -29,6 +29,7 @@ export interface ProviderUsage {
     outputTokens?: number;
     totalTokens?: number;
     contextWindowTokens?: number;
+    billing?: BillingUsage;
     totalCostUsd?: number;
     stopReason?: string | null;
     durationMs?: number;
@@ -40,6 +41,13 @@ export interface ProviderUsage {
     errors?: string[];
     raw?: Record<string, unknown>;
 }
+export interface BillingUsage {
+    provider: string;
+    uncachedInput: number;
+    cacheRead: number;
+    cacheWrite: number;
+    output: number;
+}
 export interface ProviderProgress {
     taskId: string;
     description: string;

package/dist/agent/session/accounting-accumulator.d.ts

@@ -1,5 +1,6 @@
 import type { ClosureSignals } from './closure-emitter.js';
 import type { ResponseMetadata } from '../types.js';
+import { type BillingRollupSnapshot } from './billing-rollup.js';
 interface TokenCounters {
     input: number;
     output: number;
@@ -12,6 +13,8 @@ export interface AccountingSnapshot {
     subagentCompletedCount: number;
     subagentRunningTokens: Readonly<TokenCounters>;
     subagentRunningCostUsd: number;
+    sessionBilling?: BillingRollupSnapshot;
+    subagentBilling?: BillingRollupSnapshot;
 }
 export declare class AccountingAccumulator {
     private sessionRunningCostUsd;
@@ -24,18 +27,15 @@ export declare class AccountingAccumulator {
     private subagentCompletedCount;
     private subagentRunningTokens;
     private subagentRunningCostUsd;
+    private readonly sessionBilling;
+    private readonly subagentBilling;
     reset(): void;
     recordTurnMetadata(m: ResponseMetadata): void;
     markHookBlocked(): void;
     markMaxTurnsHit(): void;
     markProviderError(): void;
     clearProviderError(): void;
-    recordSubagentCompletion(usage?: {
-        inputTokens?: number;
-        outputTokens?: number;
-        cacheReadTokens?: number;
-        cacheCreationTokens?: number;
-    }, costUsd?: number): void;
+    recordSubagentCompletion(usage?: import('../subagent/result.js').SubagentTrace['usage'], costUsd?: number): void;
     closureSignals(signal: AbortSignal, dispatchReason: string): ClosureSignals;
     snapshot(): AccountingSnapshot;
 }

package/dist/agent/session/agent-session.d.ts

@@ -90,12 +90,7 @@ export declare class AgentSession implements IAgentSession {
     getHistory(): readonly Message[];
     getTurnCount(): number;
     close(): Promise<void>;
-    recordSubagentCompletion(usage?: {
-        inputTokens?: number;
-        outputTokens?: number;
-        cacheReadTokens?: number;
-        cacheCreationTokens?: number;
-    }, costUsd?: number): void;
+    recordSubagentCompletion(usage?: import('../subagent/result.js').SubagentTrace['usage'], costUsd?: number): void;
     pushSidebandEvent(event: OutputEvent): void;
     recordLedgerElicitation(reqId: string, request: ElicitationRequest): void;
 }

package/dist/agent/session/agent-session.executors.d.ts

@@ -7,6 +7,7 @@ type SubagentUsage = {
     outputTokens?: number;
     cacheReadTokens?: number;
     cacheCreationTokens?: number;
+    outcome?: 'failed' | 'cancelled';
 };
 export declare function recordSubagentCompletionInTree(accounting: AccountingAccumulator, config: AgentConfig, abortController: AbortController, usage: SubagentUsage | undefined, costUsd: number | undefined): void;
 export {};

package/dist/agent/session/billing-rollup.d.ts

@@ -0,0 +1,18 @@
+import type { BillingUsage } from '../provider.js';
+import type { BillingRollupSnapshot } from '../trace/events.billing.js';
+export type { BillingCounters, BillingRollupSnapshot } from '../trace/events.billing.js';
+export declare class BillingRollup {
+    private total;
+    private byProvider;
+    private recorded;
+    add(b: BillingUsage | undefined): void;
+    reset(): void;
+    snapshot(): BillingRollupSnapshot | undefined;
+}
+export declare function optionalBilling<K extends string>(key: K, snap: BillingRollupSnapshot | undefined): Partial<Record<K, BillingRollupSnapshot>>;
+export declare function sealBillingField(root: BillingRollupSnapshot | undefined, subagents: BillingRollupSnapshot | undefined): {
+    billing?: {
+        root?: BillingRollupSnapshot;
+        subagents?: BillingRollupSnapshot;
+    };
+};

package/dist/agent/session/closure-emitter.d.ts

@@ -1,5 +1,6 @@
 import type { ClosureReason, TraceSink } from '../trace/index.js';
 import type { TraceWriter } from '../trace/writer.js';
+import { type BillingRollupSnapshot } from './billing-rollup.js';
 export interface ClosureTokenCounters {
     input: number;
     output: number;
@@ -28,6 +29,8 @@ export interface SealTraceInput extends ClosureSignals, ClosureTotals {
     subagentCompletedCount: number;
     subagentRunningTokens: ClosureTokenCounters;
     subagentRunningCostUsd: number;
+    sessionBilling?: BillingRollupSnapshot;
+    subagentBilling?: BillingRollupSnapshot;
     pendingChildTerminalWrites?: readonly Promise<void>[];
 }
 export declare function sealTraceWriter(writer: TraceWriter | undefined, input: SealTraceInput): Promise<void>;

package/dist/agent/session/manager-shutdown-config.d.ts

@@ -0,0 +1,7 @@
+import type { SubagentManager } from '../subagent.js';
+import type { AgentConfig } from '../types.js';
+export interface BillingStreamSource {
+    getPendingChildBillingStreams(): readonly Promise<void>[];
+}
+export declare function pendingChildBillingStreams(...sources: ReadonlyArray<BillingStreamSource | undefined>): readonly Promise<void>[];
+export declare function managerShutdownConfig(manager: SubagentManager, composeExecutor?: BillingStreamSource): Pick<AgentConfig, 'drainSubagents' | 'getPendingChildTerminalWrites' | 'getPendingChildBillingStreams'>;

package/dist/agent/session/session-executors.d.ts

@@ -10,12 +10,7 @@ export interface SessionExecutorsBindTarget {
     readonly hookRegistry: HookRegistry | undefined;
     readonly messageJournal: MessageJournal | undefined;
     getInputStreamRef(): Pick<InputStreamRef, 'pushUserMessage' | 'queueFrameworkContext'>;
-    recordSubagentCompletion(usage?: {
-        inputTokens?: number;
-        outputTokens?: number;
-        cacheReadTokens?: number;
-        cacheCreationTokens?: number;
-    }, costUsd?: number): void;
+    recordSubagentCompletion(usage?: import('../subagent/result.js').SubagentTrace['usage'], costUsd?: number): void;
 }
 export interface SessionExecutors {
     readonly subagentExecutor?: SubagentExecutor;
@@ -23,6 +18,7 @@ export interface SessionExecutors {
     readonly composeExecutor?: ComposeExecutor;
     bind(session: SessionExecutorsBindTarget): void;
     drain(reason: string): Promise<unknown>;
+    getPendingChildBillingStreams?(): readonly Promise<void>[];
 }
 export type ProviderExecutorOpts = Pick<SessionExecutors, 'subagentExecutor' | 'skillExecutor' | 'composeExecutor'>;
 export declare function providerExecutorOpts(executors: ProviderExecutorOpts | undefined): ProviderExecutorOpts;

package/dist/agent/subagent/capped-handoff.d.ts

@@ -1,5 +1,6 @@
 import type { Message, IAgentSession, OutputEvent } from '../types.js';
 import type { SubagentHandleImpl } from './handle.js';
+import type { RunBillingContext } from './handle.billing.js';
 import { TOOL_USE_LOOP_CAPPED } from '../providers/shared/tool-loop-cap.js';
 export declare function isNarrationOnly(text: string): boolean;
 export declare class CappedHandoffAccumulator {
@@ -13,7 +14,7 @@ export declare class CappedHandoffAccumulator {
     onEvent(event: OutputEvent): void;
     finish(finalMessage: Message | undefined, session: IAgentSession): Message;
 }
-export declare function emitSuccessfulHandoff<T>(handle: SubagentHandleImpl<T>, message: Message, startTime: number): Promise<void>;
+export declare function emitSuccessfulHandoff<T>(handle: SubagentHandleImpl<T>, message: Message, startTime: number, billingContext?: RunBillingContext): Promise<void>;
 export interface CappedHandoff {
     incomplete: true;
     incompleteReason: typeof TOOL_USE_LOOP_CAPPED;

package/dist/agent/subagent/handle.billing.d.ts

@@ -0,0 +1,13 @@
+import type { BillingUsage } from '../provider.js';
+import { billingLifecycleFields } from '../usage.billing.js';
+import type { SubagentHandleImpl } from './handle.js';
+export type SubagentUnsuccessfulOutcome = 'failed' | 'cancelled';
+export interface RunBillingContext {
+    total?: BillingUsage;
+    reported?: BillingUsage;
+    terminalOutcome?: SubagentUnsuccessfulOutcome;
+}
+export declare function unreportedBillingDelta(context: RunBillingContext): BillingUsage | undefined;
+export declare function takeUnreportedBilling(context: RunBillingContext): BillingUsage | undefined;
+export declare function settleUnreportedBilling<T>(handle: SubagentHandleImpl<T>, outcome: SubagentUnsuccessfulOutcome, context?: RunBillingContext): ReturnType<typeof billingLifecycleFields>;
+export declare function trackBillingStream<T>(pending: Set<Promise<void>>, stream: Promise<T>): Promise<T>;

package/dist/agent/subagent/handle.d.ts

@@ -1,6 +1,7 @@
 import type { ZodType } from 'zod';
 import type { ContentBlockParam } from '@anthropic-ai/sdk/resources';
 import { AbortGraph } from '../abort-graph.js';
+import type { BillingUsage } from '../provider.js';
 import type { HookRegistry } from '../hooks.js';
 import type { IAgentSession, Message } from '../types.js';
 import type { OutputEvent, SubagentProgressSink, SubagentProgressMeta } from '../types/session-types.js';
@@ -8,6 +9,7 @@ import type { TraceSink } from '../trace/index.js';
 import { PauseAwareCeiling } from './pause-ceiling.js';
 import type { WorkspaceEntry, WorkspaceStore } from '../workspace/workspace-store.js';
 import { type SubagentResult, type SubagentStatus, type SubagentTrace } from './result.js';
+import { type RunBillingContext } from './handle.billing.js';
 export type { SubagentProgressMeta };
 export interface SubagentHandle<T = unknown> {
     readonly id: string;
@@ -42,6 +44,7 @@ export declare class SubagentHandleImpl<T> implements SubagentHandle<T> {
     readonly _idleTimeoutMs: number;
     _currentStatus: SubagentStatus;
     private inFlight;
+    private runInProgress;
     _lastMessage: string | undefined;
     _lastDurationMs: number | undefined;
     private latestTerminalStatus;
@@ -54,6 +57,11 @@ export declare class SubagentHandleImpl<T> implements SubagentHandle<T> {
     _lastStreamedContent: string;
     _pauseCeiling: PauseAwareCeiling | undefined;
     _lastStopReason: string | undefined;
+    _billingContext: RunBillingContext;
+    readonly _pendingBillingStreams: Set<Promise<void>>;
+    get pendingBillingStreams(): Promise<void>[];
+    get _runBilling(): BillingUsage | undefined;
+    set _runBilling(value: BillingUsage | undefined);
     _logWriter?: {
         write(event: OutputEvent): void;
         close(): Promise<void>;

package/dist/agent/subagent/handle.run-success.d.ts

@@ -1,4 +1,5 @@
 import type { SubagentProgressSink } from '../types/session-types.js';
 import type { Message } from '../types.js';
+import { type RunBillingContext } from './handle.billing.js';
 import type { SubagentHandleImpl } from './handle.js';
-export declare function drainAndEmitSuccess(handle: SubagentHandleImpl<unknown>, firstMsg: Message, startTime: number, sinkOverride: SubagentProgressSink | undefined): Promise<Message>;
+export declare function drainAndEmitSuccess(handle: SubagentHandleImpl<unknown>, firstMsg: Message, startTime: number, sinkOverride: SubagentProgressSink | undefined, billingContext?: RunBillingContext): Promise<Message>;

package/dist/agent/subagent/handle.streaming.d.ts

@@ -3,7 +3,8 @@ import type { OutputEvent, SubagentProgressSink } from '../types/session-types.j
 import type { Message } from '../types.js';
 import { type SubagentResult, type SubagentStatus } from './result.js';
 import type { SubagentHandleImpl } from './handle.js';
-export declare function streamToFinalMessage<T>(handle: SubagentHandleImpl<T>, prompt: string | ContentBlockParam[], sinkOverride?: SubagentProgressSink): Promise<Message>;
+import { type RunBillingContext } from './handle.billing.js';
+export declare function streamToFinalMessage<T>(handle: SubagentHandleImpl<T>, prompt: string | ContentBlockParam[], sinkOverride?: SubagentProgressSink, billingContext?: RunBillingContext): Promise<Message>;
 export declare function runToResult<T>(handle: SubagentHandleImpl<T>, prompt: string | ContentBlockParam[], sinkOverride?: SubagentProgressSink): Promise<SubagentResult<T>>;
 export declare function runInBackground<T>(handle: SubagentHandleImpl<T>, prompt: string, onResult?: (result: SubagentResult<T>) => void, onProgress?: (event: OutputEvent) => void): void;
 export declare function dispatchStopAndRelease<T>(handle: SubagentHandleImpl<T>, reportedStatus: SubagentStatus, options?: {

package/dist/agent/subagent/result.d.ts

@@ -1,5 +1,6 @@
 import type { ZodError, ZodType } from 'zod';
 import type { Message } from '../types.js';
+import type { BillingUsage } from '../provider.js';
 import { type CappedHandoff } from './capped-handoff.js';
 import { type Signal } from '../signal-block.js';
 export type SubagentStatus = 'idle' | 'running' | 'succeeded' | 'failed' | 'cancelled';
@@ -31,6 +32,8 @@ export interface SubagentTrace {
         outputTokens?: number;
         cacheReadTokens?: number;
         cacheCreationTokens?: number;
+        billing?: BillingUsage;
+        outcome?: 'failed' | 'cancelled';
     };
 }
 export declare function createEmptyTrace(): SubagentTrace;

package/dist/agent/subagent.d.ts

@@ -13,6 +13,7 @@ export { SUBAGENT_DEFAULT_IDLE_TIMEOUT_MS, SUBAGENT_DRAIN_TIMEOUT_MS, resolveSub
 export type { ForkParent, ForkSubagentOptions, SubagentManagerOptions };
 export declare class SubagentManager {
     private readonly active;
+    private readonly pendingChildBillingStreams;
     readonly completed: CompletedCache;
     private readonly parentCanUseTool;
     private readonly hookRegistry;
@@ -54,6 +55,8 @@ export declare class SubagentManager {
     kill(id: string): Promise<boolean>;
     killAll(): Promise<void>;
     getPendingChildTerminalWrites(): readonly Promise<void>[];
+    getPendingChildBillingStreams(): readonly Promise<void>[];
+    private retainChildBillingStreams;
     abortAllAndDrain(reason?: unknown, origin?: AbortOrigin, timeoutMs?: number, rearm?: boolean): Promise<{
         drained: number;
         timedOut: boolean;

package/dist/agent/tools/compose-executor.d.ts

@@ -8,6 +8,11 @@ import type { DetachableToolRegistry } from './detach-registry.js';
 export declare class ComposeExecutor {
     private readonly ctx;
     private currentCwd;
+    private readonly billingManagers;
+    private readonly pendingBillingStreams;
+    getPendingChildBillingStreams(): readonly Promise<void>[];
+    private retainBillingStreams;
+    private teardownManager;
     constructor(ctx: ComposeExecutorContext);
     setCwd(cwd: string): void;
     setTraceWriter(writer: TraceSink | undefined): void;

package/dist/agent/trace/cost.d.ts

@@ -1,4 +1,4 @@
-export type SessionCostSource = 'closures+seal' | 'closures' | 'seal' | 'none';
+export type SessionCostSource = 'closures+seal' | 'closures' | 'closures-incomplete' | 'seal' | 'none';
 export interface CostTokens {
     input?: number;
     output?: number;
@@ -24,7 +24,9 @@ export declare class SessionCostAccumulator {
     private readonly tokens;
     private sealRoot;
     private sealSubagent;
+    private sealIncomplete;
     add(event: CostEventLike): void;
     result(): SessionCostBreakdown;
+    private tokenTotals;
 }
 export declare function computeSessionCost(events: Iterable<CostEventLike>): SessionCostBreakdown;

package/dist/agent/trace/events.billing.d.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+export declare const BillingCountersSchema: z.ZodObject<{
+    uncachedInput: z.ZodNumber;
+    cacheRead: z.ZodNumber;
+    cacheWrite: z.ZodNumber;
+    output: z.ZodNumber;
+}, z.core.$strip>;
+export declare const BillingRollupSchema: z.ZodObject<{
+    total: z.ZodObject<{
+        uncachedInput: z.ZodNumber;
+        cacheRead: z.ZodNumber;
+        cacheWrite: z.ZodNumber;
+        output: z.ZodNumber;
+    }, z.core.$strip>;
+    byProvider: z.ZodRecord<z.ZodString, z.ZodObject<{
+        uncachedInput: z.ZodNumber;
+        cacheRead: z.ZodNumber;
+        cacheWrite: z.ZodNumber;
+        output: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const SessionBillingSchema: z.ZodObject<{
+    root: z.ZodOptional<z.ZodObject<{
+        total: z.ZodObject<{
+            uncachedInput: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheWrite: z.ZodNumber;
+            output: z.ZodNumber;
+        }, z.core.$strip>;
+        byProvider: z.ZodRecord<z.ZodString, z.ZodObject<{
+            uncachedInput: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheWrite: z.ZodNumber;
+            output: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    subagents: z.ZodOptional<z.ZodObject<{
+        total: z.ZodObject<{
+            uncachedInput: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheWrite: z.ZodNumber;
+            output: z.ZodNumber;
+        }, z.core.$strip>;
+        byProvider: z.ZodRecord<z.ZodString, z.ZodObject<{
+            uncachedInput: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheWrite: z.ZodNumber;
+            output: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const BillingLifecycleShape: {
+    provider: z.ZodOptional<z.ZodString>;
+    tokens: z.ZodOptional<z.ZodObject<{
+        uncachedInput: z.ZodNumber;
+        cacheRead: z.ZodNumber;
+        cacheWrite: z.ZodNumber;
+        output: z.ZodNumber;
+    }, z.core.$strip>>;
+};
+export type BillingCounters = z.infer<typeof BillingCountersSchema>;
+export type BillingRollupSnapshot = z.infer<typeof BillingRollupSchema>;
+export interface SubagentBillingFields {
+    provider?: string;
+    tokens?: BillingCounters;
+}

package/dist/agent/trace/events.browser.d.ts

@@ -65,8 +65,8 @@ export declare const BrowserEventPayloadSchema: z.ZodObject<{
     urlBefore: z.ZodNullable<z.ZodString>;
     urlAfter: z.ZodNullable<z.ZodString>;
     status: z.ZodEnum<{
-        ok: "ok";
         error: "error";
+        ok: "ok";
         ambiguous_target: "ambiguous_target";
         blocked_by_policy: "blocked_by_policy";
     }>;

package/dist/agent/trace/events.d.ts

@@ -25,8 +25,8 @@ export declare const ToolCallCompletedPayloadSchema: z.ZodObject<{
     incompleteReason: z.ZodOptional<z.ZodString>;
     circuitBreaker: z.ZodOptional<z.ZodBoolean>;
     failureClass: z.ZodOptional<z.ZodEnum<{
-        budget: "budget";
         abort: "abort";
+        budget: "budget";
         "policy-refusal": "policy-refusal";
         timeout: "timeout";
         "permission-denied": "permission-denied";
@@ -62,8 +62,8 @@ export declare const ToolCallPayloadSchema: z.ZodDiscriminatedUnion<[z.ZodObject
     incompleteReason: z.ZodOptional<z.ZodString>;
     circuitBreaker: z.ZodOptional<z.ZodBoolean>;
     failureClass: z.ZodOptional<z.ZodEnum<{
-        budget: "budget";
         abort: "abort";
+        budget: "budget";
         "policy-refusal": "policy-refusal";
         timeout: "timeout";
         "permission-denied": "permission-denied";
@@ -274,6 +274,36 @@ export declare const SessionSealedPayloadSchema: z.ZodObject<{
         cacheCreation: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     subagentCostUsd: z.ZodOptional<z.ZodNumber>;
+    billing: z.ZodOptional<z.ZodObject<{
+        root: z.ZodOptional<z.ZodObject<{
+            total: z.ZodObject<{
+                uncachedInput: z.ZodNumber;
+                cacheRead: z.ZodNumber;
+                cacheWrite: z.ZodNumber;
+                output: z.ZodNumber;
+            }, z.core.$strip>;
+            byProvider: z.ZodRecord<z.ZodString, z.ZodObject<{
+                uncachedInput: z.ZodNumber;
+                cacheRead: z.ZodNumber;
+                cacheWrite: z.ZodNumber;
+                output: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        subagents: z.ZodOptional<z.ZodObject<{
+            total: z.ZodObject<{
+                uncachedInput: z.ZodNumber;
+                cacheRead: z.ZodNumber;
+                cacheWrite: z.ZodNumber;
+                output: z.ZodNumber;
+            }, z.core.$strip>;
+            byProvider: z.ZodRecord<z.ZodString, z.ZodObject<{
+                uncachedInput: z.ZodNumber;
+                cacheRead: z.ZodNumber;
+                cacheWrite: z.ZodNumber;
+                output: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const TraceEventInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"tool_call">;
@@ -297,8 +327,8 @@ export declare const TraceEventInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         incompleteReason: z.ZodOptional<z.ZodString>;
         circuitBreaker: z.ZodOptional<z.ZodBoolean>;
         failureClass: z.ZodOptional<z.ZodEnum<{
-            budget: "budget";
             abort: "abort";
+            budget: "budget";
             "policy-refusal": "policy-refusal";
             timeout: "timeout";
             "permission-denied": "permission-denied";
@@ -366,6 +396,13 @@ export declare const TraceEventInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         resolvedAgentType: z.ZodOptional<z.ZodString>;
         maxToolUseIterations: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>, z.ZodObject<{
+        provider: z.ZodOptional<z.ZodString>;
+        tokens: z.ZodOptional<z.ZodObject<{
+            uncachedInput: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheWrite: z.ZodNumber;
+            output: z.ZodNumber;
+        }, z.core.$strip>>;
         transition: z.ZodLiteral<"succeeded">;
         subagentId: z.ZodString;
         durationMs: z.ZodNumber;
@@ -374,14 +411,21 @@ export declare const TraceEventInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         outputBytes: z.ZodNumber;
         stopReason: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
+        provider: z.ZodOptional<z.ZodString>;
+        tokens: z.ZodOptional<z.ZodObject<{
+            uncachedInput: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheWrite: z.ZodNumber;
+            output: z.ZodNumber;
+        }, z.core.$strip>>;
         transition: z.ZodLiteral<"failed">;
         subagentId: z.ZodString;
         errorClass: z.ZodString;
         errorMessage: z.ZodString;
         partialOutputBytes: z.ZodNumber;
         failureClass: z.ZodOptional<z.ZodEnum<{
-            budget: "budget";
             abort: "abort";
+            budget: "budget";
             "policy-refusal": "policy-refusal";
             timeout: "timeout";
             "permission-denied": "permission-denied";
@@ -393,6 +437,13 @@ export declare const TraceEventInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject
             "hook-block-repeat": "hook-block-repeat";
         }>>;
     }, z.core.$strip>, z.ZodObject<{
+        provider: z.ZodOptional<z.ZodString>;
+        tokens: z.ZodOptional<z.ZodObject<{
+            uncachedInput: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheWrite: z.ZodNumber;
+            output: z.ZodNumber;
+        }, z.core.$strip>>;
         transition: z.ZodLiteral<"cancelled">;
         subagentId: z.ZodString;
         source: z.ZodEnum<{
@@ -565,8 +616,8 @@ export declare const TraceEventInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject
         urlBefore: z.ZodNullable<z.ZodString>;
         urlAfter: z.ZodNullable<z.ZodString>;
         status: z.ZodEnum<{
-            ok: "ok";
             error: "error";
+            ok: "ok";
             ambiguous_target: "ambiguous_target";
             blocked_by_policy: "blocked_by_policy";
         }>;
@@ -702,8 +753,8 @@ export declare const TraceEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         incompleteReason: z.ZodOptional<z.ZodString>;
         circuitBreaker: z.ZodOptional<z.ZodBoolean>;
         failureClass: z.ZodOptional<z.ZodEnum<{
-            budget: "budget";
             abort: "abort";
+            budget: "budget";
             "policy-refusal": "policy-refusal";
             timeout: "timeout";
             "permission-denied": "permission-denied";
@@ -777,6 +828,13 @@ export declare const TraceEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         resolvedAgentType: z.ZodOptional<z.ZodString>;
         maxToolUseIterations: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>, z.ZodObject<{
+        provider: z.ZodOptional<z.ZodString>;
+        tokens: z.ZodOptional<z.ZodObject<{
+            uncachedInput: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheWrite: z.ZodNumber;
+            output: z.ZodNumber;
+        }, z.core.$strip>>;
         transition: z.ZodLiteral<"succeeded">;
         subagentId: z.ZodString;
         durationMs: z.ZodNumber;
@@ -785,14 +843,21 @@ export declare const TraceEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         outputBytes: z.ZodNumber;
         stopReason: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
+        provider: z.ZodOptional<z.ZodString>;
+        tokens: z.ZodOptional<z.ZodObject<{
+            uncachedInput: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheWrite: z.ZodNumber;
+            output: z.ZodNumber;
+        }, z.core.$strip>>;
         transition: z.ZodLiteral<"failed">;
         subagentId: z.ZodString;
         errorClass: z.ZodString;
         errorMessage: z.ZodString;
         partialOutputBytes: z.ZodNumber;
         failureClass: z.ZodOptional<z.ZodEnum<{
-            budget: "budget";
             abort: "abort";
+            budget: "budget";
             "policy-refusal": "policy-refusal";
             timeout: "timeout";
             "permission-denied": "permission-denied";
@@ -804,6 +869,13 @@ export declare const TraceEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             "hook-block-repeat": "hook-block-repeat";
         }>>;
     }, z.core.$strip>, z.ZodObject<{
+        provider: z.ZodOptional<z.ZodString>;
+        tokens: z.ZodOptional<z.ZodObject<{
+            uncachedInput: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheWrite: z.ZodNumber;
+            output: z.ZodNumber;
+        }, z.core.$strip>>;
         transition: z.ZodLiteral<"cancelled">;
         subagentId: z.ZodString;
         source: z.ZodEnum<{
@@ -994,8 +1066,8 @@ export declare const TraceEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         urlBefore: z.ZodNullable<z.ZodString>;
         urlAfter: z.ZodNullable<z.ZodString>;
         status: z.ZodEnum<{
-            ok: "ok";
             error: "error";
+            ok: "ok";
             ambiguous_target: "ambiguous_target";
             blocked_by_policy: "blocked_by_policy";
         }>;
@@ -1134,5 +1206,35 @@ export declare const TraceEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             cacheCreation: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
         subagentCostUsd: z.ZodOptional<z.ZodNumber>;
+        billing: z.ZodOptional<z.ZodObject<{
+            root: z.ZodOptional<z.ZodObject<{
+                total: z.ZodObject<{
+                    uncachedInput: z.ZodNumber;
+                    cacheRead: z.ZodNumber;
+                    cacheWrite: z.ZodNumber;
+                    output: z.ZodNumber;
+                }, z.core.$strip>;
+                byProvider: z.ZodRecord<z.ZodString, z.ZodObject<{
+                    uncachedInput: z.ZodNumber;
+                    cacheRead: z.ZodNumber;
+                    cacheWrite: z.ZodNumber;
+                    output: z.ZodNumber;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            subagents: z.ZodOptional<z.ZodObject<{
+                total: z.ZodObject<{
+                    uncachedInput: z.ZodNumber;
+                    cacheRead: z.ZodNumber;
+                    cacheWrite: z.ZodNumber;
+                    output: z.ZodNumber;
+                }, z.core.$strip>;
+                byProvider: z.ZodRecord<z.ZodString, z.ZodObject<{
+                    uncachedInput: z.ZodNumber;
+                    cacheRead: z.ZodNumber;
+                    cacheWrite: z.ZodNumber;
+                    output: z.ZodNumber;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>;
 }, z.core.$strip>], "kind">;