Skip to content

OpenAI's Codex Security CLI and TypeScript SDK for finding, validating, and fixing security vulnerabilities. npm: https://www.npmjs.com/package/@openai/codex-security

fix(cost): include native compaction usage (#1590)

Michael D'Angelo6e720f06a298
diff --git a/sdk/typescript/src/cost.ts b/sdk/typescript/src/cost.ts
index 2e581da08..f6e9bda36 100644
--- a/sdk/typescript/src/cost.ts
+++ b/sdk/typescript/src/cost.ts
@@ -59,6 +59,8 @@ interface SessionUsage {
inheritedUsage: ScanTokenUsage | null;
replaying: boolean;
usage: ScanTokenUsage | null;
+ responseUsage: ScanTokenUsage | null;
+ responseIds: Set<string>;
calls: Map<string, ScanActivity>;
activities: ScanActivity[];
progress: ScanProgress[];
@@ -107,6 +109,8 @@ function createSessionUsage(): SessionUsage {
inheritedUsage: null,
replaying: false,
usage: null,
+ responseUsage: null,
+ responseIds: new Set(),
calls: new Map(),
activities: [],
progress: [],
@@ -521,6 +525,34 @@ function readSessionEvent(
return;
}
session.events?.push(event);
+ if (event["type"] === "token_usage_record") {
+ const responseId = payload["response_id"];
+ if (
+ payload["thread_id"] !== session.threadId ||
+ typeof responseId !== "string" ||
+ session.responseIds.has(responseId)
+ ) {
+ return;
+ }
+ const usage = tokenUsage(payload["usage"]);
+ if (usage === null) return;
+ session.responseIds.add(responseId);
+ session.responseUsage = addTokenUsage(session.responseUsage, usage);
+ // Native thread totals include compaction and any earlier turns. They are
+ // scoped to thread_id, unlike inherited legacy token_count snapshots.
+ const total = tokenUsage(payload["thread_token_usage"]);
+ const recorded =
+ total !== null && total.total_tokens >= session.responseUsage.total_tokens
+ ? total
+ : session.responseUsage;
+ if (
+ session.usage === null ||
+ recorded.total_tokens >= session.usage.total_tokens
+ ) {
+ session.usage = recorded;
+ }
+ return;
+ }
if (event["type"] === "response_item") {
session.progress.push(...sessionProgressUpdates(payload));
if (repository === undefined) return;
@@ -653,7 +685,17 @@ function readSessionEvent(
session.inheritedUsage === null
? usage
: subtractTokenUsage(usage, session.inheritedUsage);
- if (ownUsage !== null) session.usage = ownUsage;
+ // Older runtimes only emit token_count. In newer rollouts these snapshots can
+ // lag compaction receipts, so do not replace a more complete native total.
+ if (
+ ownUsage !== null &&
+ (session.usage === null ||
+ ownUsage.total_tokens > session.usage.total_tokens ||
+ (session.responseUsage === null &&
+ ownUsage.total_tokens === session.usage.total_tokens))
+ ) {
+ session.usage = ownUsage;
+ }
}
function readSessionReasoning(
diff --git a/sdk/typescript/tests-ts/cost.test.ts b/sdk/typescript/tests-ts/cost.test.ts
index 3d654ced2..947cc610c 100644
--- a/sdk/typescript/tests-ts/cost.test.ts
+++ b/sdk/typescript/tests-ts/cost.test.ts
@@ -111,6 +111,30 @@ function progressMessage(
};
}
+function nativeUsageRecord(
+ threadId: string,
+ responseId: string,
+ usage: Record<string, number>,
+ total: Record<string, number> = usage,
+): Record<string, unknown> {
+ return {
+ type: "token_usage_record",
+ payload: {
+ thread_id: threadId,
+ response_id: responseId,
+ usage: tokenUsage(usage),
+ thread_token_usage: tokenUsage(total),
+ },
+ };
+}
+
+function legacyUsageRecord(usage: Record<string, number>) {
+ return {
+ type: "event_msg",
+ payload: { type: "token_count", info: { total_token_usage: usage } },
+ };
+}
+
test.each([
[
"prefers the spawned parent over legacy parent fields",
@@ -490,6 +514,205 @@ describe("scan cost", () => {
});
describe("live scan cost tracking", () => {
+ test("keeps receipt cache-write detail when an equal legacy counter omits it", async () => {
+ const home = await codexHome();
+ const usage = {
+ ...ownedSdkUsage,
+ cached_input_tokens: 20,
+ cache_write_input_tokens: 12,
+ };
+ const path = await writeSession(home, scanThreadId, ownedSdkUsage);
+ await appendFile(
+ path,
+ jsonLines([
+ nativeUsageRecord(scanThreadId, "response-1", usage),
+ legacyUsageRecord(ownedSdkUsage),
+ ]) + "\n",
+ );
+ const tracker = costTracker(home);
+ tracker.start(scanThreadId);
+ expect((await tracker.stop(ownedSdkUsage)).cost).toMatchObject({
+ inputTokens: 100,
+ cachedInputTokens: 20,
+ cacheWriteInputTokens: 12,
+ outputTokens: 10,
+ });
+ });
+
+ test("counts compaction receipts before stale counters and deduplicates responses", async () => {
+ const home = await codexHome();
+ const original = { ...ownedSdkUsage };
+ const compact = { ...ownedSdkUsage, input_tokens: 40, output_tokens: 3 };
+ const compactTotal = {
+ ...ownedSdkUsage,
+ input_tokens: 140,
+ output_tokens: 13,
+ };
+ const path = await writeSession(home, scanThreadId, original);
+ await appendFile(
+ path,
+ jsonLines([nativeUsageRecord(scanThreadId, "response-1", original)]) +
+ "\n",
+ );
+ const budget = new AbortController();
+ const maxCostUsd = 0.000355;
+ const tracker = new ScanCostTracker({
+ codexHome: home,
+ model: "gpt-6.1-sol",
+ maxCostUsd,
+ onCost: ({ estimatedUsd }) => {
+ if (estimatedUsd > maxCostUsd) budget.abort();
+ },
+ });
+ tracker.start(scanThreadId);
+ expect((await tracker.refresh()).cost?.estimatedUsd).toBe(0.0003);
+ expect(budget.signal.aborted).toBe(false);
+
+ const compaction = nativeUsageRecord(
+ scanThreadId,
+ "response-compaction",
+ compact,
+ compactTotal,
+ );
+ await appendFile(
+ path,
+ jsonLines([
+ compaction,
+ { type: "compacted", payload: { message: "Compacted context." } },
+ legacyUsageRecord(original),
+ ]) + "\n",
+ );
+ expect((await tracker.refresh()).cost?.estimatedUsd).toBe(0.00041);
+ expect(budget.signal.aborted).toBe(true);
+
+ const final = { ...ownedSdkUsage, input_tokens: 170, output_tokens: 15 };
+ const stale = { ...ownedSdkUsage, input_tokens: 130, output_tokens: 12 };
+ await appendFile(
+ path,
+ jsonLines([
+ compaction,
+ nativeUsageRecord(
+ scanThreadId,
+ "response-2",
+ { ...ownedSdkUsage, input_tokens: 30, output_tokens: 2 },
+ final,
+ ),
+ legacyUsageRecord(stale),
+ ]) + "\n",
+ );
+ expect((await tracker.stop(stale)).usage).toMatchObject({
+ input_tokens: 170,
+ output_tokens: 15,
+ total_tokens: 185,
+ });
+ });
+
+ test("keeps native receipts scoped to the owned fork across resumed turns", async () => {
+ const home = await codexHome();
+ const inherited = {
+ ...ownedSdkUsage,
+ input_tokens: 1_000,
+ output_tokens: 100,
+ };
+ const parent = await writeSession(home, scanThreadId, inherited);
+ await appendFile(
+ parent,
+ jsonLines([
+ nativeUsageRecord(scanThreadId, "parent-response", inherited),
+ ]) + "\n",
+ );
+ const child = await writeSession(home, childUuid7Thread, ownedSdkUsage, {
+ parent: scanThreadId,
+ });
+ const rollout = ownershipRollout([lowerUuid7Turn]);
+ rollout.splice(
+ 3,
+ 0,
+ nativeUsageRecord(scanThreadId, "parent-response", inherited),
+ );
+ rollout.push(
+ nativeUsageRecord(childUuid7Thread, "child-response", ownedSdkUsage),
+ nativeUsageRecord(scanThreadId, "foreign-response", inherited),
+ );
+ await writeFile(child, jsonLines(rollout) + "\n");
+ const tracker = costTracker(home, { onSessionEvent: () => {} });
+ tracker.start(scanThreadId);
+ expect((await tracker.refresh()).usage).toMatchObject({
+ input_tokens: 1_100,
+ output_tokens: 110,
+ });
+ const compact = { ...ownedSdkUsage, input_tokens: 40, output_tokens: 3 };
+ const compactTotal = {
+ ...ownedSdkUsage,
+ input_tokens: 140,
+ output_tokens: 13,
+ };
+ const compaction = nativeUsageRecord(
+ childUuid7Thread,
+ "child-compact",
+ compact,
+ compactTotal,
+ );
+ await appendFile(child, jsonLines([compaction, compaction]) + "\n");
+ expect((await tracker.stop(inherited)).usage).toMatchObject({
+ input_tokens: 1_140,
+ output_tokens: 113,
+ });
+
+ await appendFile(
+ child,
+ jsonLines([
+ {
+ type: "event_msg",
+ payload: {
+ type: "task_started",
+ turn_id: "019f9e4d-b3bb-7000-8000-000000000004",
+ },
+ },
+ nativeUsageRecord(
+ childUuid7Thread,
+ "resumed-response",
+ { ...ownedSdkUsage, input_tokens: 60, output_tokens: 6 },
+ { ...ownedSdkUsage, input_tokens: 200, output_tokens: 19 },
+ ),
+ ]) + "\n",
+ );
+ const resumed = costTracker(home);
+ resumed.start(scanThreadId);
+ expect((await resumed.stop(inherited)).usage).toMatchObject({
+ input_tokens: 1_200,
+ output_tokens: 119,
+ });
+ });
+
+ test.each([1_000, 1_100])(
+ "reconciles a native resumed total with a final SDK receipt of %p input tokens",
+ async (finalInput) => {
+ const home = await codexHome();
+ const path = await writeSession(home, scanThreadId, {
+ ...ownedSdkUsage,
+ input_tokens: 1_000,
+ });
+ await appendFile(
+ path,
+ jsonLines([
+ nativeUsageRecord(
+ scanThreadId,
+ "resumed-response",
+ { ...ownedSdkUsage, input_tokens: 20, output_tokens: 2 },
+ { ...ownedSdkUsage, input_tokens: 1_020, output_tokens: 12 },
+ ),
+ ]) + "\n",
+ );
+ const tracker = costTracker(home);
+ tracker.start(scanThreadId);
+ expect(
+ (await tracker.stop({ ...ownedSdkUsage, input_tokens: finalInput }))
+ .cost?.inputTokens,
+ ).toBe(Math.max(1_020, finalInput));
+ },
+ );
+
test.each([
[undefined, undefined],
[0, 0],