@jeffreycao/copilot-api 1.12.9 → 1.13.0

package/dist/{server-34rnRg4k.js → server-7U9OZLf0.js}

@@ -1,5 +1,5 @@
-import { C as setModelMappings, S as resolveMappedModel, T as PATHS, _ as isResponsesApiWebSocketEnabled, a as getExtraPromptForModel, c as getModelResponsesApiCompactThreshold$1, d as getReasoningEffortForModel, f as getSmallModel, g as isResponsesApiWebSearchEnabled, h as isResponsesApiContextManagementEnabled, i as getConfig, l as getProviderConfig, m as isMessagesApiEnabled, n as getAnthropicApiKey, o as getMessageApiWebSearchModel, r as getClaudeTokenMultiplier, s as getModelMappings, u as getRawProviderConfig } from "./config-B71_S_hQ.js";
-import { C as prepareMessageProxyHeaders, E as compactMessageSections, F as createPooledWebSocketStream, I as createWebSocketUrl, L as state, M as generateTraceId, N as requestContext, O as compactSystemPromptStarts, P as resolveTraceId$1, R as HTTPError, S as prepareInteractionHeaders, T as compactAutoContinuePromptStarts, _ as getCopilotUsage, b as copilotWebSocketHeaders, d as generateRequestIdFromPayload, f as getRootSessionId, g as sleep, h as parseUserIdMetadata, j as forwardCodexResponses, m as isNullish, p as getUUID, r as setupCodexToken, s as cacheModels, v as copilotBaseUrl, x as prepareForCompact, y as copilotHeaders, z as forwardError } from "./token-fpw8tAQS.js";
+import { C as setModelMappings, S as resolveMappedModel, T as PATHS, _ as isResponsesApiWebSocketEnabled, a as getExtraPromptForModel, c as getModelResponsesApiCompactThreshold$1, d as getReasoningEffortForModel, f as getSmallModel, g as isResponsesApiWebSearchEnabled, h as isResponsesApiContextManagementEnabled, i as getConfig, l as getProviderConfig, m as isMessagesApiEnabled, n as getAnthropicApiKey, o as getMessageApiWebSearchModel, r as getClaudeTokenMultiplier, s as getModelMappings, u as getRawProviderConfig } from "./config-CQxppJtD.js";
+import { B as forwardError, C as prepareInteractionHeaders, D as compactMessageSections, E as compactAutoContinuePromptStarts, F as resolveTraceId$1, I as createPooledWebSocketStream, L as createWebSocketUrl, M as forwardCodexResponses, N as generateTraceId, P as requestContext, R as state, S as prepareForCompact, _ as getCopilotUsage, b as copilotHeaders, d as generateRequestIdFromPayload, f as getRootSessionId, g as sleep, h as parseUserIdMetadata, k as compactSystemPromptStarts, m as isNullish, p as getUUID, r as setupCodexToken, w as prepareMessageProxyHeaders, x as copilotWebSocketHeaders, y as copilotBaseUrl, z as HTTPError } from "./token-CFArcYwb.js";
 import { a as isDeferredToolName, c as parseMcpToolSearchSentinel, d as shouldEnableResponsesToolSearch, i as isBridgeToolSearchName, l as resolveBridgeToolSearchName, o as listDeferredToolNames, r as formatToolSearchBridgeArguments, s as normalizeToolSearchBridgeArguments, t as BRIDGE_TOOL_SEARCH_NAME, u as selectDeferredToolsByNames } from "./tool-search-OX6iPJ9D.js";
 import consola from "consola";
 import { createHash } from "node:crypto";
@@ -485,6 +485,7 @@ var SqliteDbStore = class {
 //#region src/lib/token-usage/store.ts
 const DB_PATH_ENV = "COPILOT_API_SQLITE_DB_PATH";
 const DEFAULT_DB_FILENAME = "copilot-api.sqlite";
+const COST_NANOS_PER_UNIT$1 = 1e9;
 let writeQueue = Promise.resolve();
 function getDbPath() {
 	return process.env[DB_PATH_ENV] ?? path.join(PATHS.APP_DIR, DEFAULT_DB_FILENAME);
@@ -518,11 +519,19 @@ function initializeTokenUsageDb(db) {
       output_tokens INTEGER NOT NULL DEFAULT 0,
       cache_read_input_tokens INTEGER NOT NULL DEFAULT 0,
       cache_creation_input_tokens INTEGER NOT NULL DEFAULT 0,
-      total_tokens INTEGER NOT NULL DEFAULT 0
+      total_tokens INTEGER NOT NULL DEFAULT 0,
+      total_nano_aiu INTEGER,
+      cost_currency TEXT,
+      total_cost_nanos INTEGER,
+      cost_source TEXT
     )
   `);
 	ensureColumn(db, "user_id", "TEXT NOT NULL DEFAULT ''");
 	ensureColumn(db, "total_tokens", "INTEGER NOT NULL DEFAULT 0");
+	ensureColumn(db, "total_nano_aiu", "INTEGER");
+	ensureColumn(db, "cost_currency", "TEXT");
+	ensureColumn(db, "total_cost_nanos", "INTEGER");
+	ensureColumn(db, "cost_source", "TEXT");
 	db.exec(`
     CREATE INDEX IF NOT EXISTS idx_token_usage_events_created_at_ms
     ON token_usage_events(created_at_ms)
@@ -555,7 +564,7 @@ function normalizeOptionalToken(value) {
 	return value === null || value === void 0 ? void 0 : normalizeToken(value);
 }
 function hasAnyToken(tokens) {
-	return normalizeToken(tokens.input_tokens) > 0 || normalizeToken(tokens.output_tokens) > 0 || normalizeToken(tokens.cache_read_input_tokens) > 0 || normalizeToken(tokens.cache_creation_input_tokens) > 0 || normalizeToken(tokens.total_tokens) > 0;
+	return normalizeToken(tokens.input_tokens) > 0 || normalizeToken(tokens.output_tokens) > 0 || normalizeToken(tokens.cache_read_input_tokens) > 0 || normalizeToken(tokens.cache_creation_input_tokens) > 0 || normalizeToken(tokens.total_tokens) > 0 || normalizeToken(tokens.total_nano_aiu) > 0;
 }
 function resolveTotalTokens(input) {
 	const explicitTotal = normalizeOptionalToken(input.total_tokens);
@@ -578,9 +587,13 @@ async function writeTokenUsageEvent(event) {
         output_tokens,
         cache_read_input_tokens,
         cache_creation_input_tokens,
-        total_tokens
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(event.created_at_ms, event.created_at_utc, event.trace_id, event.session_id, event.user_id, event.source, event.endpoint, event.provider_name, event.model, event.input_tokens, event.output_tokens, event.cache_read_input_tokens, event.cache_creation_input_tokens, event.total_tokens);
+        total_tokens,
+        total_nano_aiu,
+        cost_currency,
+        total_cost_nanos,
+        cost_source
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(event.created_at_ms, event.created_at_utc, event.trace_id, event.session_id, event.user_id, event.source, event.endpoint, event.provider_name, event.model, event.input_tokens, event.output_tokens, event.cache_read_input_tokens, event.cache_creation_input_tokens, event.total_tokens, event.total_nano_aiu, event.cost_currency, event.total_cost_nanos, event.cost_source);
 }
 function enqueueTokenUsageWrite(event) {
 	if (!isTokenUsageStorageEnabled()) return;
@@ -651,20 +664,34 @@ function createEmptyTotals() {
 	return {
 		cache_creation_input_tokens: 0,
 		cache_read_input_tokens: 0,
+		costs: [],
 		input_tokens: 0,
 		output_tokens: 0,
 		request_count: 0,
+		total_nano_aiu: null,
 		total_tokens: 0
 	};
 }
 function addTotals(target, next) {
 	target.cache_creation_input_tokens += next.cache_creation_input_tokens;
 	target.cache_read_input_tokens += next.cache_read_input_tokens;
+	target.costs = mergeCosts(target.costs, next.costs);
 	target.input_tokens += next.input_tokens;
 	target.output_tokens += next.output_tokens;
 	target.request_count += next.request_count;
+	target.total_nano_aiu = addNullableNumbers(target.total_nano_aiu, next.total_nano_aiu);
 	target.total_tokens += next.total_tokens;
 }
+function addNullableNumbers(current, next) {
+	if (current === null) return next;
+	if (next === null) return current;
+	return current + next;
+}
+function mergeCosts(current, next) {
+	const byCurrency = /* @__PURE__ */ new Map();
+	for (const cost of [...current, ...next]) byCurrency.set(cost.currency, (byCurrency.get(cost.currency) ?? 0) + cost.total_cost_nanos);
+	return [...byCurrency.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([currency, totalCostNanos]) => createCost(currency, totalCostNanos));
+}
 function createEmptySummary(period) {
 	const range = getPeriodRange(period);
 	return {
@@ -729,19 +756,47 @@ function numberFromRow(row, key) {
 	const value = row?.[key];
 	return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
-function totalsFromRow(row) {
+function nullableNumberFromRow(row, key) {
+	const value = row?.[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function createCost(currency, totalCostNanos) {
+	return {
+		amount: totalCostNanos / COST_NANOS_PER_UNIT$1,
+		currency,
+		total_cost_nanos: totalCostNanos
+	};
+}
+function costFromRow(row) {
+	const currency = row.cost_currency;
+	const totalCostNanos = row.total_cost_nanos;
+	if (typeof currency !== "string" || !currency || typeof totalCostNanos !== "number" || !Number.isFinite(totalCostNanos)) return null;
+	return createCost(currency, totalCostNanos);
+}
+function eventCostFromRow(row) {
+	const cost = costFromRow(row);
+	const source = row.cost_source;
+	if (!cost || typeof source !== "string" || !source) return null;
+	return {
+		...cost,
+		source
+	};
+}
+function totalsFromRow(row, costs = []) {
 	return {
 		cache_creation_input_tokens: numberFromRow(row, "cache_creation_input_tokens"),
 		cache_read_input_tokens: numberFromRow(row, "cache_read_input_tokens"),
+		costs,
 		input_tokens: numberFromRow(row, "input_tokens"),
 		output_tokens: numberFromRow(row, "output_tokens"),
 		request_count: numberFromRow(row, "request_count"),
+		total_nano_aiu: nullableNumberFromRow(row, "total_nano_aiu"),
 		total_tokens: numberFromRow(row, "total_tokens")
 	};
 }
-function modelSummaryFromRow(row) {
+function modelSummaryFromRow(row, costs = []) {
 	return {
-		...totalsFromRow(row),
+		...totalsFromRow(row, costs),
 		model: typeof row.model === "string" ? row.model : "unknown"
 	};
 }
@@ -757,6 +812,7 @@ function usageEventFromRow(row) {
 	return {
 		cache_creation_input_tokens: numberFromRow(row, "cache_creation_input_tokens"),
 		cache_read_input_tokens: numberFromRow(row, "cache_read_input_tokens"),
+		cost: eventCostFromRow(row),
 		created_at_ms: numberFromRow(row, "created_at_ms"),
 		created_at_utc: stringFromRow(row, "created_at_utc"),
 		endpoint: stringFromRow(row, "endpoint"),
@@ -767,6 +823,7 @@ function usageEventFromRow(row) {
 		provider_name: nullableStringFromRow(row, "provider_name"),
 		session_id: stringFromRow(row, "session_id"),
 		source: stringFromRow(row, "source"),
+		total_nano_aiu: nullableNumberFromRow(row, "total_nano_aiu"),
 		total_tokens: numberFromRow(row, "total_tokens"),
 		trace_id: stringFromRow(row, "trace_id"),
 		user_id: stringFromRow(row, "user_id")
@@ -780,6 +837,7 @@ function getTotalsRow(db, range) {
       COALESCE(SUM(output_tokens), 0) AS output_tokens,
       COALESCE(SUM(cache_read_input_tokens), 0) AS cache_read_input_tokens,
       COALESCE(SUM(cache_creation_input_tokens), 0) AS cache_creation_input_tokens,
+      SUM(total_nano_aiu) AS total_nano_aiu,
       COALESCE(SUM(total_tokens), 0) AS total_tokens
     FROM token_usage_events
     WHERE created_at_ms >= ? AND created_at_ms < ?
@@ -794,6 +852,7 @@ function getModelRows(db, range) {
       COALESCE(SUM(output_tokens), 0) AS output_tokens,
       COALESCE(SUM(cache_read_input_tokens), 0) AS cache_read_input_tokens,
       COALESCE(SUM(cache_creation_input_tokens), 0) AS cache_creation_input_tokens,
+      SUM(total_nano_aiu) AS total_nano_aiu,
       COALESCE(SUM(total_tokens), 0) AS total_tokens
     FROM token_usage_events
     WHERE created_at_ms >= ? AND created_at_ms < ?
@@ -803,8 +862,56 @@ function getModelRows(db, range) {
       model ASC
   `).all(range.startMs, range.endMs);
 }
-function createDailyBucket(interval, rows) {
-	const byModel = rows.map((row) => modelSummaryFromRow(row));
+function getCostRows(db, range) {
+	return db.prepare(`
+    SELECT
+      cost_currency,
+      COALESCE(SUM(total_cost_nanos), 0) AS total_cost_nanos
+    FROM token_usage_events
+    WHERE
+      created_at_ms >= ?
+      AND created_at_ms < ?
+      AND cost_currency IS NOT NULL
+      AND total_cost_nanos IS NOT NULL
+    GROUP BY cost_currency
+    ORDER BY cost_currency ASC
+  `).all(range.startMs, range.endMs).flatMap((row) => {
+		const cost = costFromRow(row);
+		return cost ? [cost] : [];
+	});
+}
+function getModelCostMap(db, range) {
+	const rows = db.prepare(`
+    SELECT
+      model,
+      cost_currency,
+      COALESCE(SUM(total_cost_nanos), 0) AS total_cost_nanos
+    FROM token_usage_events
+    WHERE
+      created_at_ms >= ?
+      AND created_at_ms < ?
+      AND cost_currency IS NOT NULL
+      AND total_cost_nanos IS NOT NULL
+    GROUP BY model, cost_currency
+    ORDER BY model ASC, cost_currency ASC
+  `).all(range.startMs, range.endMs);
+	const costMap = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const model = stringFromRow(row, "model") || "unknown";
+		const cost = costFromRow(row);
+		if (!cost) continue;
+		costMap.set(model, [...costMap.get(model) ?? [], cost]);
+	}
+	return costMap;
+}
+function getModelSummaries(db, range) {
+	const costMap = getModelCostMap(db, range);
+	return getModelRows(db, range).map((row) => {
+		const model = stringFromRow(row, "model") || "unknown";
+		return modelSummaryFromRow(row, costMap.get(model) ?? []);
+	});
+}
+function createDailyBucket(interval, byModel) {
 	const totals = createEmptyTotals();
 	for (const model of byModel) addTotals(totals, model);
 	return {
@@ -822,10 +929,10 @@ async function getTokenUsageSummary(period) {
 	const db = await getDb();
 	const totalsRow = getTotalsRow(db, range);
 	return {
-		byModel: getModelRows(db, range).map((row) => modelSummaryFromRow(row)),
+		byModel: getModelSummaries(db, range),
 		period,
 		range: rangePayload(range),
-		totals: totalsFromRow(totalsRow)
+		totals: totalsFromRow(totalsRow, getCostRows(db, range))
 	};
 }
 async function getTokenUsageDailySummary(period) {
@@ -835,11 +942,11 @@ async function getTokenUsageDailySummary(period) {
 	const db = await getDb();
 	const intervals = createDailyIntervals(range);
 	return {
-		byModel: getModelRows(db, range).map((row) => modelSummaryFromRow(row)),
-		days: intervals.map((interval) => createDailyBucket(interval, getModelRows(db, interval))),
+		byModel: getModelSummaries(db, range),
+		days: intervals.map((interval) => createDailyBucket(interval, getModelSummaries(db, interval))),
 		period,
 		range: rangePayload(range),
-		totals: totalsFromRow(getTotalsRow(db, range))
+		totals: totalsFromRow(getTotalsRow(db, range), getCostRows(db, range))
 	};
 }
 async function getTokenUsageEventsPage(input) {
@@ -871,7 +978,11 @@ async function getTokenUsageEventsPage(input) {
       output_tokens,
       cache_read_input_tokens,
       cache_creation_input_tokens,
-      total_tokens
+      total_nano_aiu,
+      total_tokens,
+      cost_currency,
+      total_cost_nanos,
+      cost_source
     FROM token_usage_events
     WHERE created_at_ms >= ? AND created_at_ms < ?
     ORDER BY created_at_ms DESC, id DESC
@@ -904,6 +1015,174 @@ async function closeUsageStore() {
 }
 registerProcessCleanup(closeUsageStore);
 //#endregion
+//#region src/lib/token-usage/pricing.ts
+const COST_NANOS_PER_UNIT = 1e9;
+const COST_NANOS_PER_TOKEN_AT_ONE_PER_MILLION = 1e3;
+const COPILOT_NANO_AIU_TO_COST_NANOS = COST_NANOS_PER_UNIT / 1e11;
+const BUILTIN_PROVIDER_CURRENCIES = {
+	codex: "USD",
+	dashscope: "CNY",
+	deepseek: "CNY"
+};
+const BUILTIN_PROVIDER_PRICING = {
+	codex: {
+		"gpt-5.3-codex": {
+			cachedInput: .175,
+			input: 1.75,
+			output: 14
+		},
+		"gpt-5.4": {
+			cachedInput: .25,
+			input: 2.5,
+			output: 15
+		},
+		"gpt-5.4-mini": {
+			cachedInput: .075,
+			input: .75,
+			output: 4.5
+		},
+		"gpt-5.5": {
+			cachedInput: .5,
+			input: 5,
+			output: 30
+		}
+	},
+	dashscope: {
+		"glm-5.1": { tiers: [{
+			cachedInput: 1.2,
+			cacheCreationInput: 7.5,
+			explicitCachedInput: .6,
+			input: 6,
+			maxInputTokens: 32e3,
+			output: 24
+		}, {
+			cachedInput: 1.6,
+			cacheCreationInput: 10,
+			explicitCachedInput: .8,
+			input: 8,
+			maxInputTokens: 2e5,
+			output: 28
+		}] },
+		"glm-5.2": {
+			cachedInput: 2,
+			cacheCreationInput: 10,
+			explicitCachedInput: .8,
+			input: 8,
+			output: 28
+		},
+		"qwen3.7-max": {
+			cachedInput: 2.4,
+			cacheCreationInput: 15,
+			explicitCachedInput: 1.2,
+			input: 12,
+			output: 36
+		},
+		"qwen3.7-plus": { tiers: [{
+			cachedInput: .4,
+			cacheCreationInput: 2.5,
+			explicitCachedInput: .2,
+			input: 2,
+			maxInputTokens: 256e3,
+			output: 8
+		}, {
+			cachedInput: 1.2,
+			cacheCreationInput: 7.5,
+			explicitCachedInput: .6,
+			input: 6,
+			maxInputTokens: 1e6,
+			output: 24
+		}] }
+	},
+	deepseek: {
+		"deepseek-v4-flash": {
+			cachedInput: .02,
+			input: 1,
+			output: 2
+		},
+		"deepseek-v4-pro": {
+			cachedInput: .025,
+			input: 3,
+			output: 6
+		}
+	}
+};
+function resolveTokenUsageCost(input) {
+	if (input.source === "copilot") return resolveCopilotCost(input);
+	const providerName = input.providerName?.trim();
+	if (!providerName) return null;
+	const resolvedPricing = resolveProviderPricing(providerName, input.model, input.pricing);
+	if (!resolvedPricing) return null;
+	const pricing = resolvePricingTier(resolvedPricing.pricing, getInputTokenTotal(input));
+	const currency = resolveProviderCurrency(providerName, input.pricingCurrency);
+	if (!currency) return null;
+	const inputPrice = normalizePrice(pricing.input);
+	const outputPrice = normalizePrice(pricing.output);
+	const cacheReadPrice = resolveCacheReadPrice(pricing, input);
+	const cacheCreationPrice = resolveCacheCreationPrice(pricing);
+	const totalCostNanos = costNanosForTokens(input.input_tokens, inputPrice) + costNanosForTokens(input.output_tokens, outputPrice) + costNanosForTokens(input.cache_read_input_tokens, cacheReadPrice) + costNanosForTokens(input.cache_creation_input_tokens, cacheCreationPrice);
+	if (totalCostNanos <= 0) return null;
+	return {
+		currency,
+		source: resolvedPricing.source,
+		total_cost_nanos: totalCostNanos
+	};
+}
+function resolveCopilotCost(input) {
+	const totalNanoAiu = normalizeToken(input.total_nano_aiu);
+	if (totalNanoAiu <= 0) return null;
+	const totalCostNanos = Math.round(totalNanoAiu * COPILOT_NANO_AIU_TO_COST_NANOS);
+	if (totalCostNanos <= 0) return null;
+	return {
+		currency: "USD",
+		source: "copilot_aiu",
+		total_cost_nanos: totalCostNanos
+	};
+}
+function resolveProviderPricing(providerName, model, configuredPricing) {
+	if (configuredPricing) return {
+		pricing: configuredPricing,
+		source: "config"
+	};
+	const builtinPricing = BUILTIN_PROVIDER_PRICING[providerName.toLowerCase()]?.[model.toLowerCase()];
+	if (!builtinPricing) return null;
+	return {
+		pricing: builtinPricing,
+		source: "builtin"
+	};
+}
+function resolvePricingTier(pricing, inputTokenTotal) {
+	const tiers = pricing.tiers?.filter((tier) => typeof tier === "object" && tier !== null).toSorted((a, b) => normalizeTierMax(a) - normalizeTierMax(b));
+	const selectedTier = tiers?.find((tier) => inputTokenTotal <= normalizeTierMax(tier)) ?? tiers?.at(-1);
+	return {
+		...pricing,
+		...selectedTier
+	};
+}
+function normalizeTierMax(tier) {
+	const maxInputTokens = tier.maxInputTokens;
+	return typeof maxInputTokens === "number" && Number.isFinite(maxInputTokens) && maxInputTokens > 0 ? maxInputTokens : Number.POSITIVE_INFINITY;
+}
+function getInputTokenTotal(input) {
+	return normalizeToken(input.input_tokens) + normalizeToken(input.cache_read_input_tokens) + normalizeToken(input.cache_creation_input_tokens);
+}
+function normalizePrice(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function resolveProviderCurrency(providerName, configuredCurrency) {
+	return configuredCurrency?.trim().toUpperCase() || BUILTIN_PROVIDER_CURRENCIES[providerName.toLowerCase()] || null;
+}
+function resolveCacheCreationPrice(pricing) {
+	return normalizePrice(pricing.cacheCreationInput);
+}
+function resolveCacheReadPrice(pricing, input) {
+	if (input.cache_creation_input_tokens !== void 0 && input.cache_creation_input_tokens !== null) return normalizePrice(pricing.explicitCachedInput);
+	return normalizePrice(pricing.cachedInput);
+}
+function costNanosForTokens(tokens, pricePerMillionTokens) {
+	if (pricePerMillionTokens === null) return 0;
+	return Math.round(normalizeToken(tokens) * pricePerMillionTokens * COST_NANOS_PER_TOKEN_AT_ONE_PER_MILLION);
+}
+//#endregion
 //#region src/lib/token-usage/index.ts
 const tokenUsageEventBus = new EventBus();
 function resolveTraceId(traceId) {
@@ -919,9 +1198,12 @@ function resolveUserId(input) {
 function toPersistedEvent(input) {
 	if (!hasAnyToken(input)) return null;
 	const now = /* @__PURE__ */ new Date();
+	const cost = resolveTokenUsageCost(input);
 	return {
 		cache_creation_input_tokens: normalizeToken(input.cache_creation_input_tokens),
 		cache_read_input_tokens: normalizeToken(input.cache_read_input_tokens),
+		cost_currency: cost?.currency ?? null,
+		cost_source: cost?.source ?? null,
 		created_at_ms: now.getTime(),
 		created_at_utc: now.toISOString(),
 		endpoint: input.endpoint,
@@ -931,6 +1213,8 @@ function toPersistedEvent(input) {
 		provider_name: input.providerName?.trim() || null,
 		session_id: resolveTokenUsageSessionId(input.sessionId, input.fallbackSessionId),
 		source: input.source,
+		total_nano_aiu: input.total_nano_aiu === void 0 || input.total_nano_aiu === null ? null : normalizeToken(input.total_nano_aiu),
+		total_cost_nanos: cost?.total_cost_nanos ?? null,
 		total_tokens: resolveTotalTokens(input),
 		trace_id: resolveTraceId(input.traceId),
 		user_id: resolveUserId(input)
@@ -963,12 +1247,21 @@ function createProviderTokenUsageRecorder(options) {
 	});
 }
 function normalizeOpenAIUsage(usage) {
-	const cachedTokens = normalizeToken(usage?.prompt_tokens_details?.cached_tokens);
-	const cacheCreationTokens = normalizeToken(usage?.prompt_tokens_details?.cache_creation_input_tokens);
+	if (usage && (Object.hasOwn(usage, "prompt_cache_hit_tokens") || Object.hasOwn(usage, "prompt_cache_miss_tokens"))) return {
+		cache_read_input_tokens: normalizeToken(usage.prompt_cache_hit_tokens),
+		input_tokens: normalizeToken(usage.prompt_cache_miss_tokens),
+		output_tokens: normalizeToken(usage.completion_tokens),
+		total_tokens: normalizeOptionalToken(usage.total_tokens)
+	};
+	const promptDetails = usage?.prompt_tokens_details;
+	const hasCacheCreationTokens = Boolean(promptDetails && Object.hasOwn(promptDetails, "cache_creation_input_tokens"));
+	const hasCachedTokens = Boolean(promptDetails && Object.hasOwn(promptDetails, "cached_tokens"));
+	const cachedTokens = normalizeToken(promptDetails?.cached_tokens);
+	const cacheCreationTokens = normalizeToken(promptDetails?.cache_creation_input_tokens);
 	const promptTokens = normalizeToken(usage?.prompt_tokens);
 	return {
-		cache_creation_input_tokens: cacheCreationTokens,
-		cache_read_input_tokens: cachedTokens,
+		...hasCacheCreationTokens && { cache_creation_input_tokens: cacheCreationTokens },
+		...hasCachedTokens && { cache_read_input_tokens: cachedTokens },
 		input_tokens: Math.max(0, promptTokens - cachedTokens - cacheCreationTokens),
 		output_tokens: normalizeToken(usage?.completion_tokens),
 		total_tokens: normalizeOptionalToken(usage?.total_tokens)
@@ -1128,7 +1421,7 @@ async function handleProviderChatCompletionsForProvider(c, options) {
 		});
 		throw new HTTPError(`Failed to create ${provider} chat completions`, upstreamResponse);
 	}
-	const recordUsage = createProviderChatCompletionsUsageRecorder(payload, provider);
+	const recordUsage = createProviderChatCompletionsUsageRecorder(payload, provider, modelConfig, providerConfig.pricingCurrency);
 	const contentType = upstreamResponse.headers.get("content-type") ?? "";
 	if (Boolean(payload.stream) && contentType.includes("text/event-stream")) return streamProviderChatCompletions(c, upstreamResponse, {
 		provider,
@@ -1154,9 +1447,11 @@ const applyProviderStreamOptions = (payload) => {
 		include_usage: true
 	};
 };
-const createProviderChatCompletionsUsageRecorder = (payload, provider) => createProviderTokenUsageRecorder({
+const createProviderChatCompletionsUsageRecorder = (payload, provider, modelConfig, pricingCurrency) => createProviderTokenUsageRecorder({
 	endpoint: "chat_completions",
 	model: payload.model,
+	pricing: modelConfig?.pricing,
+	pricingCurrency,
 	providerName: provider
 });
 const streamProviderChatCompletions = (c, upstreamResponse, options) => {
@@ -1336,7 +1631,10 @@ async function handleCompletion$1(c) {
 	});
 	if (isNonStreaming$1(response)) {
 		debugJson(logger$7, "Non-streaming response:", response);
-		recordUsage(normalizeOpenAIUsage(response.usage));
+		recordUsage({
+			...normalizeOpenAIUsage(response.usage),
+			total_nano_aiu: normalizeOptionalToken(response.copilot_usage?.total_nano_aiu)
+		});
 		return c.json(response);
 	}
 	logger$7.debug("Streaming response");
@@ -1345,7 +1643,10 @@ async function handleCompletion$1(c) {
 		for await (const chunk of response) {
 			debugJson(logger$7, "Streaming chunk:", chunk);
 			const parsedChunk = parseChatCompletionChunk(chunk);
-			if (parsedChunk?.usage) usage = normalizeOpenAIUsage(parsedChunk.usage);
+			if (parsedChunk?.usage || parsedChunk?.copilot_usage) usage = {
+				...normalizeOpenAIUsage(parsedChunk.usage),
+				total_nano_aiu: normalizeOptionalToken(parsedChunk.copilot_usage?.total_nano_aiu)
+			};
 			await stream.writeSSE(chunk);
 		}
 		recordUsage(usage);
@@ -4512,39 +4813,47 @@ const createWebSearchResponsesStreamCollection = () => ({
 	textPartsByKey: /* @__PURE__ */ new Map()
 });
 const collectWebSearchResponsesStreamEvent = (event, state) => {
-	if (event.type === "response.created") {
-		state.createdResponse = getResponsesResult(event.response);
-		return;
-	}
-	if (isResponsesTerminalEvent(event)) {
-		state.terminalResponse = event.response;
-		return;
-	}
-	if (event.type === "response.output_item.added" || event.type === "response.output_item.done") {
-		const outputIndex = getNumber(event.output_index);
-		const item = getRecord(event.item);
-		if (outputIndex !== void 0 && item) state.outputItemsByIndex.set(outputIndex, item);
-		return;
-	}
-	if (event.type === "response.output_text.delta") {
-		const part = getOrCreateOutputTextPart(event, state);
-		const delta = getString(event.delta);
-		if (part && delta) part.text += delta;
-		return;
-	}
-	if (event.type === "response.output_text.done") {
-		const part = getOrCreateOutputTextPart(event, state);
-		const text = getString(event.text);
-		if (part && text !== void 0) part.text = text;
-		return;
-	}
-	if (event.type === "response.output_text.annotation.added") {
-		const part = getOrCreateOutputTextPart(event, state);
-		const annotation = event.annotation;
-		if (part && annotation !== void 0) part.annotations.push(annotation);
-		return;
+	switch (event.type) {
+		case "response.created":
+			state.createdResponse = getResponsesResult(event.response);
+			break;
+		case "response.completed":
+		case "response.failed":
+		case "response.incomplete":
+			if (isResponsesTerminalEvent(event)) {
+				event.response.copilot_usage ??= event.copilot_usage;
+				state.terminalResponse = event.response;
+			}
+			break;
+		case "response.output_item.added":
+		case "response.output_item.done": {
+			const outputIndex = getNumber(event.output_index);
+			const item = getRecord(event.item);
+			if (outputIndex !== void 0 && item) state.outputItemsByIndex.set(outputIndex, item);
+			break;
+		}
+		case "response.output_text.delta": {
+			const part = getOrCreateOutputTextPart(event, state);
+			const delta = getString(event.delta);
+			if (part && delta) part.text += delta;
+			break;
+		}
+		case "response.output_text.done": {
+			const part = getOrCreateOutputTextPart(event, state);
+			const text = getString(event.text);
+			if (part && text !== void 0) part.text = text;
+			break;
+		}
+		case "response.output_text.annotation.added": {
+			const part = getOrCreateOutputTextPart(event, state);
+			const annotation = event.annotation;
+			if (part && annotation !== void 0) part.annotations.push(annotation);
+			break;
+		}
+		case "response.content_part.done":
+			collectDoneContentPart(event, state);
+			break;
 	}
-	if (event.type === "response.content_part.done") collectDoneContentPart(event, state);
 };
 const buildWebSearchResponsesStreamResult = (state) => {
 	const response = state.terminalResponse ?? state.createdResponse;
@@ -4692,7 +5001,10 @@ const handleWebSearchViaResponses = async (c, payload, options) => {
 	}) : upstreamResult;
 	const { extract, response } = reconstructWebSearchResponse(payload, result, { requestId: options.requestId });
 	debugJson(logger, `Web search via responses: ${extract.queries.length} quer(y/ies), ${extract.sources.length} source(s)`, result);
-	createUsageRecorder(payload, options.sessionId, webSearchModel)(normalizeResponsesUsage(result.usage));
+	createUsageRecorder(payload, options.sessionId, webSearchModel)({
+		...normalizeResponsesUsage(result.usage),
+		total_nano_aiu: normalizeOptionalToken(result.copilot_usage?.total_nano_aiu)
+	});
 	if (!wantsStream) return c.json(response);
 	return streamSSE(c, async (stream) => {
 		for (const event of buildSyntheticStreamEvents(response)) await stream.writeSSE({
@@ -4891,6 +5203,7 @@ async function handleProviderMessagesForProvider(c, options) {
 		if (providerConfig.type === "openai-responses") {
 			if (hasWebSearchServerTool(payload)) {
 				if (isWebSearchOnlyRequest(payload)) return await handleOpenAIResponsesProviderWebSearchMessages(c, {
+					modelConfig,
 					payload,
 					provider,
 					providerConfig
@@ -4926,13 +5239,17 @@ async function handleProviderMessagesForProvider(c, options) {
 		const contentType = upstreamResponse.headers.get("content-type") ?? "";
 		if (Boolean(payload.stream) && contentType.includes("text/event-stream")) return streamProviderMessages({
 			c,
+			modelConfig,
 			payload,
+			pricingCurrency: providerConfig.pricingCurrency,
 			provider,
 			upstreamResponse
 		});
 		return respondProviderMessagesJson(c, {
 			body: await upstreamResponse.json(),
+			modelConfig,
 			payload,
+			pricingCurrency: providerConfig.pricingCurrency,
 			provider
 		});
 	} catch (error) {
@@ -4944,7 +5261,7 @@ async function handleProviderMessagesForProvider(c, options) {
 	}
 }
 const handleOpenAIResponsesProviderWebSearchMessages = async (c, options) => {
-	const { payload, provider, providerConfig } = options;
+	const { modelConfig, payload, provider, providerConfig } = options;
 	const selectedModel = providerConfig.name === "codex" ? getModels().data.find((model) => model.id === payload.model) : void 0;
 	const responsesPayload = prepareWebSearchResponsesPayload(payload);
 	responsesPayload.stream = true;
@@ -4963,12 +5280,16 @@ const handleOpenAIResponsesProviderWebSearchMessages = async (c, options) => {
 				upstreamResponse,
 				logger: logger$5
 			}),
+			modelConfig,
 			payload,
+			pricingCurrency: providerConfig.pricingCurrency,
 			provider
 		});
 		return respondWebSearchProviderMessagesJson(c, {
 			body: upstreamResponse,
+			modelConfig,
 			payload,
+			pricingCurrency: providerConfig.pricingCurrency,
 			provider
 		});
 	}
@@ -4987,17 +5308,21 @@ const handleOpenAIResponsesProviderWebSearchMessages = async (c, options) => {
 			upstreamResponse: events(upstreamResponse),
 			logger: logger$5
 		}),
+		modelConfig,
 		payload,
+		pricingCurrency: providerConfig.pricingCurrency,
 		provider
 	});
 	return respondWebSearchProviderMessagesJson(c, {
 		body: await upstreamResponse.json(),
+		modelConfig,
 		payload,
+		pricingCurrency: providerConfig.pricingCurrency,
 		provider
 	});
 };
 const handleOpenAIResponsesProviderMessages = async (c, options) => {
-	const { payload, provider, providerConfig } = options;
+	const { modelConfig, payload, provider, providerConfig } = options;
 	const selectedModel = providerConfig.name === "codex" ? getModels().data.find((model) => model.id === payload.model) : void 0;
 	const responsesPayload = translateAnthropicMessagesToResponsesPayload(payload);
 	applyResponsesApiContextManagement(responsesPayload, selectedModel?.capabilities.limits.max_prompt_tokens);
@@ -5010,14 +5335,18 @@ const handleOpenAIResponsesProviderMessages = async (c, options) => {
 		const upstreamResponse = await forwardCodexResponses(responsesPayload, c.req.raw.headers, providerConfig.baseUrl);
 		if (responsesPayload.stream && isResponsesStream$1(upstreamResponse)) return streamResponsesProviderMessages({
 			c,
+			modelConfig,
 			payload,
+			pricingCurrency: providerConfig.pricingCurrency,
 			provider,
 			providerConfig,
 			upstreamResponse
 		});
 		return respondResponsesProviderMessagesJson(c, {
 			body: upstreamResponse,
+			modelConfig,
 			payload,
+			pricingCurrency: providerConfig.pricingCurrency,
 			provider,
 			providerConfig
 		});
@@ -5029,14 +5358,18 @@ const handleOpenAIResponsesProviderMessages = async (c, options) => {
 	}
 	if (responsesPayload.stream) return streamResponsesProviderMessages({
 		c,
+		modelConfig,
 		payload,
+		pricingCurrency: providerConfig.pricingCurrency,
 		provider,
 		providerConfig,
 		upstreamResponse: events(upstreamResponse)
 	});
 	return respondResponsesProviderMessagesJson(c, {
 		body: await upstreamResponse.json(),
+		modelConfig,
 		payload,
+		pricingCurrency: providerConfig.pricingCurrency,
 		provider,
 		providerConfig
 	});
@@ -5083,13 +5416,17 @@ const handleOpenAICompatibleProviderMessages = async (c, options) => {
 	const contentType = upstreamResponse.headers.get("content-type") ?? "";
 	if (Boolean(openAIPayload.stream) && contentType.includes("text/event-stream")) return streamOpenAICompatibleProviderMessages({
 		c,
+		modelConfig,
 		payload,
+		pricingCurrency: providerConfig.pricingCurrency,
 		provider,
 		upstreamResponse
 	});
 	return respondOpenAICompatibleProviderMessagesJson(c, {
 		body: await upstreamResponse.json(),
+		modelConfig,
 		payload,
+		pricingCurrency: providerConfig.pricingCurrency,
 		provider
 	});
 };
@@ -5158,9 +5495,9 @@ const applyContextCacheControl = (message) => {
 const setContextCacheControl = (part) => {
 	part.cache_control = { ...OPENAI_COMPATIBLE_CONTEXT_CACHE_CONTROL };
 };
-const streamProviderMessages = ({ c, payload, provider, upstreamResponse }) => {
+const streamProviderMessages = ({ c, modelConfig, payload, pricingCurrency, provider, upstreamResponse }) => {
 	logger$5.debug("provider.messages.streaming");
-	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
+	const recordUsage = createProviderMessagesUsageRecorder(payload, provider, modelConfig, pricingCurrency);
 	return streamSSE(c, async (stream) => {
 		let usage = {};
 		for await (const chunk of events(upstreamResponse)) {
@@ -5189,9 +5526,9 @@ const streamProviderMessages = ({ c, payload, provider, upstreamResponse }) => {
 		recordUsage(usage);
 	});
 };
-const streamOpenAICompatibleProviderMessages = ({ c, payload, provider, upstreamResponse }) => {
+const streamOpenAICompatibleProviderMessages = ({ c, modelConfig, payload, pricingCurrency, provider, upstreamResponse }) => {
 	logger$5.debug("provider.messages.openai_compatible.streaming");
-	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
+	const recordUsage = createProviderMessagesUsageRecorder(payload, provider, modelConfig, pricingCurrency);
 	return streamSSE(c, async (stream) => {
 		let usage = {};
 		const streamState = {
@@ -5238,9 +5575,9 @@ const streamOpenAICompatibleProviderMessages = ({ c, payload, provider, upstream
 		recordUsage(usage);
 	});
 };
-const streamResponsesProviderMessages = ({ c, payload, provider, providerConfig, upstreamResponse }) => {
+const streamResponsesProviderMessages = ({ c, modelConfig, payload, pricingCurrency, provider, providerConfig, upstreamResponse }) => {
 	logger$5.debug("provider.messages.responses.streaming", { provider });
-	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
+	const recordUsage = createProviderMessagesUsageRecorder(payload, provider, modelConfig, pricingCurrency);
 	return streamSSE(c, async (stream) => {
 		let usage = {};
 		const streamState = createResponsesStreamState({ toolSearchName: resolveBridgeToolSearchName(payload.tools) });
@@ -5333,29 +5670,29 @@ const parseProviderStreamEvent = (data) => {
 	}
 };
 const respondProviderMessagesJson = (c, options) => {
-	const { body, payload, provider } = options;
-	createProviderMessagesUsageRecorder(payload, provider)(normalizeAnthropicUsage(body.usage));
+	const { body, modelConfig, payload, pricingCurrency, provider } = options;
+	createProviderMessagesUsageRecorder(payload, provider, modelConfig, pricingCurrency)(normalizeAnthropicUsage(body.usage));
 	debugJson(logger$5, "provider.messages.no_stream result:", body);
 	return c.json(body);
 };
 const respondOpenAICompatibleProviderMessagesJson = (c, options) => {
-	const { body, payload, provider } = options;
-	createProviderMessagesUsageRecorder(payload, provider)(normalizeOpenAIUsage(body.usage));
+	const { body, modelConfig, payload, pricingCurrency, provider } = options;
+	createProviderMessagesUsageRecorder(payload, provider, modelConfig, pricingCurrency)(normalizeOpenAIUsage(body.usage));
 	const anthropicResponse = translateToAnthropic(body);
 	debugJson(logger$5, "provider.messages.openai_compatible.no_stream result:", anthropicResponse);
 	return c.json(anthropicResponse);
 };
 const respondResponsesProviderMessagesJson = (c, options) => {
-	const { body, payload, provider, providerConfig } = options;
-	createProviderMessagesUsageRecorder(payload, provider)(normalizeResponsesUsage(body.usage));
+	const { body, modelConfig, payload, pricingCurrency, provider, providerConfig } = options;
+	createProviderMessagesUsageRecorder(payload, provider, modelConfig, pricingCurrency)(normalizeResponsesUsage(body.usage));
 	const anthropicResponse = translateResponsesResultToAnthropic(body, { toolSearchName: resolveBridgeToolSearchName(payload.tools) });
 	debugJson(logger$5, "provider.messages.responses.no_stream result:", anthropicResponse);
 	if (providerConfig.name === "codex") logger$5.debug("provider.messages.codex.no_stream.result");
 	return c.json(anthropicResponse);
 };
 const respondWebSearchProviderMessagesJson = (c, options) => {
-	const { body, payload, provider } = options;
-	createProviderMessagesUsageRecorder(payload, provider)(normalizeResponsesUsage(body.usage));
+	const { body, modelConfig, payload, pricingCurrency, provider } = options;
+	createProviderMessagesUsageRecorder(payload, provider, modelConfig, pricingCurrency)(normalizeResponsesUsage(body.usage));
 	const { extract, response } = reconstructWebSearchResponse(payload, body, { requestId: body.id || `${provider}:${payload.model}` });
 	logger$5.debug(`provider.messages.responses.web_search: ${extract.queries.length} quer(y/ies), ${extract.sources.length} source(s)`);
 	if (!payload.stream) return c.json(response);
@@ -5366,9 +5703,11 @@ const respondWebSearchProviderMessagesJson = (c, options) => {
 		});
 	});
 };
-const createProviderMessagesUsageRecorder = (payload, provider) => createProviderTokenUsageRecorder({
+const createProviderMessagesUsageRecorder = (payload, provider, modelConfig, pricingCurrency) => createProviderTokenUsageRecorder({
 	endpoint: "provider_messages",
 	model: payload.model,
+	pricing: modelConfig?.pricing,
+	pricingCurrency,
 	providerName: provider,
 	sessionId: parseUserIdMetadata(payload.metadata?.user_id).sessionId
 });
@@ -5454,7 +5793,10 @@ const handleWithChatCompletions = async (c, anthropicPayload, options) => {
 	});
 	if (isNonStreaming(response)) {
 		debugJson(logger, "Non-streaming response from Copilot:", response);
-		recordUsage(normalizeOpenAIUsage(response.usage));
+		recordUsage({
+			...normalizeOpenAIUsage(response.usage),
+			total_nano_aiu: normalizeOptionalToken(response.copilot_usage?.total_nano_aiu)
+		});
 		const anthropicResponse = translateToAnthropic(response);
 		debugJson(logger, "Translated Anthropic response:", anthropicResponse);
 		return c.json(anthropicResponse);
@@ -5474,7 +5816,10 @@ const handleWithChatCompletions = async (c, anthropicPayload, options) => {
 			if (rawEvent.data === "[DONE]") break;
 			if (!rawEvent.data) continue;
 			const chunk = JSON.parse(rawEvent.data);
-			if (chunk.usage) usage = normalizeOpenAIUsage(chunk.usage);
+			if (chunk.usage || chunk.copilot_usage) usage = {
+				...normalizeOpenAIUsage(chunk.usage),
+				total_nano_aiu: normalizeOptionalToken(chunk.copilot_usage?.total_nano_aiu)
+			};
 			const events = translateChunkToAnthropicEvents(chunk, streamState);
 			for (const event of events) {
 				const eventData = JSON.stringify(event);
@@ -5533,7 +5878,10 @@ const handleWithResponsesApi = async (c, anthropicPayload, options) => {
 				if (!data) continue;
 				debugLazy(logger, () => ["Responses raw stream event:", data]);
 				const responseEvent = JSON.parse(data);
-				if (responseEvent.type === "response.completed" || responseEvent.type === "response.failed" || responseEvent.type === "response.incomplete") usage = normalizeResponsesUsage(responseEvent.response.usage);
+				if (responseEvent.type === "response.completed" || responseEvent.type === "response.failed" || responseEvent.type === "response.incomplete") usage = {
+					...normalizeResponsesUsage(responseEvent.response.usage),
+					total_nano_aiu: normalizeOptionalToken(responseEvent.copilot_usage?.total_nano_aiu)
+				};
 				const events = translateResponsesStreamEvent(responseEvent, streamState);
 				for (const event of events) {
 					const eventData = JSON.stringify(event);
@@ -5559,12 +5907,13 @@ const handleWithResponsesApi = async (c, anthropicPayload, options) => {
 			recordUsage(usage);
 		});
 	}
-	debugJsonTail(logger, "Non-streaming Responses result:", {
-		value: response,
-		tailLength: 400
-	});
+	debugJson(logger, "Non-streaming Responses result:", response);
 	const anthropicResponse = translateResponsesResultToAnthropic(response, { toolSearchName: resolveBridgeToolSearchName(anthropicPayload.tools) });
-	recordUsage(normalizeResponsesUsage(response.usage));
+	const responsesResult = response;
+	recordUsage({
+		...normalizeResponsesUsage(responsesResult.usage),
+		total_nano_aiu: normalizeOptionalToken(responsesResult.copilot_usage?.total_nano_aiu)
+	});
 	debugJson(logger, "Translated Anthropic response:", anthropicResponse);
 	return c.json(anthropicResponse);
 };
@@ -5759,7 +6108,6 @@ messageRoutes.post("/count_tokens", async (c) => {
 const modelRoutes = new Hono();
 modelRoutes.get("/", async (c) => {
 	try {
-		if (!state.models) await cacheModels();
 		const models = state.models?.data.map((model) => {
 			const contextWindow = model.capabilities?.limits?.max_context_window_tokens ?? 0;
 			const clientId = toClientModelId(model.id);
@@ -5856,9 +6204,10 @@ async function handleProviderResponsesForProvider(c, options) {
 		provider
 	});
 	compactInputByLatestCompaction(payload);
+	const modelConfig = providerConfig.models?.[payload.model];
 	if (providerConfig.name === "codex") {
 		const upstreamResponse = await forwardCodexResponses(payload, c.req.raw.headers, providerConfig.baseUrl);
-		const recordUsage = createProviderResponsesUsageRecorder(payload, provider);
+		const recordUsage = createProviderResponsesUsageRecorder(payload, provider, modelConfig, providerConfig.pricingCurrency);
 		if (payload.stream && isResponsesStream(upstreamResponse)) return streamProviderResponses(c, upstreamResponse, {
 			normalizeCodex: true,
 			provider,
@@ -5870,7 +6219,7 @@ async function handleProviderResponsesForProvider(c, options) {
 	}
 	const upstreamResponse = await forwardProviderResponses(providerConfig, payload, c.req.raw.headers);
 	if (!upstreamResponse.ok) throw new HTTPError(`Failed to create ${provider} responses`, upstreamResponse);
-	const recordUsage = createProviderResponsesUsageRecorder(payload, provider);
+	const recordUsage = createProviderResponsesUsageRecorder(payload, provider, modelConfig, providerConfig.pricingCurrency);
 	if (payload.stream) return streamProviderResponses(c, getResponsesEvents(upstreamResponse), {
 		normalizeCodex: false,
 		provider,
@@ -5879,11 +6228,13 @@ async function handleProviderResponsesForProvider(c, options) {
 	recordUsage(normalizeResponsesUsage((await upstreamResponse.clone().json()).usage));
 	return createProviderProxyResponse(upstreamResponse);
 }
-const createProviderResponsesUsageRecorder = (payload, provider) => {
+const createProviderResponsesUsageRecorder = (payload, provider, modelConfig, pricingCurrency) => {
 	const sessionAffinity = requestContext.getStore()?.sessionAffinity?.trim() || null;
 	return createProviderTokenUsageRecorder({
 		endpoint: "responses",
 		model: payload.model,
+		pricing: modelConfig?.pricing,
+		pricingCurrency,
 		providerName: provider,
 		sessionId: sessionAffinity ?? ""
 	});
@@ -6068,7 +6419,10 @@ const handleResponses = async (c) => {
 			for await (const chunk of response) {
 				debugJson(logger$1, "Responses stream chunk:", chunk);
 				const parsedEvent = parseResponsesStreamEvent(chunk);
-				if (parsedEvent?.type === "response.completed" || parsedEvent?.type === "response.failed" || parsedEvent?.type === "response.incomplete") usage = normalizeResponsesUsage(parsedEvent.response.usage);
+				if (parsedEvent?.type === "response.completed" || parsedEvent?.type === "response.failed" || parsedEvent?.type === "response.incomplete") usage = {
+					...normalizeResponsesUsage(parsedEvent.response.usage),
+					total_nano_aiu: normalizeOptionalToken(parsedEvent.copilot_usage?.total_nano_aiu)
+				};
 				const processedData = fixStreamIds(chunk.data ?? "", chunk.event, idTracker);
 				await stream.writeSSE({
 					id: chunk.id,
@@ -6083,8 +6437,12 @@ const handleResponses = async (c) => {
 		value: response,
 		tailLength: 400
 	});
-	recordUsage(normalizeResponsesUsage(response.usage));
-	return c.json(response);
+	const result = response;
+	recordUsage({
+		...normalizeResponsesUsage(result.usage),
+		total_nano_aiu: normalizeOptionalToken(result.copilot_usage?.total_nano_aiu)
+	});
+	return c.json(result);
 };
 const isAsyncIterable = (value) => Boolean(value) && typeof value[Symbol.asyncIterator] === "function";
 const isStreamingRequested = (payload) => Boolean(payload.stream);
@@ -6254,4 +6612,4 @@ server.route("/:provider/v1/models", providerModelRoutes);
 //#endregion
 export { server };
 
-//# sourceMappingURL=server-34rnRg4k.js.map
+//# sourceMappingURL=server-7U9OZLf0.js.map