The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 22, 12:00 UTC
fix(server): don't bill a replayed Codex first request twice (#22392)
Co-authored-by: maria-rcks <maria@kuuro.net>
fixfon committed
Oct 30, 2026 at 23:40 UTC
b8851fbc825d11855a29233e84833e471f6c69a5
2 files changed
+146
-2
apps/server/src/provider/Drivers/codexUsage.test.ts
+129
@@ -1,4 +1,5 @@
1
import { describe, expect, it } from "@effect/vitest";
2
+import { totalTokens } from "@t3tools/provider-core/server/usage";
3
4
import { codexUsageFormat, initialCodexScanState, parseCodexLine } from "./codexUsage.ts";
5
@@ -373,6 +374,106 @@ describe("parseCodexLine", () => {
374
expect(codexUsageFormat.readMalformedRecords?.(state)).toBe(0);
375
});
376
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
+
477
it("retains initial tier evidence only for the own OpenAI session and exact context until native settings arrive", () => {
478
const meta = (id: string, model_provider?: string) =>
479
JSON.stringify({ type: "session_meta", payload: { id, model_provider } });
@@ -535,5 +636,33 @@ describe("parseCodexLine", () => {
636
);
637
expect(record).not.toBeNull();
638
});
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
+ });
667
});
668
});
apps/server/src/provider/Drivers/codexUsage.ts
+17
-2
@@ -55,6 +55,12 @@ function readCodexTokenUsage(value: unknown): CodexTokenUsage | null {
55
return isCodexTokenUsage(usage) ? usage : null;
56
}
57
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
+
64
function advanceCodexUsage(previous: CodexTokenUsage | null, last: CodexTokenUsage) {
65
return readCodexTokenUsage(
66
Object.fromEntries(CODEX_USAGE_FIELDS.map((key) => [key, (previous?.[key] ?? 0) + last[key]])),
@@ -71,6 +77,8 @@ export const CodexScanState = Schema.Struct({
77
sessionId: Schema.mutableKey(Schema.String),
78
lastUsageSignature: Schema.mutableKey(Schema.NullOr(Schema.String)),
79
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)),
82
malformedRecords: Schema.mutableKey(TokenCount),
83
sawSessionMeta: Schema.mutableKey(Schema.Boolean),
84
modelProvider: Schema.mutableKey(Schema.String),
@@ -193,7 +201,7 @@ function parseCodexRecord(parsed: unknown, state: CodexScanState): UsageRecord |
201
state.forkCopyAnchorMs = timestampMs;
202
// Copied history is already billed in the parent, but establishes the child's baseline.
203
const signature = last === null ? null : JSON.stringify(last);
196
- if (cumulative !== null) state.lastCumulativeUsage = cumulative;
204
+ if (cumulative !== null) rebaseCodexUsage(state, cumulative);
205
else if (!hasCumulative && last !== null && signature !== state.lastUsageSignature) {
206
state.lastCumulativeUsage = advanceCodexUsage(state.lastCumulativeUsage, last);
207
}
@@ -206,7 +214,7 @@ function parseCodexRecord(parsed: unknown, state: CodexScanState): UsageRecord |
214
215
const previous = state.lastCumulativeUsage;
216
// 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);
218
if (last === null || (hasCumulative && cumulative === null)) {
219
state.malformedRecords += 1;
220
return null;
@@ -236,6 +244,12 @@ function parseCodexRecord(parsed: unknown, state: CodexScanState): UsageRecord |
244
if (cumulative !== null) {
245
// A session resumed in a new Codex process restarts its cumulative counters at this request.
246
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
+ }
253
// Forks and paginated continuations can inherit totals without copying a counter snapshot.
254
// Only bill the latest request, and require the unseen prefix to be valid usage too.
255
const reconciled =
@@ -248,6 +262,7 @@ function parseCodexRecord(parsed: unknown, state: CodexScanState): UsageRecord |
262
state.malformedRecords += 1;
263
return null;
264
}
265
+ if (restarted) state.sequenceStartSignature = sequenceStart;
266
} else {
267
if (signature === state.lastUsageSignature) return null;
268
// Advance expected totals for billed legacy requests so a cumulative re-emission is stale.