proxitor 0.6.2 → 0.8.0

package/README.md

@@ -256,6 +256,24 @@ provider:
 curl http://localhost:8828/health
 ```
 
+### Cache usage logging
+
+Proxitor automatically logs cache token usage from upstream responses — both non-streaming JSON and streaming SSE. No configuration needed.
+
+```
+[abc123] Cache read: 50000, write: 25000 tokens
+[def456] Cache: no cached tokens
+```
+
+Supports both provider formats:
+
+| Provider format | Fields |
+|---|---|
+| Anthropic | `usage.cache_read_input_tokens` / `usage.cache_creation_input_tokens` |
+| OpenAI / OpenRouter | `usage.prompt_tokens_details.cached_tokens` / `cache_write_tokens` |
+
+When both formats are present (e.g., OpenRouter relaying an Anthropic response), Anthropic fields take priority.
+
 ---
 
 ## Interactive Config Manager

package/dist/cli.mjs

@@ -10594,7 +10594,7 @@ const proxyConfigSchema = object({
 	verbose: boolean().default(false),
 	bodyLimit: string$1().min(1).default("50mb"),
 	provider: providerConfigSchema.optional(),
-	attributionReferer: string$1().min(1).default("http://localhost"),
+	attributionReferer: string$1().min(1).default("https://github.com/neiromaster/proxitor"),
 	attributionTitle: string$1().min(1).default("proxitor"),
 	headers: record(string$1(), string$1()).optional(),
 	modelOverrides: record(string$1().min(1), modelOverrideSchema).optional()
@@ -14626,7 +14626,7 @@ function buildRequestHeaders(incoming, config, inject, extraHeaders) {
 	const headers = filterHeaders(incoming, STRIP_REQUEST);
 	headers.Authorization = formatAuthHeader(config.openrouterKey, config.authType);
 	headers["HTTP-Referer"] = config.attributionReferer;
-	headers["X-Title"] = config.attributionTitle;
+	headers["X-OpenRouter-Title"] = config.attributionTitle;
 	headers["Accept-Encoding"] = "identity";
 	if (extraHeaders) Object.assign(headers, extraHeaders);
 	if (inject) headers["Content-Type"] = "application/json";
@@ -14640,6 +14640,120 @@ function buildResponseHeaders(from) {
 	return headers;
 }
 //#endregion
+//#region src/proxy/cache-logging.ts
+function extractCacheUsage(bodyText) {
+	try {
+		const parsed = JSON.parse(bodyText);
+		if (typeof parsed !== "object" || parsed === null) return void 0;
+		const usage = parsed.usage;
+		if (typeof usage !== "object" || usage === null) return void 0;
+		const result = {
+			cacheRead: 0,
+			cacheCreate: 0
+		};
+		if (typeof usage.cache_read_input_tokens === "number") result.cacheRead = usage.cache_read_input_tokens;
+		if (typeof usage.cache_creation_input_tokens === "number") result.cacheCreate = usage.cache_creation_input_tokens;
+		const details = usage.prompt_tokens_details;
+		if (typeof details === "object" && details !== null) {
+			if (typeof details.cached_tokens === "number" && details.cached_tokens > 0 && result.cacheRead === 0) result.cacheRead = details.cached_tokens;
+			if (typeof details.cache_write_tokens === "number" && details.cache_write_tokens > 0 && result.cacheCreate === 0) result.cacheCreate = details.cache_write_tokens;
+		}
+		return result;
+	} catch {
+		return;
+	}
+}
+function applyAnthropicFields(u, result) {
+	let found = false;
+	if (typeof u.cache_read_input_tokens === "number" && u.cache_read_input_tokens > 0) {
+		result.cacheRead = u.cache_read_input_tokens;
+		found = true;
+	}
+	if (typeof u.cache_creation_input_tokens === "number" && u.cache_creation_input_tokens > 0) {
+		result.cacheCreate = u.cache_creation_input_tokens;
+		found = true;
+	}
+	return found;
+}
+function applyOpenAIFields(details, result) {
+	let found = false;
+	if (typeof details.cached_tokens === "number" && details.cached_tokens > 0) {
+		result.cacheRead = details.cached_tokens;
+		found = true;
+	}
+	if (typeof details.cache_write_tokens === "number" && details.cache_write_tokens > 0) {
+		result.cacheCreate = details.cache_write_tokens;
+		found = true;
+	}
+	return found;
+}
+function extractFromEvent(parsed, result) {
+	if (typeof parsed !== "object" || parsed === null) return false;
+	const usage = (parsed.message ?? parsed).usage;
+	if (typeof usage !== "object" || usage === null) return false;
+	const u = usage;
+	let found = false;
+	found = applyAnthropicFields(u, result) || found;
+	const details = u.prompt_tokens_details;
+	if (typeof details === "object" && details !== null) found = applyOpenAIFields(details, result) || found;
+	return found;
+}
+function extractCacheUsageFromSSE(fullText) {
+	const result = {
+		cacheRead: 0,
+		cacheCreate: 0
+	};
+	let found = false;
+	for (const line of fullText.split("\n")) {
+		if (!line.startsWith("data:")) continue;
+		const payload = line.slice(5).trim();
+		if (payload === "[DONE]") continue;
+		try {
+			if (extractFromEvent(JSON.parse(payload), result)) found = true;
+		} catch {}
+	}
+	return found ? result : void 0;
+}
+function formatCacheUsage(usage, reqId) {
+	const parts = [];
+	if (usage.cacheRead > 0) parts.push(`read: ${usage.cacheRead}`);
+	if (usage.cacheCreate > 0) parts.push(`write: ${usage.cacheCreate}`);
+	logger.info(withReq(reqId, parts.length > 0 ? `Cache ${parts.join(", ")} tokens` : "Cache: no cached tokens"));
+}
+function createLoggingStream(contentType, reqId) {
+	const chunks = [];
+	return new TransformStream({
+		transform(chunk, controller) {
+			controller.enqueue(chunk);
+			chunks.push(chunk);
+		},
+		flush() {
+			try {
+				const decoder = new TextDecoder();
+				const text = chunks.reduce((acc, chunk) => acc + decoder.decode(chunk, { stream: true }), "") + decoder.decode();
+				const usage = contentType.toLowerCase().includes("text/event-stream") ? extractCacheUsageFromSSE(text) : extractCacheUsage(text);
+				if (usage) formatCacheUsage(usage, reqId);
+			} catch (err) {
+				logger.debug(withReq(reqId, `Cache usage extraction failed: ${err instanceof Error ? err.message : err}`));
+			}
+		}
+	});
+}
+function buildUpstreamResponseWithLogging(upstream, method, reqId) {
+	const headers = buildResponseHeaders(upstream.headers);
+	if (method === "HEAD" || !upstream.body) return new Response(null, {
+		status: upstream.status,
+		headers
+	});
+	const contentType = upstream.headers.get("content-type") ?? "";
+	const lower = contentType.toLowerCase();
+	const body = lower.includes("application/json") || lower.includes("text/event-stream") ? upstream.body.pipeThrough(createLoggingStream(contentType, reqId)) : upstream.body;
+	return new Response(body, {
+		status: upstream.status,
+		headers
+	});
+}
+//#endregion
 //#region src/proxy/inject.ts
 /** Extract the model name from a raw request body. Returns undefined if not parseable or absent. */
 function extractModel(rawBody) {
@@ -14705,17 +14819,6 @@ async function fetchUpstream(url, method, headers, body, signal) {
 		duplex: body ? "half" : void 0
 	});
 }
-function buildUpstreamResponse(upstream, method) {
-	const headers = buildResponseHeaders(upstream.headers);
-	if (method === "HEAD" || !upstream.body) return new Response(null, {
-		status: upstream.status,
-		headers
-	});
-	return new Response(upstream.body, {
-		status: upstream.status,
-		headers
-	});
-}
 async function readRawBody(request, reqId) {
 	try {
 		return {
@@ -14832,7 +14935,7 @@ async function executeUpstream(upstreamUrl, method, headers, body, signal, path,
 		});
 	}
 	logger.info(withReq(reqId, `${method} ${path} ← ${upstream.status} (${Date.now() - startedAt}ms)`));
-	return buildUpstreamResponse(upstream, method);
+	return buildUpstreamResponseWithLogging(upstream, method, reqId);
 }
 function createProxyServer(config, onReady) {
 	const app = new Hono();
@@ -14893,7 +14996,7 @@ function startProxyServer(config, onReady) {
 }
 //#endregion
 //#region src/version.ts
-const version = "0.6.2";
+const version = "0.8.0";
 //#endregion
 //#region src/cli.ts
 const argv = process.argv.slice(2);