@jeffreycao/copilot-api 1.12.9 → 1.13.1

package/dist/{server-34rnRg4k.js → server-s_0_JChu.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 { S as setModelMappings, a as getExtraPromptForModel, c as getModelResponsesApiCompactThreshold$1, d as getReasoningEffortForModel, f as getSmallModel, g as isResponsesApiWebSocketEnabled, h as isResponsesApiWebSearchEnabled, i as getConfig, l as getProviderConfig, m as isResponsesApiContextManagementEnabled, n as getAnthropicApiKey, o as getMessageApiWebSearchModel, p as isMessagesApiEnabled, r as getClaudeTokenMultiplier, s as getModelMappings, u as getRawProviderConfig, v as listEnabledProviders, w as PATHS, x as resolveMappedModel } from "./config-DODTXsGz.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-DigcCxDR.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)
@@ -1104,7 +1397,7 @@ async function forwardProviderModels(providerConfig, requestHeaders) {
 }
 //#endregion
 //#region src/routes/provider/chat-completions/handler.ts
-const logger$8 = createHandlerLogger("provider-chat-completions-handler");
+const logger$9 = createHandlerLogger("provider-chat-completions-handler");
 async function handleProviderChatCompletionsForProvider(c, options) {
 	const { payload, provider } = options;
 	const providerConfig = await resolveProviderConfig(provider);
@@ -1116,19 +1409,19 @@ async function handleProviderChatCompletionsForProvider(c, options) {
 	applyProviderModelDefaults(payload, modelConfig);
 	applyMissingExtraBody$1(payload, { extraBody: modelConfig?.extraBody });
 	applyProviderStreamOptions(payload);
-	debugJson(logger$8, "provider.chat_completions.request", {
+	debugJson(logger$9, "provider.chat_completions.request", {
 		payload,
 		provider
 	});
 	const upstreamResponse = await forwardProviderChatCompletions(providerConfig, payload, c.req.raw.headers);
 	if (!upstreamResponse.ok) {
-		logger$8.error("Failed to create provider chat completions", {
+		logger$9.error("Failed to create provider chat completions", {
 			provider,
 			statusCode: upstreamResponse.status
 		});
 		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,
@@ -1136,7 +1429,7 @@ async function handleProviderChatCompletionsForProvider(c, options) {
 	});
 	const responseBody = await upstreamResponse.clone().json();
 	recordUsage(normalizeOpenAIUsage(responseBody.usage));
-	debugJson(logger$8, "provider.chat_completions.response", responseBody);
+	debugJson(logger$9, "provider.chat_completions.response", responseBody);
 	return createProviderProxyResponse(upstreamResponse);
 }
 const applyProviderModelDefaults = (payload, modelConfig) => {
@@ -1154,18 +1447,20 @@ 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) => {
-	logger$8.debug("provider.chat_completions.streaming", { provider: options.provider });
+	logger$9.debug("provider.chat_completions.streaming", { provider: options.provider });
 	return streamSSE(c, async (stream) => {
 		let usage = {};
 		try {
 			for await (const chunk of events(upstreamResponse)) {
-				debugJson(logger$8, "provider.chat_completions.stream_chunk", chunk);
+				debugJson(logger$9, "provider.chat_completions.stream_chunk", chunk);
 				if (chunk.data && chunk.data !== "[DONE]") {
 					const parsedChunk = parseChatCompletionChunkData(chunk.data);
 					if (parsedChunk?.usage) usage = normalizeOpenAIUsage(parsedChunk.usage);
@@ -1292,7 +1587,7 @@ const createChatCompletions = async (payload, options) => {
 };
 //#endregion
 //#region src/routes/chat-completions/handler.ts
-const logger$7 = createHandlerLogger("chat-completions-handler");
+const logger$8 = createHandlerLogger("chat-completions-handler");
 async function handleCompletion$1(c) {
 	let payload = await c.req.json();
 	const requestedModel = payload.model;
@@ -1307,7 +1602,7 @@ async function handleCompletion$1(c) {
 		});
 	}
 	await checkRateLimit(state);
-	debugJson(logger$7, "Request payload:", payload);
+	debugJson(logger$8, "Request payload:", payload);
 	const selectedModel = state.models?.data.find((model) => model.id === payload.model);
 	if (state.manualApprove) await awaitApproval();
 	if (isNullish(payload.max_tokens) && isNullish(payload.max_completion_tokens)) {
@@ -1315,16 +1610,16 @@ async function handleCompletion$1(c) {
 			...payload,
 			max_tokens: selectedModel?.capabilities.limits.max_output_tokens
 		};
-		debugJson(logger$7, "Set max_tokens to:", payload.max_tokens);
+		debugJson(logger$8, "Set max_tokens to:", payload.max_tokens);
 	}
 	if (payload.model.includes("gpt")) {
 		if (isNullish(payload.max_completion_tokens)) payload.max_completion_tokens = payload.max_tokens;
 		delete payload.max_tokens;
 	}
 	const requestId = generateRequestIdFromPayload(payload);
-	logger$7.debug("Generated request ID:", requestId);
+	logger$8.debug("Generated request ID:", requestId);
 	const sessionId = getUUID(requestId);
-	logger$7.debug("Extracted session ID:", sessionId);
+	logger$8.debug("Extracted session ID:", sessionId);
 	const recordUsage = createCopilotTokenUsageRecorder({
 		endpoint: "chat_completions",
 		fallbackSessionId: sessionId,
@@ -1335,17 +1630,23 @@ async function handleCompletion$1(c) {
 		sessionId
 	});
 	if (isNonStreaming$1(response)) {
-		debugJson(logger$7, "Non-streaming response:", response);
-		recordUsage(normalizeOpenAIUsage(response.usage));
+		debugJson(logger$8, "Non-streaming response:", response);
+		recordUsage({
+			...normalizeOpenAIUsage(response.usage),
+			total_nano_aiu: normalizeOptionalToken(response.copilot_usage?.total_nano_aiu)
+		});
 		return c.json(response);
 	}
-	logger$7.debug("Streaming response");
+	logger$8.debug("Streaming response");
 	return streamSSE(c, async (stream) => {
 		let usage = {};
 		for await (const chunk of response) {
-			debugJson(logger$7, "Streaming chunk:", chunk);
+			debugJson(logger$8, "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);
@@ -2448,7 +2749,7 @@ const prepareMessagesApiPayload = (payload, selectedModel) => {
 };
 //#endregion
 //#region src/routes/provider/messages/count-tokens-handler.ts
-const logger$6 = createHandlerLogger("provider-count-tokens-handler");
+const logger$7 = createHandlerLogger("provider-count-tokens-handler");
 async function handleProviderCountTokens(c) {
 	const provider = c.req.param("provider");
 	return await handleProviderCountTokensForProvider(c, {
@@ -2471,7 +2772,7 @@ async function handleProviderCountTokensForProvider(c, options) {
 		toolContentSupportType: modelConfig?.toolContentSupportType ?? []
 	} : void 0), createFallbackModel(modelId));
 	const finalTokenCount = tokenCount.input + tokenCount.output;
-	logger$6.debug("provider.count_tokens.success", {
+	logger$7.debug("provider.count_tokens.success", {
 		provider,
 		model: anthropicPayload.model,
 		input_tokens: finalTokenCount
@@ -3608,9 +3909,9 @@ const mapResponsesUsage = (response) => {
 		...response.usage?.input_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: response.usage.input_tokens_details.cached_tokens }
 	};
 };
-const isRecord = (value) => typeof value === "object" && value !== null;
-const isResponseOutputText = (block) => isRecord(block) && "type" in block && block.type === "output_text";
-const isResponseOutputRefusal = (block) => isRecord(block) && "type" in block && block.type === "refusal";
+const isRecord$1 = (value) => typeof value === "object" && value !== null;
+const isResponseOutputText = (block) => isRecord$1(block) && "type" in block && block.type === "output_text";
+const isResponseOutputRefusal = (block) => isRecord$1(block) && "type" in block && block.type === "refusal";
 const convertToolResultContent = (content) => {
 	if (typeof content === "string") return content;
 	if (Array.isArray(content)) {
@@ -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({
@@ -4857,7 +5169,7 @@ function getModels() {
 }
 //#endregion
 //#region src/routes/provider/messages/handler.ts
-const logger$5 = createHandlerLogger("provider-messages-handler");
+const logger$6 = createHandlerLogger("provider-messages-handler");
 const OPENAI_COMPATIBLE_CONTEXT_CACHE_MARKER_LIMIT = 4;
 const OPENAI_COMPATIBLE_CONTEXT_CACHE_CONTROL = { type: "ephemeral" };
 const OPENAI_COMPATIBLE_CONTEXT_CACHE_ROLES = new Set([
@@ -4882,7 +5194,7 @@ async function handleProviderMessagesForProvider(c, options) {
 	} }, 404);
 	try {
 		const modelConfig = providerConfig.models?.[payload.model];
-		debugJson(logger$5, "provider.messages.request", {
+		debugJson(logger$6, "provider.messages.request", {
 			payload,
 			provider
 		});
@@ -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
@@ -4914,29 +5227,33 @@ async function handleProviderMessagesForProvider(c, options) {
 			});
 		}
 		applyMissingExtraBody(payload, { extraBody: modelConfig?.extraBody });
-		debugJson(logger$5, "Translated provider.messages.request", {
+		debugJson(logger$6, "Translated provider.messages.request", {
 			payload,
 			provider
 		});
 		const upstreamResponse = await forwardProviderMessages(providerConfig, payload, c.req.raw.headers);
 		if (!upstreamResponse.ok) {
-			logger$5.error("Failed to create responses", upstreamResponse);
+			logger$6.error("Failed to create responses", upstreamResponse);
 			throw new HTTPError("Failed to create responses", upstreamResponse);
 		}
 		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) {
-		logger$5.error("provider.messages.error", {
+		logger$6.error("provider.messages.error", {
 			provider,
 			error
 		});
@@ -4944,13 +5261,13 @@ 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;
 	applyResponsesApiContextManagement(responsesPayload, selectedModel?.capabilities.limits.max_prompt_tokens);
 	compactInputByLatestCompaction(responsesPayload);
-	debugJson(logger$5, "provider.messages.responses.web_search.request", {
+	debugJson(logger$6, "provider.messages.responses.web_search.request", {
 		payload: responsesPayload,
 		provider
 	});
@@ -4961,20 +5278,24 @@ const handleOpenAIResponsesProviderWebSearchMessages = async (c, options) => {
 				errorMessagePrefix: `${provider} web search responses stream`,
 				parseEvent: (data) => parseResponsesProviderStreamChunk(data, providerConfig),
 				upstreamResponse,
-				logger: logger$5
+				logger: logger$6
 			}),
+			modelConfig,
 			payload,
+			pricingCurrency: providerConfig.pricingCurrency,
 			provider
 		});
 		return respondWebSearchProviderMessagesJson(c, {
 			body: upstreamResponse,
+			modelConfig,
 			payload,
+			pricingCurrency: providerConfig.pricingCurrency,
 			provider
 		});
 	}
 	const upstreamResponse = await forwardProviderResponses(providerConfig, responsesPayload, c.req.raw.headers);
 	if (!upstreamResponse.ok) {
-		logger$5.error("Failed to create provider web search responses", {
+		logger$6.error("Failed to create provider web search responses", {
 			provider,
 			upstreamResponse
 		});
@@ -4985,24 +5306,28 @@ const handleOpenAIResponsesProviderWebSearchMessages = async (c, options) => {
 			errorMessagePrefix: `${provider} web search responses stream`,
 			parseEvent: (data) => parseResponsesProviderStreamChunk(data, providerConfig),
 			upstreamResponse: events(upstreamResponse),
-			logger: logger$5
+			logger: logger$6
 		}),
+		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);
 	compactInputByLatestCompaction(responsesPayload);
-	debugJson(logger$5, "provider.messages.responses.request", {
+	debugJson(logger$6, "provider.messages.responses.request", {
 		payload: responsesPayload,
 		provider
 	});
@@ -5010,33 +5335,41 @@ 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
 		});
 	}
 	const upstreamResponse = await forwardProviderResponses(providerConfig, responsesPayload, c.req.raw.headers);
 	if (!upstreamResponse.ok) {
-		logger$5.error("Failed to create provider responses", upstreamResponse);
+		logger$6.error("Failed to create provider responses", upstreamResponse);
 		throw new HTTPError("Failed to create provider responses", upstreamResponse);
 	}
 	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
 	});
@@ -5071,25 +5404,29 @@ const applyOpenAICompatibleExtraBodyThinkingBudget = (payload, options) => {
 const handleOpenAICompatibleProviderMessages = async (c, options) => {
 	const { modelConfig, payload, provider, providerConfig } = options;
 	const openAIPayload = createOpenAICompatiblePayload(payload, modelConfig);
-	debugJson(logger$5, "provider.messages.openai_compatible.request", {
+	debugJson(logger$6, "provider.messages.openai_compatible.request", {
 		payload: openAIPayload,
 		provider
 	});
 	const upstreamResponse = await forwardProviderChatCompletions(providerConfig, openAIPayload, c.req.raw.headers);
 	if (!upstreamResponse.ok) {
-		logger$5.error("Failed to create openai-compatible responses", upstreamResponse);
+		logger$6.error("Failed to create openai-compatible responses", upstreamResponse);
 		throw new HTTPError("Failed to create openai-compatible responses", upstreamResponse);
 	}
 	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,13 +5495,13 @@ const applyContextCacheControl = (message) => {
 const setContextCacheControl = (part) => {
 	part.cache_control = { ...OPENAI_COMPATIBLE_CONTEXT_CACHE_CONTROL };
 };
-const streamProviderMessages = ({ c, payload, provider, upstreamResponse }) => {
-	logger$5.debug("provider.messages.streaming");
-	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
+const streamProviderMessages = ({ c, modelConfig, payload, pricingCurrency, provider, upstreamResponse }) => {
+	logger$6.debug("provider.messages.streaming");
+	const recordUsage = createProviderMessagesUsageRecorder(payload, provider, modelConfig, pricingCurrency);
 	return streamSSE(c, async (stream) => {
 		let usage = {};
 		for await (const chunk of events(upstreamResponse)) {
-			logger$5.debug("provider.messages.raw_stream_event:", chunk.data);
+			logger$6.debug("provider.messages.raw_stream_event:", chunk.data);
 			const eventName = chunk.event;
 			if (eventName === "ping") {
 				await stream.writeSSE({
@@ -5189,9 +5526,9 @@ const streamProviderMessages = ({ c, payload, provider, upstreamResponse }) => {
 		recordUsage(usage);
 	});
 };
-const streamOpenAICompatibleProviderMessages = ({ c, payload, provider, upstreamResponse }) => {
-	logger$5.debug("provider.messages.openai_compatible.streaming");
-	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
+const streamOpenAICompatibleProviderMessages = ({ c, modelConfig, payload, pricingCurrency, provider, upstreamResponse }) => {
+	logger$6.debug("provider.messages.openai_compatible.streaming");
+	const recordUsage = createProviderMessagesUsageRecorder(payload, provider, modelConfig, pricingCurrency);
 	return streamSSE(c, async (stream) => {
 		let usage = {};
 		const streamState = {
@@ -5202,7 +5539,7 @@ const streamOpenAICompatibleProviderMessages = ({ c, payload, provider, upstream
 			thinkingBlockOpen: false
 		};
 		for await (const chunk of events(upstreamResponse)) {
-			logger$5.debug("provider.messages.openai_compatible.raw_stream_event:", chunk.data);
+			logger$6.debug("provider.messages.openai_compatible.raw_stream_event:", chunk.data);
 			if (chunk.event === "ping") {
 				await stream.writeSSE({
 					event: "ping",
@@ -5220,7 +5557,7 @@ const streamOpenAICompatibleProviderMessages = ({ c, payload, provider, upstream
 			const events = translateChunkToAnthropicEvents(parsed, streamState);
 			for (const event of events) {
 				const eventData = JSON.stringify(event);
-				debugLazy(logger$5, () => ["provider.messages.openai_compatible.translated_event:", eventData]);
+				debugLazy(logger$6, () => ["provider.messages.openai_compatible.translated_event:", eventData]);
 				await stream.writeSSE({
 					event: event.type,
 					data: eventData
@@ -5229,7 +5566,7 @@ const streamOpenAICompatibleProviderMessages = ({ c, payload, provider, upstream
 		}
 		for (const event of flushPendingAnthropicStreamEvents(streamState)) {
 			const eventData = JSON.stringify(event);
-			debugLazy(logger$5, () => ["provider.messages.openai_compatible.translated_event:", eventData]);
+			debugLazy(logger$6, () => ["provider.messages.openai_compatible.translated_event:", eventData]);
 			await stream.writeSSE({
 				event: event.type,
 				data: eventData
@@ -5238,14 +5575,14 @@ const streamOpenAICompatibleProviderMessages = ({ c, payload, provider, upstream
 		recordUsage(usage);
 	});
 };
-const streamResponsesProviderMessages = ({ c, payload, provider, providerConfig, upstreamResponse }) => {
-	logger$5.debug("provider.messages.responses.streaming", { provider });
-	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
+const streamResponsesProviderMessages = ({ c, modelConfig, payload, pricingCurrency, provider, providerConfig, upstreamResponse }) => {
+	logger$6.debug("provider.messages.responses.streaming", { provider });
+	const recordUsage = createProviderMessagesUsageRecorder(payload, provider, modelConfig, pricingCurrency);
 	return streamSSE(c, async (stream) => {
 		let usage = {};
 		const streamState = createResponsesStreamState({ toolSearchName: resolveBridgeToolSearchName(payload.tools) });
 		for await (const chunk of upstreamResponse) {
-			logger$5.debug("provider.messages.responses.raw_stream_event:", chunk.data);
+			logger$6.debug("provider.messages.responses.raw_stream_event:", chunk.data);
 			if (chunk.event === "ping") {
 				await stream.writeSSE({
 					event: "ping",
@@ -5263,7 +5600,7 @@ const streamResponsesProviderMessages = ({ c, payload, provider, providerConfig,
 			const events = translateResponsesStreamEvent(parsed, streamState);
 			for (const event of events) {
 				const eventData = JSON.stringify(event);
-				debugLazy(logger$5, () => ["provider.messages.responses.translated_event:", eventData]);
+				debugLazy(logger$6, () => ["provider.messages.responses.translated_event:", eventData]);
 				await stream.writeSSE({
 					event: event.type,
 					data: eventData
@@ -5287,7 +5624,7 @@ const parseOpenAICompatibleStreamChunk = (data) => {
 	try {
 		return JSON.parse(data);
 	} catch (error) {
-		logger$5.error("provider.messages.openai_compatible.parse_chunk_error", {
+		logger$6.error("provider.messages.openai_compatible.parse_chunk_error", {
 			data,
 			error
 		});
@@ -5300,7 +5637,7 @@ const parseResponsesProviderStreamChunk = (data, providerConfig) => {
 		if (providerConfig.name === "codex") logCodexRateLimitsEvent(parsed);
 		return parsed;
 	} catch (error) {
-		logger$5.error("provider.messages.responses.parse_chunk_error", {
+		logger$6.error("provider.messages.responses.parse_chunk_error", {
 			provider: providerConfig.name,
 			data,
 			error
@@ -5325,7 +5662,7 @@ const parseProviderStreamEvent = (data) => {
 			usage: {}
 		};
 	} catch (error) {
-		logger$5.error("provider.messages.streaming.adjust_tokens_error", {
+		logger$6.error("provider.messages.streaming.adjust_tokens_error", {
 			error,
 			originalData: data
 		});
@@ -5333,31 +5670,31 @@ const parseProviderStreamEvent = (data) => {
 	}
 };
 const respondProviderMessagesJson = (c, options) => {
-	const { body, payload, provider } = options;
-	createProviderMessagesUsageRecorder(payload, provider)(normalizeAnthropicUsage(body.usage));
-	debugJson(logger$5, "provider.messages.no_stream result:", body);
+	const { body, modelConfig, payload, pricingCurrency, provider } = options;
+	createProviderMessagesUsageRecorder(payload, provider, modelConfig, pricingCurrency)(normalizeAnthropicUsage(body.usage));
+	debugJson(logger$6, "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);
+	debugJson(logger$6, "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");
+	debugJson(logger$6, "provider.messages.responses.no_stream result:", anthropicResponse);
+	if (providerConfig.name === "codex") logger$6.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)`);
+	logger$6.debug(`provider.messages.responses.web_search: ${extract.queries.length} quer(y/ies), ${extract.sources.length} source(s)`);
 	if (!payload.stream) return c.json(response);
 	return streamSSE(c, async (stream) => {
 		for (const event of buildSyntheticStreamEvents(response)) await stream.writeSSE({
@@ -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);
 };
@@ -5650,7 +5999,7 @@ const parseAnthropicStreamEvent = (data) => {
 };
 //#endregion
 //#region src/routes/messages/handler.ts
-const logger$4 = createHandlerLogger("messages-handler");
+const logger$5 = createHandlerLogger("messages-handler");
 const messagesFlowHandlers = {
 	handleWithChatCompletions,
 	handleWithMessagesApi,
@@ -5662,7 +6011,7 @@ async function handleCompletion(c) {
 	anthropicPayload.model = resolveMappedModel(anthropicPayload.model);
 	if (anthropicPayload.model !== requestedModel) consola.debug(`Resolved model mapping: ${requestedModel} -> ${anthropicPayload.model}`);
 	const webSearchResult = await tryHandleWebSearch(c, anthropicPayload, {
-		logger: logger$4,
+		logger: logger$5,
 		forwardToProvider: (ctx, payload, provider) => handleProviderMessagesForProvider(ctx, {
 			payload,
 			provider
@@ -5677,19 +6026,19 @@ async function handleCompletion(c) {
 			provider: providerModelAlias.provider
 		});
 	}
-	debugJson(logger$4, "Anthropic request payload:", anthropicPayload);
+	debugJson(logger$5, "Anthropic request payload:", anthropicPayload);
 	normalizeSystemMessages(anthropicPayload);
 	await checkRateLimit(state);
 	sanitizeIdeTools(anthropicPayload);
 	const subagentMarker = parseSubagentMarkerFromFirstUser(anthropicPayload);
-	if (subagentMarker) debugJson(logger$4, "Detected Subagent marker:", subagentMarker);
+	if (subagentMarker) debugJson(logger$5, "Detected Subagent marker:", subagentMarker);
 	let sessionId = getRootSessionId(anthropicPayload, c);
 	const compactType = getCompactType(anthropicPayload);
 	const anthropicBeta = c.req.header("anthropic-beta");
-	logger$4.debug("Anthropic Beta header:", anthropicBeta);
+	logger$5.debug("Anthropic Beta header:", anthropicBeta);
 	const noTools = !anthropicPayload.tools || anthropicPayload.tools.length === 0;
 	if (anthropicBeta && noTools && compactType === 0) anthropicPayload.model = getSmallModel();
-	if (compactType) logger$4.debug("Compact request type:", compactType);
+	if (compactType) logger$5.debug("Compact request type:", compactType);
 	if (!state.tokenBasedBilling) {
 		const lastMessageCacheControl = getLastMessageContentCacheControl(anthropicPayload.messages.at(-1));
 		stripToolReferenceTurnBoundary(anthropicPayload);
@@ -5697,9 +6046,9 @@ async function handleCompletion(c) {
 		applyLastMessageCacheControl(anthropicPayload, lastMessageCacheControl);
 	}
 	const requestId = generateRequestIdFromPayload(anthropicPayload, sessionId);
-	logger$4.debug("Generated request ID:", requestId);
+	logger$5.debug("Generated request ID:", requestId);
 	if (!sessionId) sessionId = getUUID(requestId);
-	logger$4.debug("Extracted session ID:", sessionId);
+	logger$5.debug("Extracted session ID:", sessionId);
 	if (state.manualApprove) await awaitApproval();
 	const selectedModel = findEndpointModel(anthropicPayload.model);
 	anthropicPayload.model = selectedModel?.id ?? anthropicPayload.model;
@@ -5710,7 +6059,7 @@ async function handleCompletion(c) {
 		requestId,
 		sessionId,
 		compactType,
-		logger: logger$4
+		logger: logger$5
 	});
 	if (shouldUseResponsesApi(selectedModel, compactType)) return await messagesFlowHandlers.handleWithResponsesApi(c, anthropicPayload, {
 		subagentMarker,
@@ -5718,7 +6067,7 @@ async function handleCompletion(c) {
 		requestId,
 		sessionId,
 		compactType,
-		logger: logger$4
+		logger: logger$5
 	});
 	return await messagesFlowHandlers.handleWithChatCompletions(c, anthropicPayload, {
 		subagentMarker,
@@ -5726,7 +6075,7 @@ async function handleCompletion(c) {
 		requestId,
 		sessionId,
 		compactType,
-		logger: logger$4
+		logger: logger$5
 	});
 }
 const MESSAGES_ENDPOINT = "/v1/messages";
@@ -5757,24 +6106,89 @@ messageRoutes.post("/count_tokens", async (c) => {
 //#endregion
 //#region src/routes/models/route.ts
 const modelRoutes = new Hono();
-modelRoutes.get("/", async (c) => {
+const logger$4 = createHandlerLogger("models-handler");
+const EPOCH_ISO = (/* @__PURE__ */ new Date(0)).toISOString();
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeCopilotModel(model) {
+	const contextWindow = model.capabilities?.limits?.max_context_window_tokens ?? 0;
+	const clientId = toClientModelId(model.id);
+	return {
+		claude_model_id: contextWindow >= 1e6 ? `${clientId}[1m]` : clientId,
+		...model,
+		id: clientId,
+		object: "model",
+		type: "model",
+		created: 0,
+		created_at: EPOCH_ISO,
+		owned_by: model.vendor,
+		display_name: model.name
+	};
+}
+function getStringField(model, field) {
+	const value = model[field];
+	return typeof value === "string" && value.trim() ? value : void 0;
+}
+function normalizeProviderModel(provider, model) {
+	if (!isRecord(model)) return null;
+	const rawId = getStringField(model, "id");
+	if (!rawId) return null;
+	const id = `${provider}/${rawId}`;
+	const name = getStringField(model, "display_name") ?? getStringField(model, "name") ?? rawId;
+	const ownedBy = getStringField(model, "owned_by") ?? getStringField(model, "vendor") ?? provider;
+	return {
+		...model,
+		id,
+		object: getStringField(model, "object") ?? "model",
+		type: getStringField(model, "type") ?? "model",
+		created: typeof model.created === "number" ? model.created : 0,
+		created_at: getStringField(model, "created_at") ?? EPOCH_ISO,
+		owned_by: ownedBy,
+		display_name: name
+	};
+}
+async function getProviderModels(provider, requestHeaders) {
 	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);
-			return {
-				claude_model_id: contextWindow >= 1e6 ? `${clientId}[1m]` : clientId,
-				...model,
-				id: clientId,
-				object: "model",
-				type: "model",
-				created: 0,
-				created_at: (/* @__PURE__ */ new Date(0)).toISOString(),
-				owned_by: model.vendor,
-				display_name: model.name
-			};
+		const providerConfig = await resolveProviderConfig(provider);
+		if (!providerConfig) return [];
+		if (providerConfig.name === "codex") return getModels().data.map((model) => normalizeProviderModel(providerConfig.name, model)).filter((model) => model !== null);
+		const response = await forwardProviderModels(providerConfig, requestHeaders);
+		if (!response.ok) {
+			logger$4.warn("models.provider.skip_non_ok", {
+				provider,
+				statusCode: response.status
+			});
+			return [];
+		}
+		const body = await response.json();
+		if (!isRecord(body) || !Array.isArray(body.data)) {
+			logger$4.warn("models.provider.skip_invalid_body", { provider });
+			return [];
+		}
+		return body.data.map((model) => normalizeProviderModel(providerConfig.name, model)).filter((model) => model !== null);
+	} catch (error) {
+		logger$4.warn("models.provider.skip_error", {
+			provider,
+			error
 		});
+		return [];
+	}
+}
+async function getAggregatedModels(requestHeaders) {
+	const copilotModels = state.models?.data.map(normalizeCopilotModel) ?? [];
+	const providerModelsByProvider = await Promise.all(listEnabledProviders().map((provider) => getProviderModels(provider, requestHeaders)));
+	const models = [...copilotModels, ...providerModelsByProvider.flat()];
+	const seenModelIds = /* @__PURE__ */ new Set();
+	return models.filter((model) => {
+		if (seenModelIds.has(model.id)) return false;
+		seenModelIds.add(model.id);
+		return true;
+	});
+}
+modelRoutes.get("/", async (c) => {
+	try {
+		const models = await getAggregatedModels(c.req.raw.headers);
 		return c.json({
 			object: "list",
 			data: models,
@@ -5856,9 +6270,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 +6285,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 +6294,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 +6485,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 +6503,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 +6678,4 @@ server.route("/:provider/v1/models", providerModelRoutes);
 //#endregion
 export { server };
 
-//# sourceMappingURL=server-34rnRg4k.js.map
+//# sourceMappingURL=server-s_0_JChu.js.map