The best way to control Claude Code, Codex and more from any computer or phone
fix(server): recover missing initial Codex usage tiers (#21899)
Julius Marminge committed
Oct 19, 2026 at 22:25 UTC
d243b09296b2fa5bb979773ebce39da2b9f397d3
11 files changed
+524
-78
apps/server/src/provider/Drivers/CodexDriver.ts
+6
-1
@@ -7,6 +7,7 @@ import * as Schema from "effect/Schema";
7
import { HttpClient } from "effect/http";
8
import { ChildProcessSpawner } from "effect/process";
9
10
+import type * as CodexUsageHistory from "../../usage/CodexUsageHistory.ts";
11
import { makeCodexTextGeneration } from "../../textGeneration/CodexTextGeneration.ts";
12
import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions";
13
import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost";
@@ -97,7 +98,11 @@ export type CodexDriverEnv =
98
| ServerEnvironment.ServerEnvironmentIdentity
99
| CodexInstallation.CodexInstallation;
100
100
-export const CodexDriver: ProviderDriver<CodexSettings, CodexDriverEnv, Path.Path> = {
101
+export const CodexDriver: ProviderDriver<
102
+ CodexSettings,
103
+ CodexDriverEnv,
104
+ Path.Path | CodexUsageHistory.CodexUsageHistory
105
+> = {
106
driverKind: DRIVER_KIND,
107
metadata: {
108
displayName: "Codex",
apps/server/src/provider/Drivers/codexUsage.test.ts
+69
@@ -251,6 +251,75 @@ describe("parseCodexLine", () => {
251
expect(speedAfter(settings({ model: "gpt-6-astra" }), 4)).toBe("standard");
252
});
253
254
+ it("retains initial tier evidence only for the own OpenAI session and exact context until native settings arrive", () => {
255
+ const meta = (id: string, model_provider?: string) =>
256
+ JSON.stringify({ type: "session_meta", payload: { id, model_provider } });
257
+ const context = (turn_id?: string, model?: string) =>
258
+ JSON.stringify({ type: "turn_context", payload: { turn_id, model } });
259
+ for (const provider of ["openai", "t3", "custom", undefined]) {
260
+ const state = initialCodexScanState();
261
+ parseCodexLine(meta("own-session", provider), state);
262
+ parseCodexLine(meta("ancestor", provider === "openai" ? "custom" : "openai"), state);
263
+ parseCodexLine(context("first-turn", "gpt-6-astra"), state);
264
+ const first = parseCodexLine(tokenCount(100, 0, 1, 0), state);
265
+ expect(first).toMatchObject({
266
+ sessionId: "own-session",
267
+ model: "gpt-6-astra",
268
+ speed: "standard",
269
+ });
270
+ if (provider === "openai") {
271
+ expect(first).toHaveProperty("unresolvedServiceTierTurnId", "first-turn");
272
+ } else {
273
+ expect(first).not.toHaveProperty("unresolvedServiceTierTurnId");
274
+ }
275
+
276
+ parseCodexLine(context(undefined, "gpt-6-astra"), state);
277
+ expect(parseCodexLine(tokenCount(100, 0, 2, 0), state)).not.toHaveProperty(
278
+ "unresolvedServiceTierTurnId",
279
+ );
280
+ parseCodexLine(context("missing-model"), state);
281
+ expect(parseCodexLine(tokenCount(100, 0, 3, 0), state)).not.toHaveProperty(
282
+ "unresolvedServiceTierTurnId",
283
+ );
284
+ parseCodexLine(context("next-turn", "gpt-6-astra"), state);
285
+ const next = parseCodexLine(tokenCount(100, 0, 4, 0), state);
286
+ if (provider === "openai") {
287
+ expect(next).toHaveProperty("unresolvedServiceTierTurnId", "next-turn");
288
+ } else {
289
+ expect(next).not.toHaveProperty("unresolvedServiceTierTurnId");
290
+ }
291
+ }
292
+
293
+ for (const service_tier of ["standard", "", undefined, "priority", "ultrafast"]) {
294
+ const state = initialCodexScanState();
295
+ parseCodexLine(meta("own-session", "openai"), state);
296
+ parseCodexLine(context("first-turn", "gpt-6-astra"), state);
297
+ expect(parseCodexLine(tokenCount(100, 0, 1, 0), state)).toHaveProperty(
298
+ "unresolvedServiceTierTurnId",
299
+ "first-turn",
300
+ );
301
+ parseCodexLine(
302
+ JSON.stringify({
303
+ type: "event_msg",
304
+ payload: { type: "thread_settings_applied", thread_settings: { service_tier } },
305
+ }),
306
+ state,
307
+ );
308
+ for (const output of [2, 3]) {
309
+ parseCodexLine(context(`native-turn-${output}`, "gpt-6-astra"), state);
310
+ const record = parseCodexLine(tokenCount(100, 0, output, 0), state);
311
+ expect(record?.speed).toBe(
312
+ service_tier === "priority"
313
+ ? "fast"
314
+ : service_tier === "ultrafast"
315
+ ? "ultrafast"
316
+ : "standard",
317
+ );
318
+ expect(record).not.toHaveProperty("unresolvedServiceTierTurnId");
319
+ }
320
+ }
321
+ });
322
+
323
// A forked/subagent rollout opens with the parent's history copied in and
324
// every line re-stamped to the fork instant, then the ancestors' session
325
// metas. Counting those again multiplied usage ~1.85x on real data (#5758).
apps/server/src/provider/Drivers/codexUsage.ts
+57
-1
@@ -13,6 +13,7 @@ import {
13
} from "@t3tools/provider-core/server/usage";
14
import type { UsageTokenTotals } from "@t3tools/contracts";
15
16
+import * as CodexUsageHistory from "../../usage/CodexUsageHistory.ts";
17
import { resolveCodexHomeLayout } from "./CodexHomeLayout.ts";
18
19
const TokenCount = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
@@ -72,6 +73,9 @@ export const CodexScanState = Schema.Struct({
73
lastCumulativeUsage: Schema.mutableKey(Schema.NullOr(CodexTokenUsage)),
74
malformedRecords: Schema.mutableKey(TokenCount),
75
sawSessionMeta: Schema.mutableKey(Schema.Boolean),
76
+ modelProvider: Schema.mutableKey(Schema.String),
77
+ turnId: Schema.mutableKey(Schema.String),
78
+ sawThreadSettings: Schema.mutableKey(Schema.Boolean),
79
suppressingForkCopies: Schema.mutableKey(Schema.Boolean),
80
forkCopyAnchorMs: Schema.mutableKey(Schema.Finite),
81
});
@@ -86,6 +90,9 @@ export function initialCodexScanState(): CodexScanState {
90
lastCumulativeUsage: null,
91
malformedRecords: 0,
92
sawSessionMeta: false,
93
+ modelProvider: "",
94
+ turnId: "",
95
+ sawThreadSettings: false,
96
suppressingForkCopies: false,
97
forkCopyAnchorMs: 0,
98
};
@@ -141,6 +148,9 @@ function parseCodexRecord(parsed: unknown, state: CodexScanState): UsageRecord |
148
state.sawSessionMeta = true;
149
const id = payloadRecord["id"] ?? payloadRecord["session_id"];
150
if (typeof id === "string") state.sessionId = id;
151
+ if (typeof payloadRecord["model_provider"] === "string") {
152
+ state.modelProvider = payloadRecord["model_provider"];
153
+ }
154
const metaTimestampMs = parseTimestampMs(record["timestamp"]);
155
if (metaTimestampMs !== null && isForkedSessionMeta(payloadRecord)) {
156
state.suppressingForkCopies = true;
@@ -151,10 +161,18 @@ function parseCodexRecord(parsed: unknown, state: CodexScanState): UsageRecord |
161
162
if (record["type"] === "turn_context") {
163
if (typeof payloadRecord["model"] === "string") state.model = payloadRecord["model"];
164
+ // Model carry is useful for usage, but history recovery needs this context's own identity.
165
+ state.turnId =
166
+ typeof payloadRecord["turn_id"] === "string" &&
167
+ typeof payloadRecord["model"] === "string" &&
168
+ payloadRecord["model"].length > 0
169
+ ? payloadRecord["turn_id"]
170
+ : "";
171
return null;
172
}
173
174
if (payloadType === "thread_settings_applied") {
175
+ state.sawThreadSettings = true;
176
const settings = payloadRecord["thread_settings"];
177
if (typeof settings === "object" && settings !== null) {
178
state.speed = codexSpeed((settings as Record<string, unknown>)["service_tier"]);
@@ -270,6 +288,12 @@ function parseCodexRecord(parsed: unknown, state: CodexScanState): UsageRecord |
288
totals,
289
reportedCostUsd: null,
290
speed: state.speed,
291
+ ...(!state.sawThreadSettings &&
292
+ state.modelProvider === "openai" &&
293
+ state.sessionId.length > 0 &&
294
+ state.turnId.length > 0
295
+ ? { unresolvedServiceTierTurnId: state.turnId }
296
+ : {}),
297
dedupeKey: null,
298
};
299
}
@@ -295,6 +319,8 @@ export const codexUsageFormat: TranscriptUsageFormat<CodexScanState> = {
319
type: true,
320
id: true,
321
session_id: true,
322
+ model_provider: true,
323
+ turn_id: true,
324
model: true,
325
thread_settings: { service_tier: true },
326
forked_from_id: true,
@@ -313,10 +339,40 @@ export const codexUsageFormat: TranscriptUsageFormat<CodexScanState> = {
339
sharedSessionsAcrossFiles: true,
340
};
341
316
-export const codexUsageReader: ProviderUsageReader<CodexSettings, Path.Path> = {
342
+export const codexUsageReader: ProviderUsageReader<
343
+ CodexSettings,
344
+ Path.Path | CodexUsageHistory.CodexUsageHistory
345
+> = {
346
kind: "transcripts",
347
provider: "codex",
348
format: codexUsageFormat,
349
+ resolveServiceTiers: Effect.fn("codexUsageReader.resolveServiceTiers")(function* (records) {
350
+ const history = yield* CodexUsageHistory.CodexUsageHistory;
351
+ const requests = new Map<CodexUsageHistory.CodexUsageHistoryRequest, UsageRecord>();
352
+ for (const record of records) {
353
+ if (record.unresolvedServiceTierTurnId === undefined) continue;
354
+ requests.set(
355
+ {
356
+ sessionId: record.sessionId,
357
+ nativeTurnId: record.unresolvedServiceTierTurnId,
358
+ model: record.model,
359
+ },
360
+ record,
361
+ );
362
+ }
363
+ const resolved = yield* history.resolve([...requests.keys()]).pipe(
364
+ Effect.catchTags({
365
+ CodexUsageHistoryReadError: () =>
366
+ Effect.succeed(new Map<CodexUsageHistory.CodexUsageHistoryRequest, UsageSpeed>()),
367
+ }),
368
+ );
369
+ const speeds = new Map<UsageRecord, UsageSpeed>();
370
+ for (const [request, speed] of resolved) {
371
+ const record = requests.get(request);
372
+ if (record !== undefined) speeds.set(record, speed);
373
+ }
374
+ return speeds;
375
+ }),
376
directories: Effect.fn("codexUsageReader.directories")(function* ({ config, environment }) {
377
if (config === undefined) return [];
378
const path = yield* Path.Path;
apps/server/src/server.ts
+2
@@ -170,6 +170,7 @@ import * as CursorAccountReader from "@t3tools/provider-cursor/server/CursorAcco
170
import * as CursorKeychain from "@t3tools/provider-cursor/server/CursorKeychain";
171
import * as CursorUsageAccounts from "@t3tools/provider-cursor/server/CursorUsageAccounts";
172
import * as UsageService from "./usage/UsageService.ts";
173
+import * as CodexUsageHistory from "./usage/CodexUsageHistory.ts";
174
import * as RuntimeLayer from "./orchestration-v2/runtimeLayer.ts";
175
import * as ProjectStore from "./orchestration-v2/ProjectStore.ts";
176
import * as ThreadSearch from "./orchestration-v2/ThreadSearch.ts";
@@ -265,6 +266,7 @@ const layerUsage = UsageService.layer.pipe(
266
Layer.provide(
267
Layer.mergeAll(
268
AntigravityUsage.layer,
269
+ CodexUsageHistory.layer,
270
CursorUsageAccounts.layer.pipe(
271
Layer.provide(CursorAccountReader.layer.pipe(Layer.provide(CursorKeychain.layer))),
272
),
apps/server/src/usage/CodexUsageHistory.ts
+4
-2
@@ -12,7 +12,7 @@ import { getCodexServiceTierOptionValue } from "../codexModelOptions.ts";
12
13
export class CodexUsageHistoryReadError extends Schema.TaggedError<CodexUsageHistoryReadError>()(
14
"CodexUsageHistoryReadError",
15
- { cause: Schema.Defect() },
15
+ { requestedTurnCount: Schema.Number, cause: Schema.Defect() },
16
) {
17
override get message(): string {
18
return "Could not read historical Codex usage tiers.";
@@ -84,7 +84,9 @@ const make = Effect.gen(function* () {
84
)
85
`.pipe(
86
NodeSqliteClient.readOnly,
87
- Effect.mapError((cause) => new CodexUsageHistoryReadError({ cause })),
87
+ Effect.mapError(
88
+ (cause) => new CodexUsageHistoryReadError({ requestedTurnCount: requests.length, cause }),
89
+ ),
90
);
91
92
// Keep duplicates ambiguous even when an attempt is missing or its destination differs.
apps/server/src/usage/UsageService.test.ts
+172
-5
@@ -138,6 +138,7 @@ const layerService = (input: {
138
).pipe(
139
Layer.provideMerge(AntigravityUsage.layer),
140
Layer.provideMerge(ProviderHostLive.layer),
141
+ Layer.provideMerge(CodexUsageHistory.layer.pipe(Layer.provideMerge(Sqlite.layerMemory))),
142
Layer.provideMerge(Layer.mock(BackgroundPolicy.BackgroundPolicy)({})),
143
Layer.provideMerge(Layer.mock(ServerSecretStore.ServerSecretStore)({})),
144
Layer.provideMerge(
@@ -448,6 +449,7 @@ describe("Codex usage history", () => {
449
yield* sql`ALTER TABLE orchestration_events RENAME TO unavailable_events`;
450
const error = yield* Effect.flip(history.resolve([input]));
451
assert.instanceOf(error, CodexUsageHistory.CodexUsageHistoryReadError);
452
+ assert.strictEqual(error.requestedTurnCount, 1);
453
yield* sql`ALTER TABLE unavailable_events RENAME TO orchestration_events`;
454
assert.strictEqual((yield* history.resolve([input])).get(input), "fast");
455
}).pipe(Effect.provide(historyLayer)),
@@ -455,6 +457,158 @@ describe("Codex usage history", () => {
457
});
458
459
describe("UsageService", () => {
460
+ it.live(
461
+ "repairs initial Codex prices after unchanged-file retries, persists evidence and corrections, and honors later native tiers",
462
+ () =>
463
+ Effect.gen(function* () {
464
+ const { home, settings } = yield* setup;
465
+ const sessions = NodePath.join(home, "codex", "sessions");
466
+ const fastPath = NodePath.join(sessions, "fast.jsonl");
467
+ const ultraPath = NodePath.join(sessions, "ultra.jsonl");
468
+ const meta = (id: string) => ({
469
+ type: "session_meta",
470
+ payload: { id, model_provider: "openai" },
471
+ });
472
+ const context = (turn_id?: string) => ({
473
+ type: "turn_context",
474
+ payload: { model: "gpt-6-astra", turn_id },
475
+ });
476
+ const usage = (output_tokens: number) => ({
477
+ type: "event_msg",
478
+ timestamp: "2026-08-01T10:00:00Z",
479
+ payload: {
480
+ type: "token_count",
481
+ info: { last_token_usage: { input_tokens: 0, output_tokens } },
482
+ },
483
+ });
484
+ const tier = (service_tier?: string) => ({
485
+ type: "event_msg",
486
+ payload: { type: "thread_settings_applied", thread_settings: { service_tier } },
487
+ });
488
+ const lines = (records: readonly unknown[]) =>
489
+ records.map((record) => encodeUnknownJsonString(record)).join("\n") + "\n";
490
+ const verify = (summary: UsageSummary, output: number, cost: number) => {
491
+ assert.strictEqual(totalOutputTokens(summary), output);
492
+ assert.strictEqual(
493
+ summary.buckets.reduce((sum, bucket) => sum + bucket.costUsd, 0),
494
+ cost,
495
+ );
496
+ };
497
+ yield* Effect.promise(async () => {
498
+ await NodeFSP.mkdir(sessions, { recursive: true });
499
+ await NodeFSP.writeFile(
500
+ fastPath,
501
+ lines([meta("fast-session"), context("fast-turn"), usage(1)]) +
502
+ encodeUnknownJsonString(usage(2)),
503
+ );
504
+ await NodeFSP.writeFile(
505
+ ultraPath,
506
+ lines([meta("ultra-session"), context("ultra-turn"), usage(4)]),
507
+ );
508
+ });
509
+ yield* Effect.gen(function* () {
510
+ const first = yield* UsageService.make;
511
+ verify(yield* first.readSummary(WINDOW), 7, 7);
512
+ yield* first.awaitPersisted;
513
+ const pending = yield* UsageService.make;
514
+ verify(yield* pending.readSummary(WINDOW), 7, 7);
515
+ yield* seedCodexHistory({ id: "fast-turn", sessionId: "fast-session" });
516
+ yield* seedCodexHistory({
517
+ id: "ultra-turn",
518
+ sessionId: "ultra-session",
519
+ options: [{ id: "serviceTier", value: "ultrafast" }],
520
+ });
521
+ const sql = yield* SqlClient.SqlClient;
522
+ yield* sql`ALTER TABLE orchestration_events RENAME TO unavailable_events`;
523
+ verify(yield* pending.readSummary(WINDOW), 7, 7);
524
+ yield* pending.awaitPersisted;
525
+ const retry = yield* UsageService.make;
526
+ verify(yield* retry.readSummary(WINDOW), 7, 7);
527
+ yield* sql`ALTER TABLE unavailable_events RENAME TO orchestration_events`;
528
+ // History repair must touch both the committed record and tentative tail.
529
+ verify(yield* retry.readSummary(WINDOW), 7, 30);
530
+ yield* retry.awaitPersisted;
531
+ yield* sql`ALTER TABLE orchestration_events RENAME TO resolved_events`;
532
+ verify(yield* retry.readSummary(WINDOW), 7, 30);
533
+ const resolved = yield* UsageService.make;
534
+ verify(yield* resolved.readSummary(WINDOW), 7, 30);
535
+ yield* sql`ALTER TABLE resolved_events RENAME TO orchestration_events`;
536
+
537
+ // Completing the tail reparses it; neither an absent turn ID nor a new
538
+ // turn with no retained attempt may inherit the inferred Fast speed.
539
+ yield* Effect.promise(() =>
540
+ NodeFSP.appendFile(
541
+ fastPath,
542
+ "\n" + lines([context(), usage(3), context("unretained-turn"), usage(4)]),
543
+ ),
544
+ );
545
+ verify(yield* resolved.readSummary(WINDOW), 14, 37);
546
+ yield* seedCodexHistory({
547
+ id: "native-turn",
548
+ sessionId: "fast-session",
549
+ options: [{ id: "serviceTier", value: "ultrafast" }],
550
+ });
551
+ yield* seedCodexHistory({ id: "later-native-turn", sessionId: "fast-session" });
552
+ yield* Effect.promise(() =>
553
+ NodeFSP.appendFile(
554
+ fastPath,
555
+ lines([
556
+ context("native-turn"),
557
+ tier(),
558
+ usage(5),
559
+ context("later-native-turn"),
560
+ usage(6),
561
+ tier("priority"),
562
+ ]) + encodeUnknownJsonString(usage(7)),
563
+ ),
564
+ );
565
+ verify(yield* resolved.readSummary(WINDOW), 32, 62);
566
+ yield* resolved.awaitPersisted;
567
+ const native = yield* UsageService.make;
568
+ verify(yield* native.readSummary(WINDOW), 32, 62);
569
+ yield* seedCodexHistory({
570
+ id: "after-restart-native",
571
+ sessionId: "fast-session",
572
+ options: [{ id: "serviceTier", value: "ultrafast" }],
573
+ });
574
+ yield* Effect.promise(() =>
575
+ NodeFSP.appendFile(
576
+ fastPath,
577
+ "\n" +
578
+ lines([context("after-restart-native"), usage(8), tier("ultrafast"), usage(9)]),
579
+ ),
580
+ );
581
+ verify(yield* native.readSummary(WINDOW), 49, 132);
582
+ yield* native.awaitPersisted;
583
+ yield* Effect.promise(async () => {
584
+ await NodeFSP.rm(fastPath);
585
+ await NodeFSP.rm(ultraPath);
586
+ });
587
+ yield* sql`DELETE FROM orchestration_events`;
588
+ const deleted = yield* UsageService.make;
589
+ verify(yield* deleted.readSummary(WINDOW), 49, 132);
590
+ }).pipe(
591
+ Effect.provide(
592
+ layerService({
593
+ prefix: "usage-initial-tier",
594
+ home,
595
+ settings,
596
+ ratesDocument: {
597
+ "gpt-6-astra": {
598
+ input_cost_per_token: 0,
599
+ output_cost_per_token: 1,
600
+ input_cost_per_token_priority: 0,
601
+ output_cost_per_token_priority: 2,
602
+ input_cost_per_token_ultrafast: 0,
603
+ output_cost_per_token_ultrafast: 6,
604
+ },
605
+ },
606
+ }),
607
+ ),
608
+ );
609
+ }).pipe(Effect.scoped),
610
+ );
611
+
612
it.live(
613
"reads Pi per-model usage and auxiliary costs once across forks and repeated entries",
614
() =>
@@ -1898,7 +2052,7 @@ describe("UsageService", () => {
2052
}).pipe(Effect.scoped),
2053
);
2054
1901
- it.live.each([4, 5])(
2055
+ it.live.each([4, 5, 6])(
2056
"upgrades a v%s cache: reparses live Codex usage, keeps deleted rollouts and the old file",
2057
(version) =>
2058
Effect.gen(function* () {
@@ -1939,7 +2093,7 @@ describe("UsageService", () => {
2093
const cachePath = NodePath.join(stateDir, SCAN_CACHE_FILE_NAME);
2094
const legacyPath = NodePath.join(
2095
stateDir,
1942
- version === 4 ? "usage-scan-cache.json" : "usage-scan-cache-v5.json",
2096
+ version === 4 ? "usage-scan-cache.json" : `usage-scan-cache-v${version}.json`,
2097
);
2098
const first = yield* UsageService.make;
2099
yield* first.readSummary(WINDOW);
@@ -1957,12 +2111,25 @@ describe("UsageService", () => {
2111
version === 4 ? 0 : 1,
2112
]);
2113
if (version === 4) delete file.cs.speed;
1960
- delete file.cs.lastCumulativeUsage;
1961
- delete file.cs.malformedRecords;
2114
+ if (version < 6) {
2115
+ delete file.cs.lastCumulativeUsage;
2116
+ delete file.cs.malformedRecords;
2117
+ }
2118
}
2119
const text = encodeUnknownJsonString({ ...document, version });
2120
await NodeFSP.rm(cachePath);
2121
await NodeFSP.writeFile(legacyPath, text);
2122
+ if (version === 6) {
2123
+ for (const [name, olderVersion] of [
2124
+ ["usage-scan-cache-v5.json", 5],
2125
+ ["usage-scan-cache.json", 4],
2126
+ ] as const) {
2127
+ await NodeFSP.writeFile(
2128
+ NodePath.join(stateDir, name),
2129
+ encodeUnknownJsonString({ ...document, version: olderVersion, files: {} }),
2130
+ );
2131
+ }
2132
+ }
2133
await NodeFSP.rm(deleted);
2134
return text;
2135
});
@@ -1975,7 +2142,7 @@ describe("UsageService", () => {
2142
60 + 20 * (version === 4 ? 1 : 2),
2143
);
2144
yield* upgraded.awaitPersisted;
1978
- assert.strictEqual(SCAN_CACHE_FILE_NAME, "usage-scan-cache-v6.json");
2145
+ assert.strictEqual(SCAN_CACHE_FILE_NAME, "usage-scan-cache-v7.json");
2146
assert.strictEqual(
2147
yield* Effect.promise(() => NodeFSP.readFile(legacyPath, "utf8")),
2148
legacy,
apps/server/src/usage/UsageService.ts
+83
-3
@@ -195,6 +195,11 @@ export const make = Effect.gen(function* () {
195
const readerContext = yield* Effect.context<BuiltInUsageReadersEnv>();
196
197
const fileCache: ScanCache = new Map();
198
+ // Reads from concurrent windows can still hold the original record after it is corrected.
199
+ const resolvedRecords = new WeakMap<UsageRecord, UsageRecord>();
200
+ const correctedRecord = (record: UsageRecord) => resolvedRecords.get(record) ?? record;
201
+ const correctedBatch = (records: readonly UsageRecord[]) =>
202
+ records.some((record) => resolvedRecords.has(record)) ? records.map(correctedRecord) : records;
203
const sourceCache = new Map<string, typeof CachedSource.Type>();
204
let cacheDirty = false;
205
const isWithinDirectory = (filePath: string, dir: string) => {
@@ -498,6 +503,33 @@ export const make = Effect.gen(function* () {
503
failed: true,
504
};
505
506
+ if (parsed.resumed && cached !== undefined && cached.tailRecords.length > 0) {
507
+ // Completing a tentative line reparses it. Reuse its saved correction only when the
508
+ // same usage is emitted again, without putting inferred tiers in the parser state.
509
+ const reparsed = [...parsed.records, ...parsed.tailRecords];
510
+ const identity = (record: UsageRecord) =>
511
+ encodeUsageRecordKey([
512
+ record.provider,
513
+ record.sessionId,
514
+ record.timestampMs,
515
+ record.model,
516
+ record.rateModel,
517
+ record.totals,
518
+ record.reportedCostUsd,
519
+ record.dedupeKey,
520
+ ]);
521
+ for (const [index, previous] of cached.tailRecords.entries()) {
522
+ const record = reparsed[index];
523
+ const corrected = correctedRecord(previous);
524
+ if (
525
+ record?.unresolvedServiceTierTurnId !== undefined &&
526
+ corrected.unresolvedServiceTierTurnId === undefined &&
527
+ identity(record) === identity(corrected)
528
+ ) {
529
+ resolvedRecords.set(record, corrected);
530
+ }
531
+ }
532
+ }
533
const base = parsed.resumed && cached !== undefined ? cached.records : [];
534
const seen = new Set<string>();
535
const records = dedupeWithinFile([...base, ...parsed.records], seen);
@@ -568,9 +600,13 @@ export const make = Effect.gen(function* () {
600
if (
601
current === update.replaces ||
602
current === undefined ||
571
- !isLaterRead(current, update.entry)
603
+ isLaterRead(update.entry, current)
604
) {
573
- fileCache.set(path, update.entry);
605
+ fileCache.set(path, {
606
+ ...update.entry,
607
+ records: correctedBatch(update.entry.records),
608
+ tailRecords: correctedBatch(update.entry.tailRecords),
609
+ });
610
cacheDirty = true;
611
}
612
return { path, records, malformedRecords };
@@ -735,6 +771,49 @@ export const make = Effect.gen(function* () {
771
}
772
return retainedFiles;
773
});
774
+ const windowEndMs =
775
+ hourlyWindow?.untilTimeMs ??
776
+ Date.parse(`${input.untilDay}T00:00:00Z`) + 86400000 + MTIME_SLACK_MS;
777
+ let resolvedAny = false;
778
+ for (const { reader } of transcriptReaders) {
779
+ if (reader.resolveServiceTiers === undefined) continue;
780
+ const pending = new Set<UsageRecord>();
781
+ for (const [index, files] of filesByDir.entries()) {
782
+ if (scannedDirs[index]?.provider !== reader.provider) continue;
783
+ for (const file of files) {
784
+ for (const raw of file.records) {
785
+ const record = correctedRecord(raw);
786
+ if (
787
+ record.provider === reader.provider &&
788
+ record.unresolvedServiceTierTurnId !== undefined &&
789
+ record.timestampMs >= windowStartMs &&
790
+ record.timestampMs < windowEndMs
791
+ ) {
792
+ pending.add(record);
793
+ }
794
+ }
795
+ }
796
+ }
797
+ if (pending.size === 0) continue;
798
+ const resolved = yield* reader
799
+ .resolveServiceTiers([...pending])
800
+ .pipe(Effect.provideContext(readerContext));
801
+ for (const [record, speed] of resolved) {
802
+ const { unresolvedServiceTierTurnId: _turnId, ...rest } = record;
803
+ resolvedRecords.set(record, { ...rest, speed });
804
+ resolvedAny = true;
805
+ }
806
+ }
807
+ if (resolvedAny) {
808
+ for (const [filePath, entry] of fileCache) {
809
+ const records = correctedBatch(entry.records);
810
+ const tailRecords = correctedBatch(entry.tailRecords);
811
+ if (records === entry.records && tailRecords === entry.tailRecords) continue;
812
+ // Update the current entry by identity; a slow resolver cannot restore an older file.
813
+ fileCache.set(filePath, { ...entry, records, tailRecords });
814
+ cacheDirty = true;
815
+ }
816
+ }
817
const crossFileSessions = sharedSessions(filesByDir.flat());
818
819
for (const [
@@ -756,7 +835,8 @@ export const make = Effect.gen(function* () {
835
}
836
scannedFiles += 1;
837
const eventOccurrences = new Map<string, number>();
759
- for (const record of file.records) {
838
+ for (const rawRecord of file.records) {
839
+ const record = correctedRecord(rawRecord);
840
let usageRecord = record;
841
if (
842
sharedSessionProviders.has(record.provider) &&
apps/server/src/usage/usageScanCache.test.ts
+101
-58
@@ -12,7 +12,7 @@ import {
12
import type { UsageRecord } from "@t3tools/provider-core/server/usage";
13
14
import { TEST_FORMAT_MAP } from "./usageTestFormats.ts";
15
-import { initialCodexScanState } from "../provider/Drivers/codexUsage.ts";
15
+import { initialCodexScanState, parseCodexLine } from "../provider/Drivers/codexUsage.ts";
16
17
function record(overrides: Partial<UsageRecord> = {}): UsageRecord {
18
return {
@@ -98,25 +98,47 @@ describe("scan cache round trip", () => {
98
tailRecords: [record({ provider: "grok", model: "<synthetic>", dedupeKey: null })],
99
position: position({ resumeOffset: 30, guardLength: 30, guardHash: 123 }),
100
});
101
+ const state = initialCodexScanState();
102
+ for (const line of [
103
+ { type: "session_meta", payload: { id: "session-c", model_provider: "openai" } },
104
+ { type: "turn_context", payload: { model: "gpt-6-astra", turn_id: "native-turn" } },
105
+ {
106
+ type: "event_msg",
107
+ timestamp: "2026-08-01T10:00:00Z",
108
+ payload: {
109
+ type: "token_count",
110
+ info: { last_token_usage: { input_tokens: 1, output_tokens: 2 } },
111
+ },
112
+ },
113
+ ])
114
+ parseCodexLine(JSON.stringify(line), state);
115
+ const pending = {
116
+ ...record({
117
+ provider: "codex",
118
+ model: "gpt-6-astra",
119
+ sessionId: "session-c",
120
+ dedupeKey: null,
121
+ }),
122
+ unresolvedServiceTierTurnId: "native-turn",
123
+ };
124
+ const pendingTail = { ...pending, unresolvedServiceTierTurnId: "native-tail" };
125
original.set("/codex.jsonl", {
126
size: 80,
127
malformedRecords: 3,
128
mtimeMs: 400,
129
provider: "codex",
130
records: [
107
- record({ provider: "codex", model: "gpt-6-astra", dedupeKey: null, speed: "ultrafast" }),
108
- ],
109
- tailRecords: [],
110
- position: position({
111
- state: {
112
- ...initialCodexScanState(),
131
+ record({
132
+ provider: "codex",
133
model: "gpt-6-astra",
134
+ rateModel: "gpt-6",
135
+ dedupeKey: null,
136
speed: "ultrafast",
115
- sessionId: "session-c",
116
- lastUsageSignature: '{"input_tokens":1}',
117
- sawSessionMeta: true,
118
- },
119
- }),
137
+ }),
138
+ pending,
139
+ ],
140
+ tailRecords: [pendingTail],
141
+ position: position({ state }),
142
});
143
144
original.set("/a.jsonl", {
@@ -142,53 +164,74 @@ describe("scan cache round trip", () => {
164
expect(restored).toEqual(original);
165
});
166
145
- it("retains v5 history and stateless positions but invalidates obsolete Codex state", () => {
146
- const original = cacheWith([["/gone.jsonl", 100, [record({ speed: "fast" })]]]);
147
- original.set("/gone-codex.jsonl", {
148
- ...original.get("/gone.jsonl")!,
149
- provider: "codex",
150
- records: [record({ provider: "codex", speed: "fast", dedupeKey: null })],
151
- position: position({
152
- state: {
153
- model: "gpt-6-astra",
154
- speed: "fast",
155
- sessionId: "session-a",
156
- lastUsageSignature: null,
157
- sawSessionMeta: true,
158
- suppressingForkCopies: false,
159
- forkCopyAnchorMs: 0,
167
+ it.each([5, 6])(
168
+ "retains v%s history and compatible positions but invalidates obsolete state",
169
+ (version) => {
170
+ const original = cacheWith([["/gone.jsonl", 100, [record({ speed: "fast" })]]]);
171
+ original.set("/gone-codex.jsonl", {
172
+ ...original.get("/gone.jsonl")!,
173
+ provider: "codex",
174
+ records: [record({ provider: "codex", speed: "fast", dedupeKey: null })],
175
+ position: position({
176
+ state: {
177
+ ...(version === 6 ? initialCodexScanState() : {}),
178
+ model: "gpt-6-astra",
179
+ speed: "fast",
180
+ sessionId: "session-a",
181
+ lastUsageSignature: null,
182
+ sawSessionMeta: true,
183
+ suppressingForkCopies: false,
184
+ forkCopyAnchorMs: 0,
185
+ },
186
+ }),
187
+ });
188
+ original.set("/gone-pi.jsonl", {
189
+ ...original.get("/gone.jsonl")!,
190
+ size: 256,
191
+ provider: "pi",
192
+ records: [record({ provider: "pi", model: "anthropic/claude-fable-5" })],
193
+ malformedRecords: 3,
194
+ position: position({ state: { sessionId: "session-a" } }),
195
+ });
196
+ const encoded = encodeScanCache(original);
197
+ const entry = encoded.files["/gone.jsonl"]!;
198
+ const legacy = {
199
+ ...encoded,
200
+ version,
201
+ files: {
202
+ ...encoded.files,
203
+ "/gone.jsonl": {
204
+ s: entry.s,
205
+ m: entry.m,
206
+ p: entry.p,
207
+ r: entry.r,
208
+ t: entry.t,
209
+ o: entry.o,
210
+ gl: entry.gl,
211
+ gh: entry.gh,
212
+ cs: entry.cs,
213
+ },
214
},
161
- }),
162
- });
163
- const encoded = encodeScanCache(original);
164
- const entry = encoded.files["/gone.jsonl"]!;
165
- const legacy = {
166
- ...encoded,
167
- version: 5,
168
- files: {
169
- ...encoded.files,
170
- "/gone.jsonl": {
171
- s: entry.s,
172
- m: entry.m,
173
- p: entry.p,
174
- r: entry.r,
175
- t: entry.t,
176
- o: entry.o,
177
- gl: entry.gl,
178
- gh: entry.gh,
179
- cs: entry.cs,
180
- },
181
- },
182
- };
183
-
184
- const restored = decodeScanCache(JSON.parse(JSON.stringify(legacy)), TEST_FORMAT_MAP);
185
- expect(restored.get("/gone.jsonl")).toEqual(original.get("/gone.jsonl"));
186
- expect(restored.get("/gone-codex.jsonl")).toEqual({
187
- ...original.get("/gone-codex.jsonl"),
188
- size: -1,
189
- position: { resumeOffset: 0, guardLength: 0, guardHash: 0, state: null },
190
- });
191
- });
215
+ };
216
+
217
+ const restored = decodeScanCache(JSON.parse(JSON.stringify(legacy)), TEST_FORMAT_MAP);
218
+ expect(restored.get("/gone.jsonl")).toEqual(original.get("/gone.jsonl"));
219
+ expect(restored.get("/gone-codex.jsonl")).toEqual({
220
+ ...original.get("/gone-codex.jsonl"),
221
+ size: -1,
222
+ position: { resumeOffset: 0, guardLength: 0, guardHash: 0, state: null },
223
+ });
224
+ expect(restored.get("/gone-pi.jsonl")).toEqual(
225
+ version === 6
226
+ ? original.get("/gone-pi.jsonl")
227
+ : {
228
+ ...original.get("/gone-pi.jsonl"),
229
+ size: -1,
230
+ position: { resumeOffset: 0, guardLength: 0, guardHash: 0, state: null },
231
+ },
232
+ );
233
+ },
234
+ );
235
236
it("drops an entry whose persisted parse state is corrupt", () => {
237
const encoded = encodeScanCache(cacheWith([["/a.jsonl", 100, [record()]]]));
apps/server/src/usage/usageScanCache.ts
+17
-5
@@ -9,7 +9,7 @@ import * as Schema from "effect/Schema";
9
import { CLAUDE_SYNTHETIC_MODEL } from "../provider/Drivers/claudeUsage.ts";
10
import { GUARD_LENGTH, type TranscriptParsePosition } from "./usageTranscriptReader.ts";
11
12
-const USAGE_SCAN_CACHE_VERSION = 6 as const;
12
+const USAGE_SCAN_CACHE_VERSION = 7 as const;
13
const SPEED_COMPATIBLE_SINCE_VERSION = 4;
14
15
/**
@@ -17,8 +17,9 @@ const SPEED_COMPATIBLE_SINCE_VERSION = 4;
17
* replace it, dropping saved usage for deleted transcripts. Separate files keep
18
* both.
19
*/
20
-export const SCAN_CACHE_FILE_NAME = "usage-scan-cache-v6.json";
20
+export const SCAN_CACHE_FILE_NAME = "usage-scan-cache-v7.json";
21
export const LEGACY_SCAN_CACHE_FILE_NAMES = [
22
+ "usage-scan-cache-v6.json",
23
"usage-scan-cache-v5.json",
24
"usage-scan-cache.json",
25
] as const;
@@ -56,6 +57,7 @@ type SerializedRecord = readonly [
57
reportedCostUsd: number | null,
58
speed: number,
59
rateModelIndex?: number | null,
60
+ unresolvedServiceTierTurnId?: string,
61
];
62
63
interface SerializedFile {
@@ -114,6 +116,9 @@ function serializeFile(entry: CachedFile, tables: InternTables): SerializedFile
116
record.rateModel === undefined
117
? null
118
: intern(tables.models, tables.modelIndex, record.rateModel),
119
+ ...(record.unresolvedServiceTierTurnId === undefined
120
+ ? ([] as const)
121
+ : ([record.unresolvedServiceTierTurnId] as const)),
122
];
123
return {
124
s: entry.size,
@@ -225,6 +230,7 @@ export function decodeScanCache(
230
reportedCostUsd,
231
speedIndex,
232
rateModelIndex,
233
+ unresolvedServiceTierTurnId,
234
] = row as SerializedRecord;
235
const speed = typeof speedIndex === "number" ? SPEEDS[speedIndex] : undefined;
236
@@ -234,6 +240,8 @@ export function decodeScanCache(
240
typeof timestampMs !== "number" ||
241
!Number.isFinite(timestampMs) ||
242
model === undefined ||
243
+ (unresolvedServiceTierTurnId !== undefined &&
244
+ typeof unresolvedServiceTierTurnId !== "string") ||
245
(rateModelIndex != null && rateModel === undefined) ||
246
!Number.isFinite(uncached) ||
247
!Number.isFinite(cached) ||
@@ -264,6 +272,9 @@ export function decodeScanCache(
272
},
273
reportedCostUsd: typeof reportedCostUsd === "number" ? reportedCostUsd : null,
274
speed,
275
+ ...(version >= 7 && unresolvedServiceTierTurnId !== undefined
276
+ ? { unresolvedServiceTierTurnId }
277
+ : {}),
278
dedupeKey: typeof dedupeKey === "string" ? dedupeKey : null,
279
});
280
}
@@ -298,9 +309,10 @@ export function decodeScanCache(
309
) {
310
continue;
311
}
301
- // Older stateful reducers have different semantics. Keep their history for deleted rollouts,
302
- // but force live files to re-parse: no file has size -1 and a zero position cannot resume.
303
- const legacy = format.state !== undefined && version < USAGE_SCAN_CACHE_VERSION;
312
+ // Keep history for deleted rollouts, but re-parse incompatible reducer state.
313
+ // Only Codex requires new provenance state in v7.
314
+ const legacy =
315
+ format.state !== undefined && (version < 6 || (entry.p === "codex" && version < 7));
316
// A corrupt state disqualifies the entry: resuming with it would attach
317
// appended usage to the wrong model or replay fork-copied history.
318
if (!legacy && !isValidState.get(entry.p)?.(entry.cs)) continue;
apps/server/src/usage/usageTranscriptStreaming.test.ts
+9
-3
@@ -50,8 +50,8 @@ const claude = (id = "m1", output = 99) => ({
50
},
51
});
52
const codex = [
53
- { type: "session_meta", timestamp, payload: { id: "s1" } },
54
- { type: "turn_context", timestamp, payload: { model: "gpt-5.6-sol" } },
53
+ { type: "session_meta", timestamp, payload: { id: "s1", model_provider: "openai" } },
54
+ { type: "turn_context", timestamp, payload: { model: "gpt-5.6-sol", turn_id: "initial-turn" } },
55
{
56
type: "event_msg",
57
timestamp,
@@ -252,9 +252,14 @@ describe("large usage records", () => {
252
it("preserves Codex model switches and duplicate suppression across streaming resumes", async () => {
253
const path = NodePath.join(dir, "history.jsonl");
254
const first = await scan(
255
- codex.map((record) => ({ padding: content, ...record })),
255
+ codex.map((record) => ({ padding: "x".repeat(9 * 1024 * 1024), ...record })),
256
"codex",
257
);
258
+ expect(first.records[0]).toMatchObject({
259
+ sessionId: "s1",
260
+ model: "gpt-5.6-sol",
261
+ unresolvedServiceTierTurnId: "initial-turn",
262
+ });
263
await NodeFSP.appendFile(
264
path,
265
[
@@ -281,6 +286,7 @@ describe("large usage records", () => {
286
sessionId: "s1",
287
totals: { outputTokens: 101 },
288
});
289
+ expect(result?.records[0]).not.toHaveProperty("unresolvedServiceTierTurnId");
290
const full = await readTranscriptRecords(path, "codex");
291
expect([...first.records, ...result!.records]).toEqual(full?.records);
292
});
packages/provider-core/src/server/usage.ts
+4
@@ -20,6 +20,7 @@ export interface UsageRecord {
20
readonly totals: UsageTokenTotals;
21
readonly reportedCostUsd: number | null;
22
readonly speed: UsageSpeed;
23
+ readonly unresolvedServiceTierTurnId?: string;
24
readonly dedupeKey: string | null;
25
}
26
@@ -118,6 +119,9 @@ export type ProviderUsageReader<Config, R> =
119
readonly kind: "transcripts";
120
readonly provider: UsageProviderKind;
121
readonly format: TranscriptUsageFormat<unknown>;
122
+ readonly resolveServiceTiers?: (
123
+ records: readonly UsageRecord[],
124
+ ) => Effect.Effect<ReadonlyMap<UsageRecord, UsageSpeed>, never, R>;
125
readonly directories: (
126
instance: ProviderUsageInstance<Config>,
127
) => Effect.Effect<