@devries-cameron20 / t3code-1 / commits / b8851fbc82
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

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.