import type { TurnTokenUsage } from "@t3tools/contracts";
import type * as EffectCodexSchema from "effect-codex-app-server/schema";
type CodexCumulativeTokenUsage = {
readonly inputTokens: number;
readonly cachedInputTokens: number;
readonly cacheCreationTokens?: number;
readonly outputTokens: number;
readonly reasoningTokens: number;
};
interface CodexTurnTokenUsageAccumulator {
inputTokens: number;
cachedInputTokens: number;
cacheCreationTokens: number | undefined;
outputTokens: number;
reasoningTokens: number;
observed: boolean;
hasSubagents: boolean;
}
export interface CodexTurnTokenUsageState {
baseline: CodexCumulativeTokenUsage | undefined;
activeTurnId: string | undefined;
readonly byTurnId: Map<string, CodexTurnTokenUsageAccumulator>;
}
function codexTokenUsageBreakdown(
usage: EffectCodexSchema.V2ThreadTokenUsageUpdatedNotification__TokenUsageBreakdown,
): CodexCumulativeTokenUsage {
return {
inputTokens: usage.inputTokens,
cachedInputTokens: usage.cachedInputTokens,
...(usage.cacheWriteInputTokens !== undefined
? { cacheCreationTokens: usage.cacheWriteInputTokens }
: {}),
outputTokens: usage.outputTokens,
reasoningTokens: usage.reasoningOutputTokens,
};
}
export function makeCodexTurnTokenUsageState(): CodexTurnTokenUsageState {
return {
baseline: undefined,
activeTurnId: undefined,
byTurnId: new Map(),
};
}
export function getCodexTurnAccumulator(
state: CodexTurnTokenUsageState,
turnId: string,
): CodexTurnTokenUsageAccumulator {
const existing = state.byTurnId.get(turnId);
if (existing) return existing;
const created: CodexTurnTokenUsageAccumulator = {
inputTokens: 0,
cachedInputTokens: 0,
cacheCreationTokens: 0,
outputTokens: 0,
reasoningTokens: 0,
observed: false,
hasSubagents: false,
};
state.byTurnId.set(turnId, created);
return created;
}
/** total is thread-wide; last covers the newest model response. */
function codexTurnTokenUsageDelta(
previous: CodexCumulativeTokenUsage | undefined,
current: CodexCumulativeTokenUsage,
last: CodexCumulativeTokenUsage,
): CodexCumulativeTokenUsage {
if (
previous === undefined ||
current.inputTokens < previous.inputTokens ||
current.cachedInputTokens < previous.cachedInputTokens ||
current.outputTokens < previous.outputTokens ||
current.reasoningTokens < previous.reasoningTokens
) {
return last;
}
return {
inputTokens: current.inputTokens - previous.inputTokens,
cachedInputTokens: current.cachedInputTokens - previous.cachedInputTokens,
...(current.cacheCreationTokens !== undefined &&
previous.cacheCreationTokens !== undefined &&
current.cacheCreationTokens >= previous.cacheCreationTokens
? { cacheCreationTokens: current.cacheCreationTokens - previous.cacheCreationTokens }
: {}),
outputTokens: current.outputTokens - previous.outputTokens,
reasoningTokens: current.reasoningTokens - previous.reasoningTokens,
};
}
export function accumulateCodexTurnTokenUsage(
state: CodexTurnTokenUsageState,
turnId: string,
usage: EffectCodexSchema.V2ThreadTokenUsageUpdatedNotification["tokenUsage"],
): void {
const current = codexTokenUsageBreakdown(usage.total);
if (state.activeTurnId !== turnId) {
// Every thread-wide total updates the baseline; late finished-turn updates do not count toward the live turn.
state.baseline = current;
return;
}
const accumulator = getCodexTurnAccumulator(state, turnId);
const delta = codexTurnTokenUsageDelta(
state.baseline,
current,
codexTokenUsageBreakdown(usage.last),
);
state.baseline = current;
if (
delta.inputTokens > 0 ||
delta.cachedInputTokens > 0 ||
delta.outputTokens > 0 ||
delta.reasoningTokens > 0
) {
accumulator.observed = true;
}
accumulator.inputTokens += delta.inputTokens;
accumulator.cachedInputTokens += delta.cachedInputTokens;
accumulator.outputTokens += delta.outputTokens;
accumulator.reasoningTokens += delta.reasoningTokens;
if (delta.cacheCreationTokens === undefined) {
accumulator.cacheCreationTokens = undefined;
} else if (accumulator.cacheCreationTokens !== undefined) {
accumulator.cacheCreationTokens += delta.cacheCreationTokens;
}
}
/** `model` is the thread model Codex last reported, which a reroute replaces. */
export function completeCodexTurnTokenUsage(
state: CodexTurnTokenUsageState,
turnId: string,
completed: boolean,
model?: string,
): TurnTokenUsage {
const usage = state.byTurnId.get(turnId);
state.byTurnId.delete(turnId);
if (state.activeTurnId === turnId) state.activeTurnId = undefined;
const models = model === undefined ? {} : { models: [model] };
if (!usage?.observed) {
return {
usageStatus: "unavailable",
usageScope: "main_agent",
hasSubagents: usage?.hasSubagents ?? false,
...models,
};
}
// Codex counts cache reads and writes inside inputTokens.
return {
usageStatus: completed ? "complete" : "partial",
usageScope: "main_agent",
inputTokens: usage.inputTokens,
cachedInputTokens: Math.min(usage.inputTokens, usage.cachedInputTokens),
...(usage.cacheCreationTokens !== undefined
? { cacheCreationTokens: Math.min(usage.inputTokens, usage.cacheCreationTokens) }
: {}),
outputTokens: usage.outputTokens,
reasoningTokens: Math.min(usage.outputTokens, usage.reasoningTokens),
hasSubagents: usage.hasSubagents,
...models,
};
}