Skip to content

Commit 6b94121

Browse files
committed
fix(usage): keep resolved Codex tiers when a cached file re-parses whole
1 parent 030ccd4 commit 6b94121

2 files changed

Lines changed: 116 additions & 11 deletions

File tree

‎apps/server/src/usage/UsageService.test.ts‎

Lines changed: 89 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -793,6 +793,95 @@ describe("UsageService", () => {
793793
}).pipe(Effect.scoped),
794794
);
795795

796+
it.live(
797+
"keeps resolved Codex tiers when a grown pre-v12 cache entry re-parses without history",
798+
() =>
799+
Effect.gen(function* () {
800+
const { home, settings } = yield* setup;
801+
const sessions = NodePath.join(home, "codex", "sessions");
802+
const rolloutPath = NodePath.join(sessions, "tier.jsonl");
803+
const context = (turn_id: string) => ({
804+
type: "turn_context",
805+
payload: { model: "gpt-6-astra", turn_id },
806+
});
807+
const usage = (output_tokens: number) => ({
808+
type: "event_msg",
809+
timestamp: "2026-08-01T10:00:00Z",
810+
payload: {
811+
type: "token_count",
812+
info: { last_token_usage: { input_tokens: 0, output_tokens } },
813+
},
814+
});
815+
const lines = (records: readonly unknown[]) =>
816+
records.map((record) => encodeUnknownJsonString(record)).join("\n") + "\n";
817+
const verify = (summary: UsageSummary, output: number, cost: number) => {
818+
assert.strictEqual(totalOutputTokens(summary), output);
819+
assert.strictEqual(
820+
summary.buckets.reduce((sum, bucket) => sum + bucket.costUsd, 0),
821+
cost,
822+
);
823+
};
824+
yield* Effect.promise(async () => {
825+
await NodeFSP.mkdir(sessions, { recursive: true });
826+
await NodeFSP.writeFile(
827+
rolloutPath,
828+
lines([
829+
{ type: "session_meta", payload: { id: "tier-session", model_provider: "openai" } },
830+
context("ultra-turn"),
831+
usage(1),
832+
]),
833+
);
834+
});
835+
yield* Effect.gen(function* () {
836+
const { stateDir } = yield* ServerConfig.ServerConfig;
837+
yield* seedCodexHistory({
838+
id: "ultra-turn",
839+
sessionId: "tier-session",
840+
options: [{ id: "serviceTier", value: "ultrafast" }],
841+
});
842+
const first = yield* UsageService.make;
843+
verify(yield* first.readSummary(WINDOW), 1, 6);
844+
yield* first.awaitPersisted;
845+
846+
// Downgrade the saved cache to v11, whose clean Codex entries cannot resume.
847+
yield* Effect.promise(async () => {
848+
const cachePath = NodePath.join(stateDir, SCAN_CACHE_FILE_NAME);
849+
const document = JSON.parse(await NodeFSP.readFile(cachePath, "utf8"));
850+
await NodeFSP.rm(cachePath);
851+
await NodeFSP.writeFile(
852+
NodePath.join(stateDir, "usage-scan-cache-v11.json"),
853+
encodeUnknownJsonString({ ...document, version: 11 }),
854+
);
855+
await NodeFSP.appendFile(rolloutPath, lines([context("later-turn"), usage(2)]));
856+
});
857+
const sql = yield* SqlClient.SqlClient;
858+
yield* sql`ALTER TABLE orchestration_events RENAME TO unavailable_events`;
859+
const upgraded = yield* UsageService.make;
860+
verify(yield* upgraded.readSummary(WINDOW), 3, 8);
861+
yield* upgraded.awaitPersisted;
862+
const restarted = yield* UsageService.make;
863+
verify(yield* restarted.readSummary(WINDOW), 3, 8);
864+
yield* sql`ALTER TABLE unavailable_events RENAME TO orchestration_events`;
865+
}).pipe(
866+
Effect.provide(
867+
layerService({
868+
prefix: "usage-reparse-tier",
869+
home,
870+
settings,
871+
ratesDocument: {
872+
"gpt-6-astra": {
873+
input_cost_per_token: 0,
874+
output_cost_per_token: 1,
875+
input_cost_per_token_ultrafast: 0,
876+
output_cost_per_token_ultrafast: 6,
877+
},
878+
},
879+
}),
880+
),
881+
);
882+
}).pipe(Effect.scoped),
883+
);
884+
796885
it.live(
797886
"reads Pi per-model usage and auxiliary costs once across forks and repeated entries",
798887
() =>

‎apps/server/src/usage/UsageService.ts‎

Lines changed: 27 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -488,21 +488,37 @@ export const make = Effect.gen(function* () {
488488
failed: true,
489489
};
490490

491+
const identity = (record: UsageRecord) =>
492+
encodeUsageRecordKey([
493+
record.provider,
494+
record.sessionId,
495+
record.timestampMs,
496+
record.model,
497+
record.rateModel,
498+
record.totals,
499+
record.reportedCostUsd,
500+
record.dedupeKey,
501+
]);
502+
if (!parsed.resumed && cached !== undefined && cached.provider === provider) {
503+
// A whole-file re-parse re-emits saved requests unresolved. Keep their saved tier
504+
// corrections, since the history that resolved them may no longer be available.
505+
const saved = new Map<string, UsageRecord>();
506+
for (const previous of [...cached.records, ...cached.tailRecords]) {
507+
const corrected = correctedRecord(previous);
508+
if (corrected.unresolvedServiceTierTurnId === undefined) {
509+
saved.set(identity(corrected), corrected);
510+
}
511+
}
512+
for (const record of [...parsed.records, ...parsed.tailRecords]) {
513+
if (record.unresolvedServiceTierTurnId === undefined) continue;
514+
const corrected = saved.get(identity(record));
515+
if (corrected !== undefined) resolvedRecords.set(record, corrected);
516+
}
517+
}
491518
if (parsed.resumed && cached !== undefined && cached.tailRecords.length > 0) {
492519
// Completing a tentative line reparses it. Reuse its saved correction only when the
493520
// same usage is emitted again, without putting inferred tiers in the parser state.
494521
const reparsed = [...parsed.records, ...parsed.tailRecords];
495-
const identity = (record: UsageRecord) =>
496-
encodeUsageRecordKey([
497-
record.provider,
498-
record.sessionId,
499-
record.timestampMs,
500-
record.model,
501-
record.rateModel,
502-
record.totals,
503-
record.reportedCostUsd,
504-
record.dedupeKey,
505-
]);
506522
for (const [index, previous] of cached.tailRecords.entries()) {
507523
const record = reparsed[index];
508524
const corrected = correctedRecord(previous);

0 commit comments

Comments
 (0)