@jeffreycao/copilot-api 1.9.2 → 1.9.4

package/dist/{server-CA39Gy7x.js → server-D1nq9oGf.js}

@@ -1,12 +1,13 @@
 import { PATHS } from "./paths-Cla6y5eD.js";
-import { COMPACT_AUTO_CONTINUE, COMPACT_REQUEST, HTTPError, cacheModels, compactAutoContinuePromptStarts, compactMessageSections, compactSummaryPromptStart, compactSystemPromptStarts, compactTextOnlyGuard, copilotBaseUrl, copilotHeaders, forwardError, generateRequestIdFromPayload, getCopilotUsage, getRootSessionId, getUUID, isNullish, parseUserIdMetadata, prepareForCompact, prepareInteractionHeaders, prepareMessageProxyHeaders, requestContext, resolveTraceId, sleep, state } from "./utils-DG6CB51Z.js";
+import { COMPACT_AUTO_CONTINUE, COMPACT_REQUEST, HTTPError, cacheModels, compactAutoContinuePromptStarts, compactMessageSections, compactSummaryPromptStart, compactSystemPromptStarts, compactTextOnlyGuard, copilotBaseUrl, copilotHeaders, forwardError, generateRequestIdFromPayload, generateTraceId, getCopilotUsage, getRootSessionId, getUUID, isNullish, parseUserIdMetadata, prepareForCompact, prepareInteractionHeaders, prepareMessageProxyHeaders, requestContext, resolveTraceId as resolveTraceId$1, sleep, state } from "./utils-DEJvF68W.js";
 import { getAnthropicApiKey, getClaudeTokenMultiplier, getConfig, getExtraPromptForModel, getProviderConfig, getReasoningEffortForModel, getSmallModel, isMessagesApiEnabled, isResponsesApiContextManagementModel, isResponsesApiWebSearchEnabled } from "./config-BQvWqYh_.js";
 import consola from "consola";
+import fs from "node:fs/promises";
 import path from "node:path";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
-import fs, { readFileSync } from "node:fs";
+import fs$1, { readFileSync } from "node:fs";
 import { streamSSE } from "hono/streaming";
 import util from "node:util";
 import { events } from "fetch-event-stream";
@@ -59,7 +60,7 @@ function createAuthMiddleware(options = {}) {
 //#endregion
 //#region src/lib/trace.ts
 const traceIdMiddleware = async (c, next) => {
-	const traceId = resolveTraceId(c.req.header("x-trace-id"));
+	const traceId = resolveTraceId$1(c.req.header("x-trace-id"));
 	c.header("x-trace-id", traceId);
 	const context = {
 		traceId,
@@ -79,6 +80,58 @@ const awaitApproval = async () => {
 	if (!await consola.prompt(`Accept incoming request?`, { type: "confirm" })) throw new HTTPError("Request rejected", Response.json({ message: "Request rejected" }, { status: 403 }));
 };
 
+//#endregion
+//#region src/lib/process-cleanup.ts
+const cleanupHandlers = /* @__PURE__ */ new Set();
+let cleanupPromise = null;
+let cleanupState = "idle";
+let runtimeInitialized$1 = false;
+function initializeProcessCleanupRuntime() {
+	if (runtimeInitialized$1) return;
+	runtimeInitialized$1 = true;
+	process.once("beforeExit", () => {
+		runProcessCleanups();
+	});
+	process.once("exit", runProcessCleanupsSync);
+	process.once("SIGINT", () => {
+		shutdownProcess(0);
+	});
+	process.once("SIGTERM", () => {
+		shutdownProcess(0);
+	});
+}
+function runProcessCleanupsSync() {
+	if (cleanupState !== "idle") return;
+	cleanupState = "done";
+	for (const handler of Array.from(cleanupHandlers)) try {
+		handler();
+	} catch {}
+}
+async function runProcessCleanups() {
+	if (cleanupPromise) return cleanupPromise;
+	if (cleanupState === "done") return;
+	cleanupState = "running";
+	cleanupPromise = (async () => {
+		for (const handler of Array.from(cleanupHandlers)) await handler();
+		cleanupState = "done";
+	})();
+	return cleanupPromise;
+}
+async function shutdownProcess(exitCode) {
+	try {
+		await runProcessCleanups();
+	} finally {
+		process.exit(exitCode);
+	}
+}
+function registerProcessCleanup(handler) {
+	initializeProcessCleanupRuntime();
+	cleanupHandlers.add(handler);
+	return () => {
+		cleanupHandlers.delete(handler);
+	};
+}
+
 //#endregion
 //#region src/lib/logger.ts
 const LOG_RETENTION_MS = 10080 * 60 * 1e3;
@@ -92,22 +145,22 @@ let runtimeInitialized = false;
 let flushInterval;
 let cleanupInterval;
 const ensureLogDirectory = () => {
-	if (!fs.existsSync(LOG_DIR)) fs.mkdirSync(LOG_DIR, { recursive: true });
+	if (!fs$1.existsSync(LOG_DIR)) fs$1.mkdirSync(LOG_DIR, { recursive: true });
 };
 const cleanupOldLogs = () => {
-	if (!fs.existsSync(LOG_DIR)) return;
+	if (!fs$1.existsSync(LOG_DIR)) return;
 	const now = Date.now();
-	for (const entry of fs.readdirSync(LOG_DIR)) {
+	for (const entry of fs$1.readdirSync(LOG_DIR)) {
 		const filePath = path.join(LOG_DIR, entry);
 		let stats;
 		try {
-			stats = fs.statSync(filePath);
+			stats = fs$1.statSync(filePath);
 		} catch {
 			continue;
 		}
 		if (!stats.isFile()) continue;
 		if (now - stats.mtimeMs > LOG_RETENTION_MS) try {
-			fs.rmSync(filePath);
+			fs$1.rmSync(filePath);
 		} catch {
 			continue;
 		}
@@ -160,21 +213,13 @@ const initializeLoggerRuntime = () => {
 	maybeUnref(flushInterval);
 	cleanupInterval = setInterval(cleanupOldLogs, CLEANUP_INTERVAL_MS);
 	maybeUnref(cleanupInterval);
-	process.once("exit", cleanup);
-	process.once("SIGINT", () => {
-		cleanup();
-		process.exit(0);
-	});
-	process.once("SIGTERM", () => {
-		cleanup();
-		process.exit(0);
-	});
+	registerProcessCleanup(cleanup);
 };
 const getLogStream = (filePath) => {
 	initializeLoggerRuntime();
 	let stream = logStreams.get(filePath);
 	if (!stream || stream.destroyed) {
-		stream = fs.createWriteStream(filePath, { flags: "a" });
+		stream = fs$1.createWriteStream(filePath, { flags: "a" });
 		logStreams.set(filePath, stream);
 		stream.on("error", (error) => {
 			console.warn("Log stream error", error);
@@ -248,6 +293,550 @@ async function checkRateLimit(state$1) {
 	consola.info("Rate limit wait completed, proceeding with request");
 }
 
+//#endregion
+//#region src/lib/event-bus.ts
+var EventBus = class {
+	handlers = /* @__PURE__ */ new Map();
+	publish(name, event) {
+		const handlers = this.handlers.get(name);
+		if (!handlers) return;
+		for (const handler of Array.from(handlers)) handler(event);
+	}
+	subscribe(name, handler) {
+		let handlers = this.handlers.get(name);
+		if (!handlers) {
+			handlers = /* @__PURE__ */ new Set();
+			this.handlers.set(name, handlers);
+		}
+		const registeredHandler = handler;
+		handlers.add(registeredHandler);
+		return () => {
+			handlers.delete(registeredHandler);
+			if (handlers.size === 0) this.handlers.delete(name);
+		};
+	}
+};
+
+//#endregion
+//#region src/lib/sqlite.ts
+const MINIMUM_NODE_SQLITE_VERSION = "22.13.0";
+const isBunRuntime = () => Boolean(globalThis.Bun);
+function parseNodeVersion(version) {
+	return version.split(".", 3).map((part) => {
+		const parsed = Number.parseInt(part, 10);
+		return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
+	});
+}
+function isNodeSqliteSupportedVersion(version) {
+	const current = parseNodeVersion(version);
+	const minimum = parseNodeVersion(MINIMUM_NODE_SQLITE_VERSION);
+	for (const [index, minimumPart] of minimum.entries()) {
+		const currentPart = current[index] ?? 0;
+		if (currentPart > minimumPart) return true;
+		if (currentPart < minimumPart) return false;
+	}
+	return true;
+}
+function isSqliteRuntimeSupported(input = {}) {
+	if (input.isBun ?? isBunRuntime()) return true;
+	return isNodeSqliteSupportedVersion(input.nodeVersion ?? process.versions.node);
+}
+function getUnsupportedNodeSqliteMessage(nodeVersion) {
+	return `SQLite-backed token usage requires Bun or Node.js >= ${MINIMUM_NODE_SQLITE_VERSION}. Detected Node.js ${nodeVersion}. Upgrade Node.js or run the CLI with Bun, for example \`bunx --bun @jeffreycao/copilot-api@latest start\` or \`bun run start start\`.`;
+}
+var UnsupportedNodeSqliteRuntimeError = class extends Error {
+	constructor(nodeVersion, cause) {
+		super(getUnsupportedNodeSqliteMessage(nodeVersion), { cause });
+		this.name = "UnsupportedNodeSqliteRuntimeError";
+	}
+};
+async function openBunDatabase(dbPath) {
+	return new (await (import(["bun", "sqlite"].join(":")))).Database(dbPath);
+}
+async function loadNodeSqliteModule() {
+	const nodeVersion = process.versions.node;
+	if (!isNodeSqliteSupportedVersion(nodeVersion)) throw new UnsupportedNodeSqliteRuntimeError(nodeVersion);
+	const specifier = ["node", "sqlite"].join(":");
+	try {
+		return await import(specifier);
+	} catch (error) {
+		throw new UnsupportedNodeSqliteRuntimeError(nodeVersion, error);
+	}
+}
+async function openNodeDatabase(dbPath) {
+	return new (await (loadNodeSqliteModule())).DatabaseSync(dbPath);
+}
+async function openSqliteDatabase(dbPath) {
+	const dir = path.dirname(dbPath);
+	if (dbPath !== ":memory:" && dir !== ".") await fs.mkdir(dir, { recursive: true });
+	return isBunRuntime() ? openBunDatabase(dbPath) : openNodeDatabase(dbPath);
+}
+var SqliteDbStore = class {
+	dbPromise = null;
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	getDb() {
+		this.dbPromise ??= this.open();
+		return this.dbPromise;
+	}
+	async close(input) {
+		const currentDbPromise = this.dbPromise;
+		this.dbPromise = null;
+		if (!currentDbPromise) return;
+		const db = await currentDbPromise;
+		input?.beforeClose?.(db);
+		db.close?.();
+	}
+	async open() {
+		const db = await openSqliteDatabase(this.options.getPath());
+		this.options.initialize?.(db);
+		return db;
+	}
+};
+
+//#endregion
+//#region src/lib/token-usage/store.ts
+const DB_PATH_ENV = "COPILOT_API_SQLITE_DB_PATH";
+const DEFAULT_DB_FILENAME = "copilot-api.sqlite";
+let writeQueue = Promise.resolve();
+function getDbPath() {
+	return process.env[DB_PATH_ENV] ?? path.join(PATHS.APP_DIR, DEFAULT_DB_FILENAME);
+}
+const tokenUsageDbStore = new SqliteDbStore({
+	getPath: getDbPath,
+	initialize: initializeTokenUsageDb
+});
+function getDb() {
+	return tokenUsageDbStore.getDb();
+}
+function isTokenUsageStorageEnabled() {
+	return isSqliteRuntimeSupported();
+}
+function initializeTokenUsageDb(db) {
+	db.exec("PRAGMA journal_mode = WAL");
+	db.exec("PRAGMA busy_timeout = 5000");
+	db.exec(`
+    CREATE TABLE IF NOT EXISTS token_usage_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      created_at_ms INTEGER NOT NULL,
+      created_at_utc TEXT NOT NULL,
+      trace_id TEXT NOT NULL,
+      session_id TEXT NOT NULL DEFAULT '',
+      user_id TEXT NOT NULL DEFAULT '',
+      source TEXT NOT NULL,
+      endpoint TEXT NOT NULL,
+      provider_name TEXT,
+      model TEXT NOT NULL,
+      input_tokens INTEGER NOT NULL DEFAULT 0,
+      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
+    )
+  `);
+	ensureColumn(db, "user_id", "TEXT NOT NULL DEFAULT ''");
+	ensureColumn(db, "total_tokens", "INTEGER NOT NULL DEFAULT 0");
+	db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_token_usage_events_created_at_ms
+    ON token_usage_events(created_at_ms)
+  `);
+	db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_token_usage_events_model
+    ON token_usage_events(model)
+  `);
+	db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_token_usage_events_trace_id
+    ON token_usage_events(trace_id)
+  `);
+	db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_token_usage_events_session_id
+    ON token_usage_events(session_id)
+  `);
+	db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_token_usage_events_user_id
+    ON token_usage_events(user_id)
+  `);
+}
+function ensureColumn(db, name, definition) {
+	if (!db.prepare("PRAGMA table_info(token_usage_events)").all().some((row) => row.name === name)) db.exec(`ALTER TABLE token_usage_events ADD COLUMN ${name} ${definition}`);
+}
+function normalizeToken(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+	return Math.max(0, Math.floor(value));
+}
+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;
+}
+function resolveTotalTokens(input) {
+	const explicitTotal = normalizeOptionalToken(input.total_tokens);
+	if (explicitTotal !== void 0) return explicitTotal;
+	return normalizeToken(input.input_tokens) + normalizeToken(input.output_tokens) + normalizeToken(input.cache_read_input_tokens) + normalizeToken(input.cache_creation_input_tokens);
+}
+async function writeTokenUsageEvent(event) {
+	(await getDb()).prepare(`
+      INSERT INTO token_usage_events (
+        created_at_ms,
+        created_at_utc,
+        trace_id,
+        session_id,
+        user_id,
+        source,
+        endpoint,
+        provider_name,
+        model,
+        input_tokens,
+        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);
+}
+function enqueueTokenUsageWrite(event) {
+	if (!isTokenUsageStorageEnabled()) return;
+	writeQueue = writeQueue.then(() => writeTokenUsageEvent(event)).catch((error) => {
+		consola.warn("Failed to record token usage", error);
+	});
+}
+async function flushTokenUsageEvents() {
+	let currentQueue = writeQueue;
+	while (true) {
+		await currentQueue;
+		if (currentQueue === writeQueue) return;
+		currentQueue = writeQueue;
+	}
+}
+function getPeriodRange(period, now = /* @__PURE__ */ new Date()) {
+	const start = new Date(now);
+	switch (period) {
+		case "day":
+			start.setHours(0, 0, 0, 0);
+			break;
+		case "week": {
+			const daysSinceMonday = (start.getDay() + 6) % 7;
+			start.setDate(start.getDate() - daysSinceMonday);
+			start.setHours(0, 0, 0, 0);
+			break;
+		}
+		case "month":
+			start.setDate(1);
+			start.setHours(0, 0, 0, 0);
+			break;
+		default: break;
+	}
+	const end = new Date(start);
+	switch (period) {
+		case "day":
+			end.setDate(end.getDate() + 1);
+			break;
+		case "week":
+			end.setDate(end.getDate() + 7);
+			break;
+		case "month":
+			end.setMonth(end.getMonth() + 1);
+			break;
+		default: break;
+	}
+	return {
+		endMs: end.getTime(),
+		startMs: start.getTime()
+	};
+}
+function createEmptyTotals() {
+	return {
+		cache_creation_input_tokens: 0,
+		cache_read_input_tokens: 0,
+		input_tokens: 0,
+		output_tokens: 0,
+		request_count: 0,
+		total_tokens: 0
+	};
+}
+function createEmptySummary(period) {
+	const range = getPeriodRange(period);
+	return {
+		byModel: [],
+		period,
+		range: {
+			end_ms: range.endMs,
+			end_utc: new Date(range.endMs).toISOString(),
+			start_ms: range.startMs,
+			start_utc: new Date(range.startMs).toISOString()
+		},
+		totals: createEmptyTotals()
+	};
+}
+function createEmptyEventsPage(input) {
+	const range = getPeriodRange(input.period);
+	const page = Math.max(1, Math.floor(input.page));
+	const pageSize = Math.min(100, Math.max(1, Math.floor(input.pageSize)));
+	return {
+		items: [],
+		page,
+		page_size: pageSize,
+		period: input.period,
+		range: {
+			end_ms: range.endMs,
+			end_utc: new Date(range.endMs).toISOString(),
+			start_ms: range.startMs,
+			start_utc: new Date(range.startMs).toISOString()
+		},
+		total: 0,
+		total_pages: 1
+	};
+}
+function numberFromRow(row, key) {
+	const value = row?.[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function totalsFromRow(row) {
+	return {
+		cache_creation_input_tokens: numberFromRow(row, "cache_creation_input_tokens"),
+		cache_read_input_tokens: numberFromRow(row, "cache_read_input_tokens"),
+		input_tokens: numberFromRow(row, "input_tokens"),
+		output_tokens: numberFromRow(row, "output_tokens"),
+		request_count: numberFromRow(row, "request_count"),
+		total_tokens: numberFromRow(row, "total_tokens")
+	};
+}
+function stringFromRow(row, key) {
+	const value = row[key];
+	return typeof value === "string" ? value : "";
+}
+function nullableStringFromRow(row, key) {
+	const value = row[key];
+	return typeof value === "string" ? value : null;
+}
+function usageEventFromRow(row) {
+	return {
+		cache_creation_input_tokens: numberFromRow(row, "cache_creation_input_tokens"),
+		cache_read_input_tokens: numberFromRow(row, "cache_read_input_tokens"),
+		created_at_ms: numberFromRow(row, "created_at_ms"),
+		created_at_utc: stringFromRow(row, "created_at_utc"),
+		endpoint: stringFromRow(row, "endpoint"),
+		id: numberFromRow(row, "id"),
+		input_tokens: numberFromRow(row, "input_tokens"),
+		model: stringFromRow(row, "model") || "unknown",
+		output_tokens: numberFromRow(row, "output_tokens"),
+		provider_name: nullableStringFromRow(row, "provider_name"),
+		session_id: stringFromRow(row, "session_id"),
+		source: stringFromRow(row, "source"),
+		total_tokens: numberFromRow(row, "total_tokens"),
+		trace_id: stringFromRow(row, "trace_id"),
+		user_id: stringFromRow(row, "user_id")
+	};
+}
+async function getTokenUsageSummary(period) {
+	if (!isTokenUsageStorageEnabled()) return createEmptySummary(period);
+	await flushTokenUsageEvents();
+	const range = getPeriodRange(period);
+	const db = await getDb();
+	const totalsRow = db.prepare(`
+    SELECT
+      COUNT(*) AS request_count,
+      COALESCE(SUM(input_tokens), 0) AS input_tokens,
+      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,
+      COALESCE(SUM(total_tokens), 0) AS total_tokens
+    FROM token_usage_events
+    WHERE created_at_ms >= ? AND created_at_ms < ?
+  `).get(range.startMs, range.endMs);
+	return {
+		byModel: db.prepare(`
+    SELECT
+      model,
+      COUNT(*) AS request_count,
+      COALESCE(SUM(input_tokens), 0) AS input_tokens,
+      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,
+      COALESCE(SUM(total_tokens), 0) AS total_tokens
+    FROM token_usage_events
+    WHERE created_at_ms >= ? AND created_at_ms < ?
+    GROUP BY model
+    ORDER BY
+      total_tokens DESC,
+      model ASC
+  `).all(range.startMs, range.endMs).map((row) => ({
+			...totalsFromRow(row),
+			model: typeof row.model === "string" ? row.model : "unknown"
+		})),
+		period,
+		range: {
+			end_ms: range.endMs,
+			end_utc: new Date(range.endMs).toISOString(),
+			start_ms: range.startMs,
+			start_utc: new Date(range.startMs).toISOString()
+		},
+		totals: totalsFromRow(totalsRow)
+	};
+}
+async function getTokenUsageEventsPage(input) {
+	if (!isTokenUsageStorageEnabled()) return createEmptyEventsPage(input);
+	await flushTokenUsageEvents();
+	const range = getPeriodRange(input.period);
+	const page = Math.max(1, Math.floor(input.page));
+	const pageSize = Math.min(100, Math.max(1, Math.floor(input.pageSize)));
+	const offset = (page - 1) * pageSize;
+	const db = await getDb();
+	const totalRow = db.prepare(`
+    SELECT COUNT(*) AS total
+    FROM token_usage_events
+    WHERE created_at_ms >= ? AND created_at_ms < ?
+  `).get(range.startMs, range.endMs);
+	const rows = db.prepare(`
+    SELECT
+      id,
+      created_at_ms,
+      created_at_utc,
+      trace_id,
+      session_id,
+      user_id,
+      source,
+      endpoint,
+      provider_name,
+      model,
+      input_tokens,
+      output_tokens,
+      cache_read_input_tokens,
+      cache_creation_input_tokens,
+      total_tokens
+    FROM token_usage_events
+    WHERE created_at_ms >= ? AND created_at_ms < ?
+    ORDER BY created_at_ms DESC, id DESC
+    LIMIT ? OFFSET ?
+  `).all(range.startMs, range.endMs, pageSize, offset);
+	const total = numberFromRow(totalRow, "total");
+	return {
+		items: rows.map((row) => usageEventFromRow(row)),
+		page,
+		page_size: pageSize,
+		period: input.period,
+		range: {
+			end_ms: range.endMs,
+			end_utc: new Date(range.endMs).toISOString(),
+			start_ms: range.startMs,
+			start_utc: new Date(range.startMs).toISOString()
+		},
+		total,
+		total_pages: Math.max(1, Math.ceil(total / pageSize))
+	};
+}
+async function closeUsageStore() {
+	await flushTokenUsageEvents();
+	await tokenUsageDbStore.close({ beforeClose: (db) => {
+		try {
+			db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+		} catch {}
+	} });
+	writeQueue = Promise.resolve();
+}
+registerProcessCleanup(closeUsageStore);
+
+//#endregion
+//#region src/lib/token-usage/index.ts
+const tokenUsageEventBus = new EventBus();
+function resolveTraceId(traceId) {
+	return traceId?.trim() || requestContext.getStore()?.traceId || generateTraceId();
+}
+function resolveTokenUsageSessionId(sessionId, fallbackSessionId) {
+	return requestContext.getStore()?.sessionAffinity?.trim() || sessionId?.trim() || fallbackSessionId?.trim() || "";
+}
+function resolveUserId(input) {
+	if (input.source === "provider") return input.providerName?.trim() || "";
+	return state.userName?.trim() || "";
+}
+function toPersistedEvent(input) {
+	if (!hasAnyToken(input)) return null;
+	const now = /* @__PURE__ */ new Date();
+	return {
+		cache_creation_input_tokens: normalizeToken(input.cache_creation_input_tokens),
+		cache_read_input_tokens: normalizeToken(input.cache_read_input_tokens),
+		created_at_ms: now.getTime(),
+		created_at_utc: now.toISOString(),
+		endpoint: input.endpoint,
+		input_tokens: normalizeToken(input.input_tokens),
+		model: input.model.trim() || "unknown",
+		output_tokens: normalizeToken(input.output_tokens),
+		provider_name: input.providerName?.trim() || null,
+		session_id: resolveTokenUsageSessionId(input.sessionId, input.fallbackSessionId),
+		source: input.source,
+		total_tokens: resolveTotalTokens(input),
+		trace_id: resolveTraceId(input.traceId),
+		user_id: resolveUserId(input)
+	};
+}
+tokenUsageEventBus.subscribe("token_usage.recorded", enqueueTokenUsageWrite);
+function recordTokenUsageEvent(input) {
+	const event = toPersistedEvent(input);
+	if (!event) return;
+	tokenUsageEventBus.publish("token_usage.recorded", event);
+}
+function createTokenUsageRecorder(options) {
+	return (usage) => {
+		recordTokenUsageEvent({
+			...usage,
+			...options
+		});
+	};
+}
+function createCopilotTokenUsageRecorder(options) {
+	return createTokenUsageRecorder({
+		...options,
+		source: "copilot"
+	});
+}
+function createProviderTokenUsageRecorder(options) {
+	return createTokenUsageRecorder({
+		...options,
+		source: "provider"
+	});
+}
+function normalizeOpenAIUsage(usage) {
+	const cachedTokens = normalizeToken(usage?.prompt_tokens_details?.cached_tokens);
+	const promptTokens = normalizeToken(usage?.prompt_tokens);
+	return {
+		cache_read_input_tokens: cachedTokens,
+		input_tokens: Math.max(0, promptTokens - cachedTokens),
+		output_tokens: normalizeToken(usage?.completion_tokens),
+		total_tokens: normalizeOptionalToken(usage?.total_tokens)
+	};
+}
+function normalizeResponsesUsage(usage) {
+	const cachedTokens = normalizeToken(usage?.input_tokens_details?.cached_tokens);
+	const inputTokens = normalizeToken(usage?.input_tokens);
+	return {
+		cache_read_input_tokens: cachedTokens,
+		input_tokens: Math.max(0, inputTokens - cachedTokens),
+		output_tokens: normalizeToken(usage?.output_tokens),
+		total_tokens: normalizeOptionalToken(usage?.total_tokens)
+	};
+}
+function normalizeAnthropicUsage(usage) {
+	return {
+		cache_creation_input_tokens: normalizeOptionalToken(usage?.cache_creation_input_tokens),
+		cache_read_input_tokens: normalizeOptionalToken(usage?.cache_read_input_tokens),
+		input_tokens: normalizeOptionalToken(usage?.input_tokens),
+		output_tokens: normalizeOptionalToken(usage?.output_tokens),
+		total_tokens: normalizeOptionalToken(usage?.total_tokens)
+	};
+}
+function mergeAnthropicUsage(current, next) {
+	return {
+		cache_creation_input_tokens: next.cache_creation_input_tokens ?? current.cache_creation_input_tokens,
+		cache_read_input_tokens: next.cache_read_input_tokens ?? current.cache_read_input_tokens,
+		input_tokens: next.input_tokens ?? current.input_tokens,
+		output_tokens: next.output_tokens ?? current.output_tokens,
+		total_tokens: next.total_tokens ?? current.total_tokens
+	};
+}
+
 //#endregion
 //#region src/lib/copilot-rate-limit.ts
 const copilotRateLimitTypes = ["session", "weekly"];
@@ -352,23 +941,42 @@ async function handleCompletion$1(c) {
 	logger$6.debug("Generated request ID:", requestId);
 	const sessionId = getUUID(requestId);
 	logger$6.debug("Extracted session ID:", sessionId);
+	const recordUsage = createCopilotTokenUsageRecorder({
+		endpoint: "chat_completions",
+		fallbackSessionId: sessionId,
+		model: payload.model
+	});
 	const response = await createChatCompletions(payload, {
 		requestId,
 		sessionId
 	});
 	if (isNonStreaming$1(response)) {
 		debugJson(logger$6, "Non-streaming response:", response);
+		recordUsage(normalizeOpenAIUsage(response.usage));
 		return c.json(response);
 	}
 	logger$6.debug("Streaming response");
 	return streamSSE(c, async (stream) => {
+		let usage = {};
 		for await (const chunk of response) {
 			debugJson(logger$6, "Streaming chunk:", chunk);
+			const parsedChunk = parseChatCompletionChunk(chunk);
+			if (parsedChunk?.usage) usage = normalizeOpenAIUsage(parsedChunk.usage);
 			await stream.writeSSE(chunk);
 		}
+		recordUsage(usage);
 	});
 }
 const isNonStreaming$1 = (response) => Object.hasOwn(response, "choices");
+const parseChatCompletionChunk = (chunk) => {
+	const data = chunk.data;
+	if (!data || data === "[DONE]") return null;
+	try {
+		return JSON.parse(data);
+	} catch {
+		return null;
+	}
+};
 
 //#endregion
 //#region src/routes/chat-completions/route.ts
@@ -401,6 +1009,13 @@ embeddingRoutes.post("/", async (c) => {
 	try {
 		const paylod = await c.req.json();
 		const response = await createEmbeddings(paylod);
+		createCopilotTokenUsageRecorder({
+			endpoint: "embeddings",
+			model: paylod.model
+		})({
+			input_tokens: response.usage.prompt_tokens,
+			output_tokens: 0
+		});
 		return c.json(response);
 	} catch (error) {
 		return await forwardError(c, error);
@@ -2492,6 +3107,12 @@ function closeThinkingBlockIfOpen(state$1, events$1) {
 const handleWithChatCompletions = async (c, anthropicPayload, options) => {
 	const { logger: logger$7, subagentMarker, requestId, sessionId, compactType } = options;
 	const openAIPayload = translateToOpenAI(anthropicPayload);
+	const recordUsage = createCopilotUsageRecorder({
+		endpoint: "chat_completions",
+		fallbackSessionId: sessionId,
+		model: openAIPayload.model,
+		payload: anthropicPayload
+	});
 	debugJson(logger$7, "Translated OpenAI request payload:", openAIPayload);
 	const response = await createChatCompletions(openAIPayload, {
 		subagentMarker,
@@ -2501,12 +3122,14 @@ const handleWithChatCompletions = async (c, anthropicPayload, options) => {
 	});
 	if (isNonStreaming(response)) {
 		debugJson(logger$7, "Non-streaming response from Copilot:", response);
+		recordUsage(normalizeOpenAIUsage(response.usage));
 		const anthropicResponse = translateToAnthropic(response);
 		debugJson(logger$7, "Translated Anthropic response:", anthropicResponse);
 		return c.json(anthropicResponse);
 	}
 	logger$7.debug("Streaming response from Copilot");
 	return streamSSE(c, async (stream) => {
+		let usage = {};
 		const streamState = {
 			messageStartSent: false,
 			contentBlockIndex: 0,
@@ -2519,6 +3142,7 @@ 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);
 			const events$1 = translateChunkToAnthropicEvents(chunk, streamState);
 			for (const event of events$1) {
 				const eventData = JSON.stringify(event);
@@ -2529,11 +3153,18 @@ const handleWithChatCompletions = async (c, anthropicPayload, options) => {
 				});
 			}
 		}
+		recordUsage(usage);
 	});
 };
 const handleWithResponsesApi = async (c, anthropicPayload, options) => {
-	const { logger: logger$7, subagentMarker, selectedModel, requestId, sessionId, compactType } = options;
+	const { logger: logger$7, selectedModel,...requestOptions } = options;
 	const responsesPayload = translateAnthropicMessagesToResponsesPayload(anthropicPayload);
+	const recordUsage = createCopilotUsageRecorder({
+		endpoint: "responses",
+		fallbackSessionId: requestOptions.sessionId,
+		model: responsesPayload.model,
+		payload: anthropicPayload
+	});
 	applyResponsesApiContextManagement(responsesPayload, selectedModel?.capabilities.limits.max_prompt_tokens);
 	compactInputByLatestCompaction(responsesPayload);
 	debugJson(logger$7, "Translated Responses payload:", responsesPayload);
@@ -2541,15 +3172,13 @@ const handleWithResponsesApi = async (c, anthropicPayload, options) => {
 	const response = await createResponses(responsesPayload, {
 		vision,
 		initiator,
-		subagentMarker,
-		requestId,
-		sessionId,
-		compactType
+		...requestOptions
 	});
 	if (responsesPayload.stream && isAsyncIterable$1(response)) {
 		logger$7.debug("Streaming response from Copilot (Responses API)");
 		return streamSSE(c, async (stream) => {
 			const streamState = createResponsesStreamState();
+			let usage = {};
 			for await (const chunk of response) {
 				if (chunk.event === "ping") {
 					await stream.writeSSE({
@@ -2561,7 +3190,9 @@ const handleWithResponsesApi = async (c, anthropicPayload, options) => {
 				const data = chunk.data;
 				if (!data) continue;
 				debugLazy(logger$7, () => ["Responses raw stream event:", data]);
-				const events$1 = translateResponsesStreamEvent(JSON.parse(data), streamState);
+				const responseEvent = JSON.parse(data);
+				if (responseEvent.type === "response.completed" || responseEvent.type === "response.failed" || responseEvent.type === "response.incomplete") usage = normalizeResponsesUsage(responseEvent.response.usage);
+				const events$1 = translateResponsesStreamEvent(responseEvent, streamState);
 				for (const event of events$1) {
 					const eventData = JSON.stringify(event);
 					debugLazy(logger$7, () => ["Translated Anthropic event:", eventData]);
@@ -2583,6 +3214,7 @@ const handleWithResponsesApi = async (c, anthropicPayload, options) => {
 					data: JSON.stringify(errorEvent)
 				});
 			}
+			recordUsage(usage);
 		});
 	}
 	debugJsonTail(logger$7, "Non-streaming Responses result:", {
@@ -2590,12 +3222,19 @@ const handleWithResponsesApi = async (c, anthropicPayload, options) => {
 		tailLength: 400
 	});
 	const anthropicResponse = translateResponsesResultToAnthropic(response);
+	recordUsage(normalizeResponsesUsage(response.usage));
 	debugJson(logger$7, "Translated Anthropic response:", anthropicResponse);
 	return c.json(anthropicResponse);
 };
 const handleWithMessagesApi = async (c, anthropicPayload, options) => {
 	const { logger: logger$7, anthropicBetaHeader, subagentMarker, selectedModel, requestId, sessionId, compactType } = options;
 	prepareMessagesApiPayload(anthropicPayload, selectedModel);
+	const recordUsage = createCopilotUsageRecorder({
+		endpoint: "messages",
+		fallbackSessionId: sessionId,
+		model: anthropicPayload.model,
+		payload: anthropicPayload
+	});
 	debugJson(logger$7, "Translated Messages payload:", anthropicPayload);
 	const response = await createMessages(anthropicPayload, anthropicBetaHeader, {
 		subagentMarker,
@@ -2606,27 +3245,47 @@ const handleWithMessagesApi = async (c, anthropicPayload, options) => {
 	if (isAsyncIterable$1(response)) {
 		logger$7.debug("Streaming response from Copilot (Messages API)");
 		return streamSSE(c, async (stream) => {
+			let usage = {};
 			for await (const event of response) {
 				const eventName = event.event;
 				const data = event.data ?? "";
 				if (data === "[DONE]") break;
 				if (!data) continue;
 				debugLazy(logger$7, () => ["Messages raw stream event:", data]);
+				const parsedEvent = parseAnthropicStreamEvent(data);
+				if (parsedEvent?.type === "message_start") usage = mergeAnthropicUsage(usage, normalizeAnthropicUsage(parsedEvent.message.usage));
+				else if (parsedEvent?.type === "message_delta") usage = mergeAnthropicUsage(usage, normalizeAnthropicUsage(parsedEvent.usage));
 				await stream.writeSSE({
 					event: eventName,
 					data
 				});
 			}
+			recordUsage(usage);
 		});
 	}
 	debugJsonTail(logger$7, "Non-streaming Messages result:", {
 		value: response,
 		tailLength: 400
 	});
+	recordUsage(normalizeAnthropicUsage(response.usage));
 	return c.json(response);
 };
 const isNonStreaming = (response) => Object.hasOwn(response, "choices");
 const isAsyncIterable$1 = (value) => Boolean(value) && typeof value[Symbol.asyncIterator] === "function";
+const createCopilotUsageRecorder = (options) => createCopilotTokenUsageRecorder({
+	endpoint: options.endpoint,
+	fallbackSessionId: options.fallbackSessionId,
+	model: options.model,
+	sessionId: getMetadataSessionId(options.payload)
+});
+const getMetadataSessionId = (payload) => parseUserIdMetadata(payload.metadata?.user_id).sessionId;
+const parseAnthropicStreamEvent = (data) => {
+	try {
+		return JSON.parse(data);
+	} catch {
+		return null;
+	}
+};
 
 //#endregion
 //#region src/lib/subagent.ts
@@ -2916,44 +3575,20 @@ async function handleProviderMessages(c) {
 			throw new HTTPError("Failed to create responses", upstreamResponse);
 		}
 		const contentType = upstreamResponse.headers.get("content-type") ?? "";
-		if (Boolean(payload.stream) && contentType.includes("text/event-stream")) {
-			logger$3.debug("provider.messages.streaming");
-			return streamSSE(c, async (stream) => {
-				for await (const chunk of events(upstreamResponse)) {
-					logger$3.debug("provider.messages.raw_stream_event:", chunk.data);
-					const eventName = chunk.event;
-					if (eventName === "ping") {
-						await stream.writeSSE({
-							event: "ping",
-							data: "{\"type\":\"ping\"}"
-						});
-						continue;
-					}
-					let data = chunk.data;
-					if (!data) continue;
-					if (chunk.data === "[DONE]") break;
-					try {
-						const parsed = JSON.parse(data);
-						if (parsed.type === "message_start") adjustInputTokens(providerConfig, parsed.message.usage);
-						else if (parsed.type === "message_delta") adjustInputTokens(providerConfig, parsed.usage);
-						data = JSON.stringify(parsed);
-					} catch (error) {
-						logger$3.error("provider.messages.streaming.adjust_tokens_error", {
-							error,
-							originalData: data
-						});
-					}
-					await stream.writeSSE({
-						event: eventName,
-						data
-					});
-				}
-			});
-		}
+		if (Boolean(payload.stream) && contentType.includes("text/event-stream")) return streamProviderMessages({
+			c,
+			payload,
+			provider,
+			providerConfig,
+			upstreamResponse
+		});
 		const jsonBody = await upstreamResponse.json();
-		adjustInputTokens(providerConfig, jsonBody.usage);
-		debugJson(logger$3, "provider.messages.no_stream result:", jsonBody);
-		return c.json(jsonBody);
+		return respondProviderMessagesJson(c, {
+			body: jsonBody,
+			payload,
+			provider,
+			providerConfig
+		});
 	} catch (error) {
 		logger$3.error("provider.messages.error", {
 			provider,
@@ -2962,6 +3597,81 @@ async function handleProviderMessages(c) {
 		throw error;
 	}
 }
+const streamProviderMessages = ({ c, payload, provider, providerConfig, upstreamResponse }) => {
+	logger$3.debug("provider.messages.streaming");
+	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
+	return streamSSE(c, async (stream) => {
+		let usage = {};
+		for await (const chunk of events(upstreamResponse)) {
+			logger$3.debug("provider.messages.raw_stream_event:", chunk.data);
+			const eventName = chunk.event;
+			if (eventName === "ping") {
+				await stream.writeSSE({
+					event: "ping",
+					data: "{\"type\":\"ping\"}"
+				});
+				continue;
+			}
+			let data = chunk.data;
+			if (!data) continue;
+			if (chunk.data === "[DONE]") break;
+			const parsed = parseProviderStreamEvent(data, providerConfig);
+			if (parsed) {
+				usage = mergeAnthropicUsage(usage, parsed.usage);
+				data = parsed.data;
+			}
+			await stream.writeSSE({
+				event: eventName,
+				data
+			});
+		}
+		recordUsage(usage);
+	});
+};
+const parseProviderStreamEvent = (data, providerConfig) => {
+	try {
+		const parsed = JSON.parse(data);
+		if (parsed.type === "message_start") {
+			adjustInputTokens(providerConfig, parsed.message.usage);
+			return {
+				data: JSON.stringify(parsed),
+				model: parsed.message.model,
+				usage: normalizeAnthropicUsage(parsed.message.usage)
+			};
+		}
+		if (parsed.type === "message_delta") {
+			adjustInputTokens(providerConfig, parsed.usage);
+			return {
+				data: JSON.stringify(parsed),
+				usage: normalizeAnthropicUsage(parsed.usage)
+			};
+		}
+		return {
+			data: JSON.stringify(parsed),
+			usage: {}
+		};
+	} catch (error) {
+		logger$3.error("provider.messages.streaming.adjust_tokens_error", {
+			error,
+			originalData: data
+		});
+		return null;
+	}
+};
+const respondProviderMessagesJson = (c, options) => {
+	const { body, payload, provider, providerConfig } = options;
+	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
+	adjustInputTokens(providerConfig, body.usage);
+	recordUsage(normalizeAnthropicUsage(body.usage));
+	debugJson(logger$3, "provider.messages.no_stream result:", body);
+	return c.json(body);
+};
+const createProviderMessagesUsageRecorder = (payload, provider) => createProviderTokenUsageRecorder({
+	endpoint: "provider_messages",
+	model: payload.model,
+	providerName: provider,
+	sessionId: parseUserIdMetadata(payload.metadata?.user_id).sessionId
+});
 const adjustInputTokens = (providerConfig, usage) => {
 	if (!providerConfig.adjustInputTokens || !usage) return;
 	usage.input_tokens = Math.max(0, (usage.input_tokens ?? 0) - (usage.cache_read_input_tokens ?? 0) - (usage.cache_creation_input_tokens ?? 0));
@@ -3062,6 +3772,11 @@ const handleResponses = async (c) => {
 	logger$1.debug("Generated request ID:", requestId);
 	const sessionId = getUUID(requestId);
 	logger$1.debug("Extracted session ID:", sessionId);
+	const recordUsage = createCopilotTokenUsageRecorder({
+		endpoint: "responses",
+		fallbackSessionId: sessionId,
+		model: payload.model
+	});
 	useFunctionApplyPatch(payload);
 	removeUnsupportedTools(payload);
 	if (!isResponsesApiWebSearchEnabled()) removeWebSearchTool(payload);
@@ -3085,8 +3800,11 @@ const handleResponses = async (c) => {
 		logger$1.debug("Forwarding native Responses stream");
 		return streamSSE(c, async (stream) => {
 			const idTracker = createStreamIdTracker();
+			let usage = {};
 			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);
 				const processedData = fixStreamIds(chunk.data ?? "", chunk.event, idTracker);
 				await stream.writeSSE({
 					id: chunk.id,
@@ -3094,16 +3812,27 @@ const handleResponses = async (c) => {
 					data: processedData
 				});
 			}
+			recordUsage(usage);
 		});
 	}
 	debugJsonTail(logger$1, "Forwarding native Responses result:", {
 		value: response,
 		tailLength: 400
 	});
+	recordUsage(normalizeResponsesUsage(response.usage));
 	return c.json(response);
 };
 const isAsyncIterable = (value) => Boolean(value) && typeof value[Symbol.asyncIterator] === "function";
 const isStreamingRequested = (payload) => Boolean(payload.stream);
+const parseResponsesStreamEvent = (chunk) => {
+	const data = chunk.data;
+	if (!data || data === "[DONE]") return null;
+	try {
+		return JSON.parse(data);
+	} catch {
+		return null;
+	}
+};
 const useFunctionApplyPatch = (payload) => {
 	if (getConfig().useFunctionApplyPatch ?? true) {
 		logger$1.debug("Using function tool apply_patch for responses");
@@ -3161,6 +3890,39 @@ responsesRoutes.post("/", async (c) => {
 	}
 });
 
+//#endregion
+//#region src/routes/token-usage/route.ts
+const tokenUsageRoute = new Hono();
+const periods = new Set([
+	"day",
+	"week",
+	"month"
+]);
+const DEFAULT_EVENTS_PAGE_SIZE = 20;
+function parsePeriod(value) {
+	return periods.has(value) ? value : "day";
+}
+function parsePositiveInt(value, fallback) {
+	const parsed = Number.parseInt(value ?? "", 10);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+tokenUsageRoute.get("/", async (c) => {
+	const period = parsePeriod(c.req.query("period"));
+	const summary = await getTokenUsageSummary(period);
+	return c.json(summary);
+});
+tokenUsageRoute.get("/events", async (c) => {
+	const period = parsePeriod(c.req.query("period"));
+	const page = parsePositiveInt(c.req.query("page"), 1);
+	const pageSize = parsePositiveInt(c.req.query("page_size"), DEFAULT_EVENTS_PAGE_SIZE);
+	const eventsPage = await getTokenUsageEventsPage({
+		page,
+		pageSize,
+		period
+	});
+	return c.json(eventsPage);
+});
+
 //#endregion
 //#region src/routes/token/route.ts
 const tokenRoute = new Hono();
@@ -3210,6 +3972,7 @@ server.route("/chat/completions", completionRoutes);
 server.route("/models", modelRoutes);
 server.route("/embeddings", embeddingRoutes);
 server.route("/usage", usageRoute);
+server.route("/token-usage", tokenUsageRoute);
 server.route("/token", tokenRoute);
 server.route("/responses", responsesRoutes);
 server.route("/v1/chat/completions", completionRoutes);
@@ -3222,4 +3985,4 @@ server.route("/:provider/v1/models", providerModelRoutes);
 
 //#endregion
 export { server };
-//# sourceMappingURL=server-CA39Gy7x.js.map
+//# sourceMappingURL=server-D1nq9oGf.js.map