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

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<