Open History to see the last commit
1import type { TurnTokenUsage } from "@t3tools/contracts";
2import type * as EffectCodexSchema from "effect-codex-app-server/schema";
3
4type CodexCumulativeTokenUsage = {
5 readonly inputTokens: number;
6 readonly cachedInputTokens: number;
7 readonly cacheCreationTokens?: number;
8 readonly outputTokens: number;
9 readonly reasoningTokens: number;
10};
11
12interface CodexTurnTokenUsageAccumulator {
13 inputTokens: number;
14 cachedInputTokens: number;
15 cacheCreationTokens: number | undefined;
16 outputTokens: number;
17 reasoningTokens: number;
18 observed: boolean;
19 hasSubagents: boolean;
20}
21
22export interface CodexTurnTokenUsageState {
23 baseline: CodexCumulativeTokenUsage | undefined;
24 activeTurnId: string | undefined;
25 readonly byTurnId: Map<string, CodexTurnTokenUsageAccumulator>;
26}
27
28function codexTokenUsageBreakdown(
29 usage: EffectCodexSchema.V2ThreadTokenUsageUpdatedNotification__TokenUsageBreakdown,
30): CodexCumulativeTokenUsage {
31 return {
32 inputTokens: usage.inputTokens,
33 cachedInputTokens: usage.cachedInputTokens,
34 ...(usage.cacheWriteInputTokens !== undefined
35 ? { cacheCreationTokens: usage.cacheWriteInputTokens }
36 : {}),
37 outputTokens: usage.outputTokens,
38 reasoningTokens: usage.reasoningOutputTokens,
39 };
40}
41
42export function makeCodexTurnTokenUsageState(): CodexTurnTokenUsageState {
43 return {
44 baseline: undefined,
45 activeTurnId: undefined,
46 byTurnId: new Map(),
47 };
48}
49
50export function getCodexTurnAccumulator(
51 state: CodexTurnTokenUsageState,
52 turnId: string,
53): CodexTurnTokenUsageAccumulator {
54 const existing = state.byTurnId.get(turnId);
55 if (existing) return existing;
56 const created: CodexTurnTokenUsageAccumulator = {
57 inputTokens: 0,
58 cachedInputTokens: 0,
59 cacheCreationTokens: 0,
60 outputTokens: 0,
61 reasoningTokens: 0,
62 observed: false,
63 hasSubagents: false,
64 };
65 state.byTurnId.set(turnId, created);
66 return created;
67}
68
69/** total is thread-wide; last covers the newest model response. */
70function codexTurnTokenUsageDelta(
71 previous: CodexCumulativeTokenUsage | undefined,
72 current: CodexCumulativeTokenUsage,
73 last: CodexCumulativeTokenUsage,
74): CodexCumulativeTokenUsage {
75 if (
76 previous === undefined ||
77 current.inputTokens < previous.inputTokens ||
78 current.cachedInputTokens < previous.cachedInputTokens ||
79 current.outputTokens < previous.outputTokens ||
80 current.reasoningTokens < previous.reasoningTokens
81 ) {
82 return last;
83 }
84 return {
85 inputTokens: current.inputTokens - previous.inputTokens,
86 cachedInputTokens: current.cachedInputTokens - previous.cachedInputTokens,
87 ...(current.cacheCreationTokens !== undefined &&
88 previous.cacheCreationTokens !== undefined &&
89 current.cacheCreationTokens >= previous.cacheCreationTokens
90 ? { cacheCreationTokens: current.cacheCreationTokens - previous.cacheCreationTokens }
91 : {}),
92 outputTokens: current.outputTokens - previous.outputTokens,
93 reasoningTokens: current.reasoningTokens - previous.reasoningTokens,
94 };
95}
96
97export function accumulateCodexTurnTokenUsage(
98 state: CodexTurnTokenUsageState,
99 turnId: string,
100 usage: EffectCodexSchema.V2ThreadTokenUsageUpdatedNotification["tokenUsage"],
101): void {
102 const current = codexTokenUsageBreakdown(usage.total);
103 if (state.activeTurnId !== turnId) {
104 // Every thread-wide total updates the baseline; late finished-turn updates do not count toward the live turn.
105 state.baseline = current;
106 return;
107 }
108
109 const accumulator = getCodexTurnAccumulator(state, turnId);
110 const delta = codexTurnTokenUsageDelta(
111 state.baseline,
112 current,
113 codexTokenUsageBreakdown(usage.last),
114 );
115 state.baseline = current;
116
117 if (
118 delta.inputTokens > 0 ||
119 delta.cachedInputTokens > 0 ||
120 delta.outputTokens > 0 ||
121 delta.reasoningTokens > 0
122 ) {
123 accumulator.observed = true;
124 }
125 accumulator.inputTokens += delta.inputTokens;
126 accumulator.cachedInputTokens += delta.cachedInputTokens;
127 accumulator.outputTokens += delta.outputTokens;
128 accumulator.reasoningTokens += delta.reasoningTokens;
129 if (delta.cacheCreationTokens === undefined) {
130 accumulator.cacheCreationTokens = undefined;
131 } else if (accumulator.cacheCreationTokens !== undefined) {
132 accumulator.cacheCreationTokens += delta.cacheCreationTokens;
133 }
134}
135
136/** `model` is the thread model Codex last reported, which a reroute replaces. */
137export function completeCodexTurnTokenUsage(
138 state: CodexTurnTokenUsageState,
139 turnId: string,
140 completed: boolean,
141 model?: string,
142): TurnTokenUsage {
143 const usage = state.byTurnId.get(turnId);
144 state.byTurnId.delete(turnId);
145 if (state.activeTurnId === turnId) state.activeTurnId = undefined;
146 const models = model === undefined ? {} : { models: [model] };
147 if (!usage?.observed) {
148 return {
149 usageStatus: "unavailable",
150 usageScope: "main_agent",
151 hasSubagents: usage?.hasSubagents ?? false,
152 ...models,
153 };
154 }
155
156 // Codex counts cache reads and writes inside inputTokens.
157 return {
158 usageStatus: completed ? "complete" : "partial",
159 usageScope: "main_agent",
160 inputTokens: usage.inputTokens,
161 cachedInputTokens: Math.min(usage.inputTokens, usage.cachedInputTokens),
162 ...(usage.cacheCreationTokens !== undefined
163 ? { cacheCreationTokens: Math.min(usage.inputTokens, usage.cacheCreationTokens) }
164 : {}),
165 outputTokens: usage.outputTokens,
166 reasoningTokens: Math.min(usage.outputTokens, usage.reasoningTokens),
167 hasSubagents: usage.hasSubagents,
168 ...models,
169 };
170}