Skip to content

Commit b8851fb

Browse files
fixfonmaria-rcks
andauthored
fix(server): don't bill a replayed Codex first request twice (pingdotgg#22392)
Co-authored-by: maria-rcks <[email protected]>
1 parent 444df61 commit b8851fb

2 files changed

Lines changed: 146 additions & 2 deletions

File tree

‎apps/server/src/provider/Drivers/codexUsage.test.ts‎

Lines changed: 129 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
11
import { describe, expect, it } from "@effect/vitest";
2+
import { totalTokens } from "@t3tools/provider-core/server/usage";
23

34
import { codexUsageFormat, initialCodexScanState, parseCodexLine } from "./codexUsage.ts";
45

@@ -373,6 +374,106 @@ describe("parseCodexLine", () => {
373374
expect(codexUsageFormat.readMalformedRecords?.(state)).toBe(0);
374375
});
375376

377+
it("ignores a replay of the current sequence's first request without rewinding the baseline", () => {
378+
const state = initialCodexScanState();
379+
parseCodexLine(turnContext, state);
380+
const request = counters(100, 20);
381+
const processed = [
382+
counted(request, request),
383+
counted(request, counters(200, 40)),
384+
counted(request, request),
385+
counted(request, counters(300, 60)),
386+
].map((line) => {
387+
const record = parseCodexLine(line, state);
388+
return record === null ? 0 : totalTokens(record.totals);
389+
});
390+
391+
expect({
392+
processed,
393+
skipped: codexUsageFormat.readMalformedRecords?.(state),
394+
}).toEqual({ processed: [120, 120, 0, 120], skipped: 0 });
395+
});
396+
397+
it("bills a genuine restart with the same counters at a new timestamp", () => {
398+
const state = initialCodexScanState();
399+
parseCodexLine(turnContext, state);
400+
const request = counters(100, 20);
401+
const lines = [
402+
counted(request, request),
403+
counted(request, counters(200, 40)),
404+
counted(request, request).replace("05:17:49.919Z", "05:18:49.919Z"),
405+
counted(counters(30, 5), counters(130, 25)),
406+
];
407+
const processed = lines.map((line) => {
408+
const record = parseCodexLine(line, state);
409+
return record === null ? 0 : totalTokens(record.totals);
410+
});
411+
expect({ processed, skipped: codexUsageFormat.readMalformedRecords?.(state) }).toEqual({
412+
processed: [120, 120, 120, 35],
413+
skipped: 0,
414+
});
415+
});
416+
417+
it.each([
418+
{
419+
reset: true,
420+
markerTotal: counters(0, 0),
421+
nextTotal: counters(130, 25),
422+
processed: [120, 120, 0, 120, 35],
423+
},
424+
{
425+
reset: false,
426+
markerTotal: counters(200, 40),
427+
nextTotal: counters(230, 45),
428+
processed: [120, 120, 0, 0, 35],
429+
},
430+
])(
431+
"bills a request equal to the old sequence start only after a context marker reset the counters (reset: $reset)",
432+
({ markerTotal, nextTotal, processed }) => {
433+
const state = initialCodexScanState();
434+
parseCodexLine(turnContext, state);
435+
const request = counters(100, 20);
436+
const marker = counted({ ...counters(0, 0), total_tokens: 26387 }, markerTotal, {
437+
model_context_window: 475000,
438+
});
439+
const billed = [
440+
counted(request, request),
441+
counted(request, counters(200, 40)),
442+
marker,
443+
counted(request, request),
444+
counted(counters(30, 5), nextTotal),
445+
].map((line) => {
446+
const record = parseCodexLine(line, state);
447+
return record === null ? 0 : totalTokens(record.totals);
448+
});
449+
450+
expect({
451+
processed: billed,
452+
skipped: codexUsageFormat.readMalformedRecords?.(state),
453+
}).toEqual({ processed, skipped: 0 });
454+
},
455+
);
456+
457+
it("forgets the old sequence start when a malformed pair zeroes the cumulative baseline", () => {
458+
const state = initialCodexScanState();
459+
parseCodexLine(turnContext, state);
460+
const request = counters(100, 20);
461+
const processed = [
462+
counted(request, request),
463+
counted(counters(30, 5), counters(0, 0)),
464+
counted(request, request),
465+
counted(counters(30, 5), counters(130, 25)),
466+
].map((line) => {
467+
const record = parseCodexLine(line, state);
468+
return record === null ? 0 : totalTokens(record.totals);
469+
});
470+
471+
expect({
472+
processed,
473+
skipped: codexUsageFormat.readMalformedRecords?.(state),
474+
}).toEqual({ processed: [120, 0, 120, 35], skipped: 1 });
475+
});
476+
376477
it("retains initial tier evidence only for the own OpenAI session and exact context until native settings arrive", () => {
377478
const meta = (id: string, model_provider?: string) =>
378479
JSON.stringify({ type: "session_meta", payload: { id, model_provider } });
@@ -535,5 +636,33 @@ describe("parseCodexLine", () => {
535636
);
536637
expect(record).not.toBeNull();
537638
});
639+
640+
it("forgets the old sequence start when a copied zero baseline rebases the counters", () => {
641+
const state = initialCodexScanState();
642+
const forkInstant = "2026-08-01T05:00:00.000Z";
643+
const request = counters(100, 20);
644+
const billed = (line: string) => {
645+
const record = parseCodexLine(line, state);
646+
return record === null ? 0 : totalTokens(record.totals);
647+
};
648+
parseCodexLine(stamped("2026-08-01T04:59:00.000Z", turnContext), state);
649+
const first = billed(stamped("2026-08-01T04:59:01.000Z", counted(request, request)));
650+
parseCodexLine(meta({ id: "child", timestamp: forkInstant, forkedFromId: "parent" }), state);
651+
const copied = billed(
652+
stamped(
653+
"2026-08-01T05:00:00.001Z",
654+
counted({ ...counters(0, 0), total_tokens: 26387 }, counters(0, 0)),
655+
),
656+
);
657+
const afterBurst = billed(stamped("2026-08-01T05:00:06.000Z", counted(request, request)));
658+
const next = billed(
659+
stamped("2026-08-01T05:00:06.100Z", counted(counters(30, 5), counters(130, 25))),
660+
);
661+
662+
expect({
663+
processed: [first, copied, afterBurst, next],
664+
skipped: codexUsageFormat.readMalformedRecords?.(state),
665+
}).toEqual({ processed: [120, 0, 120, 35], skipped: 0 });
666+
});
538667
});
539668
});

‎apps/server/src/provider/Drivers/codexUsage.ts‎

Lines changed: 17 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -55,6 +55,12 @@ function readCodexTokenUsage(value: unknown): CodexTokenUsage | null {
5555
return isCodexTokenUsage(usage) ? usage : null;
5656
}
5757

58+
// A zeroed baseline rebases the counters, so the sequence start measured against it is forgotten.
59+
function rebaseCodexUsage(state: CodexScanState, cumulative: CodexTokenUsage) {
60+
state.lastCumulativeUsage = cumulative;
61+
if (cumulative.input_tokens + cumulative.output_tokens === 0) delete state.sequenceStartSignature;
62+
}
63+
5864
function advanceCodexUsage(previous: CodexTokenUsage | null, last: CodexTokenUsage) {
5965
return readCodexTokenUsage(
6066
Object.fromEntries(CODEX_USAGE_FIELDS.map((key) => [key, (previous?.[key] ?? 0) + last[key]])),
@@ -71,6 +77,8 @@ export const CodexScanState = Schema.Struct({
7177
sessionId: Schema.mutableKey(Schema.String),
7278
lastUsageSignature: Schema.mutableKey(Schema.NullOr(Schema.String)),
7379
lastCumulativeUsage: Schema.mutableKey(Schema.NullOr(CodexTokenUsage)),
80+
// Optional so scan states cached before this field existed stay valid.
81+
sequenceStartSignature: Schema.mutableKey(Schema.optionalKey(Schema.String)),
7482
malformedRecords: Schema.mutableKey(TokenCount),
7583
sawSessionMeta: Schema.mutableKey(Schema.Boolean),
7684
modelProvider: Schema.mutableKey(Schema.String),
@@ -193,7 +201,7 @@ function parseCodexRecord(parsed: unknown, state: CodexScanState): UsageRecord |
193201
state.forkCopyAnchorMs = timestampMs;
194202
// Copied history is already billed in the parent, but establishes the child's baseline.
195203
const signature = last === null ? null : JSON.stringify(last);
196-
if (cumulative !== null) state.lastCumulativeUsage = cumulative;
204+
if (cumulative !== null) rebaseCodexUsage(state, cumulative);
197205
else if (!hasCumulative && last !== null && signature !== state.lastUsageSignature) {
198206
state.lastCumulativeUsage = advanceCodexUsage(state.lastCumulativeUsage, last);
199207
}
@@ -206,7 +214,7 @@ function parseCodexRecord(parsed: unknown, state: CodexScanState): UsageRecord |
206214

207215
const previous = state.lastCumulativeUsage;
208216
// A valid snapshot remains the next baseline even when its paired request is malformed.
209-
if (cumulative !== null) state.lastCumulativeUsage = cumulative;
217+
if (cumulative !== null) rebaseCodexUsage(state, cumulative);
210218
if (last === null || (hasCumulative && cumulative === null)) {
211219
state.malformedRecords += 1;
212220
return null;
@@ -236,6 +244,12 @@ function parseCodexRecord(parsed: unknown, state: CodexScanState): UsageRecord |
236244
if (cumulative !== null) {
237245
// A session resumed in a new Codex process restarts its cumulative counters at this request.
238246
const restarted = CODEX_USAGE_FIELDS.every((key) => cumulative[key] === last[key]);
247+
const sequenceStart = JSON.stringify([timestampMs, last]);
248+
// Only the same event is a replay; a later request can restart with identical counters.
249+
if (restarted && sequenceStart === state.sequenceStartSignature) {
250+
state.lastCumulativeUsage = previous;
251+
return null;
252+
}
239253
// Forks and paginated continuations can inherit totals without copying a counter snapshot.
240254
// Only bill the latest request, and require the unseen prefix to be valid usage too.
241255
const reconciled =
@@ -248,6 +262,7 @@ function parseCodexRecord(parsed: unknown, state: CodexScanState): UsageRecord |
248262
state.malformedRecords += 1;
249263
return null;
250264
}
265+
if (restarted) state.sequenceStartSignature = sequenceStart;
251266
} else {
252267
if (signature === state.lastUsageSignature) return null;
253268
// Advance expected totals for billed legacy requests so a cumulative re-emission is stale.

0 commit comments

Comments
 (0)