@nick3/copilot-api 1.3.3 → 1.3.8

package/dist/{server-BZhJgGbw.js → server-COWbIpDR.js}

@@ -1,13 +1,18 @@
-import { HTTPError, PATHS, accountFromState, accountsManager, copilotBaseUrl, copilotHeaders, forwardError, generateRequestIdFromPayload, getAliasTargetSet, getConfig, getCopilotUsage, getExtraPromptForModel, getModelAliases, getModelAliasesInfo, getModelRefreshIntervalMs, getProviderConfig, getReasoningEffortForModel, getRootSessionId, getSmallModel, getUUID, isForceAgentEnabled, isFreeModelLoadBalancingEnabled, isMessageStartInputTokensFallbackEnabled, isMessagesApiEnabled, isNullish, isResponsesApiContextManagementModel, listAccountsFromRegistry, mergeConfigWithDefaults, prepareInteractionHeaders, shouldCompactUseSmallModel, sleep, state } from "./accounts-manager-H7YGTVk8.js";
+import { PATHS } from "./paths-DoT4SZ8f.js";
+import { listAccountsFromRegistry } from "./accounts-registry-c7rs5Ed9.js";
+import { HTTPError, accountFromState, cacheModels, copilotBaseUrl, copilotHeaders, forwardError, generateRequestIdFromPayload, getCopilotUsage, getRootSessionId, getUUID, isNullish, prepareForCompact, prepareInteractionHeaders, sleep, state } from "./utils-BaoXuYkx.js";
+import "./get-copilot-token-CUT8hpgX.js";
+import { PROVIDER_TYPE_ANTHROPIC, accountsManager, getAliasTargetSet, getConfig, getExtraPromptForModel, getModelAliases, getModelAliasesInfo, getModelRefreshIntervalMs, getProviderConfig, getReasoningEffortForModel, getSmallModel, isForceAgentEnabled, isFreeModelLoadBalancingEnabled, isMessageStartInputTokensFallbackEnabled, isMessagesApiEnabled, isResponsesApiContextManagementModel, mergeConfigWithDefaults, shouldCompactUseSmallModel } from "./accounts-manager-BGBtDChT.js";
 import consola from "consola";
 import fs, { readFile } from "node:fs/promises";
 import * as path$1 from "node:path";
 import path from "node:path";
 import { randomUUID, timingSafeEqual } from "node:crypto";
-import fs$1, { existsSync } from "node:fs";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
+import fs$1, { existsSync } from "node:fs";
+import { AsyncLocalStorage } from "node:async_hooks";
 import { Database } from "bun:sqlite";
 import { fileURLToPath } from "node:url";
 import { streamSSE } from "hono/streaming";
@@ -100,6 +105,40 @@ function createAuthMiddleware(options = {}) {
 	};
 }
 
+//#endregion
+//#region src/lib/request-context.ts
+const TRACE_ID_MAX_LENGTH = 64;
+const TRACE_ID_PATTERN = /^\w[\w.-]*$/;
+const asyncLocalStorage = new AsyncLocalStorage();
+const requestContext = {
+	getStore: () => asyncLocalStorage.getStore(),
+	run: (context, callback) => asyncLocalStorage.run(context, callback)
+};
+function generateTraceId() {
+	const timestamp = Date.now().toString(36);
+	const random = Math.random().toString(36).slice(2, 8);
+	return `${timestamp}-${random}`;
+}
+function resolveTraceId(traceId) {
+	const candidate = traceId?.trim();
+	if (!candidate || candidate.length > TRACE_ID_MAX_LENGTH || !TRACE_ID_PATTERN.test(candidate)) return generateTraceId();
+	return candidate;
+}
+
+//#endregion
+//#region src/lib/trace.ts
+const traceIdMiddleware = async (c, next) => {
+	const traceId = resolveTraceId(c.req.header("x-trace-id"));
+	c.header("x-trace-id", traceId);
+	const context = {
+		traceId,
+		startTime: Date.now()
+	};
+	await requestContext.run(context, async () => {
+		await next();
+	});
+};
+
 //#endregion
 //#region src/lib/admin-db.ts
 const DEFAULT_DB_PATH = path.join(PATHS.APP_DIR, "admin.sqlite");
@@ -726,6 +765,8 @@ const CONFIG_KEYS = new Set([
 	"smallModel",
 	"freeModelLoadBalancing",
 	"apiKey",
+	"providers",
+	"responsesApiContextManagementModels",
 	"modelReasoningEfforts",
 	"modelAliases",
 	"allowOriginalModelNamesForAliases",
@@ -733,7 +774,8 @@ const CONFIG_KEYS = new Set([
 	"forceAgent",
 	"compactUseSmallModel",
 	"messageStartInputTokensFallback",
-	"modelRefreshIntervalHours"
+	"modelRefreshIntervalHours",
+	"useMessagesApi"
 ]);
 const REASONING_EFFORTS = new Set([
 	"none",
@@ -772,6 +814,18 @@ function parseOptionalNonNegativeNumber(value, field) {
 	if (!Number.isFinite(value) || value < 0) return { error: `${field} must be a non-negative number` };
 	return { value };
 }
+function parseOptionalStringArray(value, field) {
+	if (value === null || value === void 0) return { clear: true };
+	if (!Array.isArray(value)) return { error: `${field} must be an array of strings` };
+	const out = [];
+	for (const [index, entry] of value.entries()) {
+		if (typeof entry !== "string") return { error: `${field}[${index}] must be a string` };
+		const trimmed = entry.trim();
+		if (!trimmed) return { error: `${field}[${index}] must be a non-empty string` };
+		out.push(trimmed);
+	}
+	return { value: [...new Set(out)] };
+}
 function parseAuthConfig(value) {
 	if (value === null || value === void 0) return { clear: true };
 	if (!isPlainObject(value)) return { error: "auth must be an object" };
@@ -793,6 +847,142 @@ function parseStringRecord(value, field) {
 	}
 	return { value: record };
 }
+const PROVIDER_MODEL_CONFIG_KEYS = new Set([
+	"temperature",
+	"topP",
+	"topK"
+]);
+const PROVIDER_CONFIG_KEYS = new Set([
+	"type",
+	"enabled",
+	"baseUrl",
+	"apiKey",
+	"models"
+]);
+function validateAllowedObjectKeys(value, field, allowed) {
+	for (const key of Object.keys(value)) if (!allowed.has(key)) return `${field}.${key} is not supported`;
+}
+function applyProviderModelTemperature(config, value, field) {
+	if (!Object.hasOwn(value, "temperature")) return void 0;
+	const parsed = parseOptionalNonNegativeNumber(value.temperature, `${field}.temperature`);
+	if ("error" in parsed) return parsed.error;
+	if ("value" in parsed) config.temperature = parsed.value;
+}
+function applyProviderModelTopP(config, value, field) {
+	if (!Object.hasOwn(value, "topP")) return void 0;
+	const parsed = parseOptionalNonNegativeNumber(value.topP, `${field}.topP`);
+	if ("error" in parsed) return parsed.error;
+	if ("value" in parsed) config.topP = parsed.value;
+}
+function applyProviderModelTopK(config, value, field) {
+	if (!Object.hasOwn(value, "topK")) return void 0;
+	const parsed = parseOptionalNonNegativeNumber(value.topK, `${field}.topK`);
+	if ("error" in parsed) return parsed.error;
+	if ("value" in parsed) config.topK = parsed.value;
+}
+function parseProviderModelConfig(value, field) {
+	if (value === null || value === void 0) return { error: `${field} must be an object` };
+	if (!isPlainObject(value)) return { error: `${field} must be an object` };
+	const keyError = validateAllowedObjectKeys(value, field, PROVIDER_MODEL_CONFIG_KEYS);
+	if (keyError) return { error: keyError };
+	const config = {};
+	const temperatureError = applyProviderModelTemperature(config, value, field);
+	if (temperatureError) return { error: temperatureError };
+	const topPError = applyProviderModelTopP(config, value, field);
+	if (topPError) return { error: topPError };
+	const topKError = applyProviderModelTopK(config, value, field);
+	if (topKError) return { error: topKError };
+	return { value: config };
+}
+function parseProviderModelsRecord(value, field) {
+	if (value === null || value === void 0) return { clear: true };
+	if (!isPlainObject(value)) return { error: `${field} must be an object` };
+	const record = Object.create(null);
+	for (const [rawModelId, rawModelConfig] of Object.entries(value)) {
+		if (BLOCKED_KEYS.has(rawModelId)) return { error: `${field}.${rawModelId} is not allowed` };
+		const modelId = rawModelId.trim();
+		if (!modelId) return { error: `${field} keys must be non-empty strings` };
+		if (rawModelId !== modelId) return { error: `${field}.${rawModelId} must not include leading/trailing whitespace` };
+		if (BLOCKED_KEYS.has(modelId)) return { error: `${field}.${modelId} is not allowed` };
+		const parsed = parseProviderModelConfig(rawModelConfig, `${field}.${modelId}`);
+		if ("error" in parsed) return parsed;
+		if ("clear" in parsed) continue;
+		record[modelId] = parsed.value;
+	}
+	return { value: record };
+}
+function applyProviderType(provider, value, field) {
+	if (!Object.hasOwn(value, "type")) return void 0;
+	const parsed = parseOptionalString(value.type, `${field}.type`);
+	if ("error" in parsed) return parsed.error;
+	if ("value" in parsed) {
+		if (parsed.value !== PROVIDER_TYPE_ANTHROPIC) return `${field}.type must be "${PROVIDER_TYPE_ANTHROPIC}"`;
+		provider.type = PROVIDER_TYPE_ANTHROPIC;
+	}
+}
+function applyProviderEnabled(provider, value, field) {
+	if (!Object.hasOwn(value, "enabled")) return void 0;
+	const parsed = parseOptionalBoolean(value.enabled, `${field}.enabled`);
+	if ("error" in parsed) return parsed.error;
+	if ("value" in parsed) provider.enabled = parsed.value;
+}
+function applyProviderBaseUrl(provider, value, field) {
+	if (!Object.hasOwn(value, "baseUrl")) return void 0;
+	const parsed = parseOptionalString(value.baseUrl, `${field}.baseUrl`);
+	if ("error" in parsed) return parsed.error;
+	if ("value" in parsed) provider.baseUrl = parsed.value;
+}
+function applyProviderApiKey(provider, value, field) {
+	if (!Object.hasOwn(value, "apiKey")) return void 0;
+	const parsed = parseOptionalString(value.apiKey, `${field}.apiKey`);
+	if ("error" in parsed) return parsed.error;
+	if ("value" in parsed) provider.apiKey = parsed.value;
+}
+function applyProviderModels(provider, value, field) {
+	if (!Object.hasOwn(value, "models")) return void 0;
+	const parsed = parseProviderModelsRecord(value.models, `${field}.models`);
+	if ("error" in parsed) return parsed.error;
+	if ("value" in parsed) provider.models = parsed.value;
+}
+function parseProviderConfig(value, field) {
+	if (value === null || value === void 0) return { error: `${field} must be an object` };
+	if (!isPlainObject(value)) return { error: `${field} must be an object` };
+	const keyError = validateAllowedObjectKeys(value, field, PROVIDER_CONFIG_KEYS);
+	if (keyError) return { error: keyError };
+	const provider = {};
+	const typeError = applyProviderType(provider, value, field);
+	if (typeError) return { error: typeError };
+	const enabledError = applyProviderEnabled(provider, value, field);
+	if (enabledError) return { error: enabledError };
+	const baseUrlError = applyProviderBaseUrl(provider, value, field);
+	if (baseUrlError) return { error: baseUrlError };
+	const apiKeyError = applyProviderApiKey(provider, value, field);
+	if (apiKeyError) return { error: apiKeyError };
+	const modelsError = applyProviderModels(provider, value, field);
+	if (modelsError) return { error: modelsError };
+	return { value: provider };
+}
+function parseProviders(value) {
+	if (value === null || value === void 0) return { clear: true };
+	if (!isPlainObject(value)) return { error: "providers must be an object" };
+	const record = Object.create(null);
+	const seenProviderNames = /* @__PURE__ */ new Set();
+	for (const [rawProviderName, rawProviderConfig] of Object.entries(value)) {
+		if (BLOCKED_KEYS.has(rawProviderName)) return { error: `providers.${rawProviderName} is not allowed` };
+		const providerName = rawProviderName.trim();
+		if (!providerName) return { error: "providers keys must be non-empty strings" };
+		if (rawProviderName !== providerName) return { error: `providers.${rawProviderName} must not include leading/trailing whitespace` };
+		if (BLOCKED_KEYS.has(providerName)) return { error: `providers.${providerName} is not allowed` };
+		const normalizedProviderName = providerName.toLowerCase();
+		if (seenProviderNames.has(normalizedProviderName)) return { error: `providers.${rawProviderName} conflicts with another provider` };
+		seenProviderNames.add(normalizedProviderName);
+		const parsed = parseProviderConfig(rawProviderConfig, `providers.${providerName}`);
+		if ("error" in parsed) return parsed;
+		if ("clear" in parsed) continue;
+		record[providerName] = parsed.value;
+	}
+	return { value: record };
+}
 function parseReasoningRecord(value) {
 	if (value === null || value === void 0) return { clear: true };
 	if (!isPlainObject(value)) return { error: "modelReasoningEfforts must be an object" };
@@ -911,12 +1101,32 @@ function applyModelAliases(next, value) {
 	}
 	next.modelAliases = parsed.value;
 }
+function applyResponsesApiContextManagementModels(next, value) {
+	const parsed = parseOptionalStringArray(value, "responsesApiContextManagementModels");
+	if ("error" in parsed) return parsed.error;
+	if ("clear" in parsed) {
+		delete next.responsesApiContextManagementModels;
+		return;
+	}
+	next.responsesApiContextManagementModels = parsed.value;
+}
+function applyProvidersConfig(next, value) {
+	const parsed = parseProviders(value);
+	if ("error" in parsed) return parsed.error;
+	if ("clear" in parsed) {
+		delete next.providers;
+		return;
+	}
+	next.providers = parsed.value;
+}
 const CONFIG_PATCH_HANDLERS = {
 	auth: applyAuthConfig,
 	extraPrompts: applyExtraPrompts,
 	smallModel: (next, value) => applyOptionalString(next, "smallModel", value),
 	freeModelLoadBalancing: (next, value) => applyOptionalBoolean(next, "freeModelLoadBalancing", value),
 	apiKey: (next, value) => applyOptionalString(next, "apiKey", value),
+	providers: applyProvidersConfig,
+	responsesApiContextManagementModels: applyResponsesApiContextManagementModels,
 	modelReasoningEfforts: applyReasoningEfforts,
 	modelAliases: applyModelAliases,
 	allowOriginalModelNamesForAliases: (next, value) => applyOptionalBoolean(next, "allowOriginalModelNamesForAliases", value),
@@ -924,7 +1134,8 @@ const CONFIG_PATCH_HANDLERS = {
 	forceAgent: (next, value) => applyOptionalBoolean(next, "forceAgent", value),
 	compactUseSmallModel: (next, value) => applyOptionalBoolean(next, "compactUseSmallModel", value),
 	messageStartInputTokensFallback: (next, value) => applyOptionalBoolean(next, "messageStartInputTokensFallback", value),
-	modelRefreshIntervalHours: (next, value) => applyOptionalNumber(next, "modelRefreshIntervalHours", value)
+	modelRefreshIntervalHours: (next, value) => applyOptionalNumber(next, "modelRefreshIntervalHours", value),
+	useMessagesApi: (next, value) => applyOptionalBoolean(next, "useMessagesApi", value)
 };
 function applyConfigPatch(base, input) {
 	const next = { ...base };
@@ -1972,12 +2183,14 @@ const createHandlerLogger = (name) => {
 			cleanupOldLogs();
 			lastCleanup = Date.now();
 		}
+		const traceId = requestContext.getStore()?.traceId;
 		const date = logObj.date;
 		const dateKey = date.toLocaleDateString("sv-SE");
 		const timestamp = date.toLocaleString("sv-SE", { hour12: false });
 		const filePath = path.join(LOG_DIR, `${sanitizedName}-${dateKey}.log`);
 		const message = formatArgs(logObj.args);
-		const line = `[${timestamp}] [${logObj.type}] [${logObj.tag || name}]${message ? ` ${message}` : ""}`;
+		const traceIdStr = traceId ? ` [${traceId}]` : "";
+		const line = `[${timestamp}] [${logObj.type}] [${logObj.tag || name}]${traceIdStr}${message ? ` ${message}` : ""}`;
 		appendLine(filePath, line);
 	} });
 	return instance;
@@ -2227,7 +2440,7 @@ const getTokenCount = async (payload, model) => {
 
 //#endregion
 //#region src/services/copilot/create-responses.ts
-const createResponses = async (payload, { vision, initiator, upstreamRequestId, subagentMarker, sessionId }, account) => {
+const createResponses = async (payload, { vision, initiator, upstreamRequestId, subagentMarker, sessionId, isCompact }, account) => {
 	const ctx = account ?? accountFromState();
 	if (!ctx.copilotToken) throw new Error("Copilot token not found");
 	const headers = {
@@ -2235,6 +2448,7 @@ const createResponses = async (payload, { vision, initiator, upstreamRequestId,
 		"x-initiator": initiator
 	};
 	prepareInteractionHeaders(sessionId, Boolean(subagentMarker), headers);
+	prepareForCompact(headers, isCompact);
 	payload.service_tier = null;
 	const response = await fetch(`${copilotBaseUrl(ctx)}/responses`, {
 		method: "POST",
@@ -2716,6 +2930,7 @@ const createChatCompletions = async (payload, account, options) => {
 	};
 	prepareInteractionHeaders(options?.sessionId, Boolean(options?.subagentMarker), headers);
 	const upstreamPayload = applyDefaultReasoningEffort(payload);
+	prepareForCompact(headers, options?.isCompact);
 	const response = await fetch(`${copilotBaseUrl(ctx)}/chat/completions`, {
 		method: "POST",
 		headers,
@@ -4265,6 +4480,7 @@ const createMessages = async (payload, account, options) => {
 		"x-initiator": options?.subagentMarker ? "agent" : initiator
 	};
 	prepareInteractionHeaders(options?.sessionId, Boolean(options?.subagentMarker), headers);
+	prepareForCompact(headers, options?.isCompact);
 	const anthropicBeta = buildAnthropicBetaHeader(options?.anthropicBetaHeader, payload.thinking);
 	if (anthropicBeta) headers["anthropic-beta"] = anthropicBeta;
 	const response = await fetch(`${copilotBaseUrl(ctx)}/v1/messages`, {
@@ -4711,7 +4927,8 @@ async function handleCompletion(c) {
 		subagentMarker,
 		sessionId,
 		instr,
-		selectedModel
+		selectedModel,
+		isCompact
 	});
 	if (endpoint === RESPONSES_ENDPOINT$1) return await handleWithResponsesApi({
 		c,
@@ -4721,7 +4938,8 @@ async function handleCompletion(c) {
 		subagentMarker,
 		sessionId,
 		selectedModel,
-		instr
+		instr,
+		isCompact
 	});
 	return await handleWithChatCompletions({
 		c,
@@ -4730,11 +4948,12 @@ async function handleCompletion(c) {
 		subagentMarker,
 		sessionId,
 		selectedModel,
-		instr
+		instr,
+		isCompact
 	});
 }
 const handleWithChatCompletions = async (params) => {
-	const { c, openAIPayload, initiatorOverride, subagentMarker, sessionId, selectedModel, instr } = params;
+	const { c, openAIPayload, initiatorOverride, subagentMarker, sessionId, selectedModel, instr, isCompact } = params;
 	logger$5.debug("Translated OpenAI request payload:", JSON.stringify(openAIPayload));
 	const ctx = toAccountContext(instr.account);
 	const initiator = initiatorOverride ?? getChatInitiator(openAIPayload.messages);
@@ -4745,7 +4964,8 @@ const handleWithChatCompletions = async (params) => {
 			upstreamRequestId: instr.upstreamRequestId,
 			initiator,
 			subagentMarker,
-			sessionId
+			sessionId,
+			isCompact
 		});
 	} catch (error) {
 		return await handleChatCompletionsCreateError({
@@ -4776,7 +4996,7 @@ const handleWithChatCompletions = async (params) => {
 	}));
 };
 const handleWithResponsesApi = async (params) => {
-	const { c, anthropicPayload, openAIPayload, initiatorOverride, subagentMarker, sessionId, selectedModel, instr } = params;
+	const { c, anthropicPayload, openAIPayload, initiatorOverride, subagentMarker, sessionId, selectedModel, instr, isCompact } = params;
 	const responsesPayload = translateAnthropicMessagesToResponsesPayload(anthropicPayload, selectedModel.id);
 	applyResponsesApiContextManagement(responsesPayload, selectedModel.capabilities.limits.max_prompt_tokens);
 	compactInputByLatestCompaction(responsesPayload);
@@ -4792,7 +5012,8 @@ const handleWithResponsesApi = async (params) => {
 			initiator: resolvedInitiator,
 			upstreamRequestId: instr.upstreamRequestId,
 			subagentMarker,
-			sessionId
+			sessionId,
+			isCompact
 		}, ctx);
 	} catch (error) {
 		return await handleResponsesCreateError({
@@ -5243,7 +5464,7 @@ async function streamMessagesAndLog(params) {
 	}
 }
 const handleWithMessagesApi = async (params) => {
-	const { c, anthropicPayload, anthropicBetaHeader, initiatorOverride, subagentMarker, sessionId, instr, selectedModel } = params;
+	const { c, anthropicPayload, anthropicBetaHeader, initiatorOverride, subagentMarker, sessionId, instr, selectedModel, isCompact } = params;
 	for (const msg of anthropicPayload.messages) if (msg.role === "assistant" && Array.isArray(msg.content)) msg.content = msg.content.filter((block) => {
 		if (block.type !== "thinking") return true;
 		return block.thinking && block.thinking !== "Thinking..." && block.signature && !block.signature.includes("@");
@@ -5267,7 +5488,8 @@ const handleWithMessagesApi = async (params) => {
 			upstreamRequestId: instr.upstreamRequestId,
 			initiator,
 			subagentMarker,
-			sessionId
+			sessionId,
+			isCompact
 		});
 	} catch (error) {
 		return await handleMessagesCreateError({
@@ -5328,9 +5550,9 @@ messageRoutes.post("/count_tokens", async (c) => {
 const modelRoutes = new Hono();
 modelRoutes.get("/", async (c) => {
 	try {
-		const accountModels = accountsManager.getFirstAccountModels();
+		if (!state.models) await cacheModels();
 		const blockedTargets = getAliasTargetSet();
-		const models = accountModels?.data.filter((model) => !blockedTargets.has(model.id.toLowerCase())).map((model) => ({
+		const models = state.models?.data.filter((model) => !blockedTargets.has(model.id.toLowerCase())).map((model) => ({
 			id: model.id,
 			object: "model",
 			type: "model",
@@ -5489,14 +5711,37 @@ async function handleProviderMessages(c) {
 			provider
 		}));
 		const upstreamResponse = await forwardProviderMessages(providerConfig, payload, c.req.raw.headers);
+		if (!upstreamResponse.ok) {
+			logger$3.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")) {
 			logger$3.debug("provider.messages.streaming");
 			return streamSSE(c, async (stream) => {
-				for await (const event of events(upstreamResponse)) {
-					const eventName = event.event;
-					const data = event.data ?? "";
-					logger$3.debug("provider.messages.raw_stream_event", data);
+				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;
+					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
@@ -5504,7 +5749,10 @@ async function handleProviderMessages(c) {
 				}
 			});
 		}
-		return createProviderProxyResponse(upstreamResponse);
+		const jsonBody = await upstreamResponse.json();
+		adjustInputTokens(providerConfig, jsonBody.usage);
+		logger$3.debug("provider.messages.no_stream result:", JSON.stringify(jsonBody));
+		return c.json(jsonBody);
 	} catch (error) {
 		logger$3.error("provider.messages.error", {
 			provider,
@@ -5513,6 +5761,11 @@ async function handleProviderMessages(c) {
 		throw error;
 	}
 }
+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));
+	logger$3.debug("provider.messages.adjusted_usage:", JSON.stringify(usage));
+};
 
 //#endregion
 //#region src/routes/provider/messages/route.ts
@@ -6119,6 +6372,7 @@ usageRoute.get("/:accountIndex", async (c) => {
 //#endregion
 //#region src/server.ts
 const server = new Hono();
+server.use(traceIdMiddleware);
 server.use(logger());
 server.use(cors());
 server.use("*", createAuthMiddleware({
@@ -6144,4 +6398,4 @@ server.route("/:provider/v1/models", providerModelRoutes);
 
 //#endregion
 export { server };
-//# sourceMappingURL=server-BZhJgGbw.js.map
+//# sourceMappingURL=server-COWbIpDR.js.map