proxitor 0.6.1 → 0.7.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

@@ -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,18 +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
-	});
-}
-/** Read and process the request body, returning an error response on failure */
 async function readRawBody(request, reqId) {
 	try {
 		return {
@@ -14735,7 +14837,6 @@ async function readRawBody(request, reqId) {
 		};
 	}
 }
-/** Resolve per-request config: extract model, resolve overrides, build routing and body */
 function resolveRequest(rawBody, config, method, path, reqId) {
 	const modelName = extractModel(rawBody);
 	const resolved = resolveModelConfig(config, modelName);
@@ -14768,7 +14869,41 @@ function resolveRequest(rawBody, config, method, path, reqId) {
 		headers: resolved.headers
 	};
 }
-/** Execute upstream fetch, returning appropriate error responses on failure */
+/**
+* Extract a readable error detail from an upstream response body.
+*
+* OpenRouter error format:
+*   { error: { code: 400, message: "...", metadata: { raw: "...", provider_name: "..." } } }
+*
+* - `error.message` — human-readable summary
+* - `error.metadata.provider_name` — which provider caused it (null = OpenRouter itself)
+* - `error.metadata.raw` — the original provider error (most specific cause)
+*/
+function formatMetadata(meta) {
+	const parts = [];
+	if (meta.provider_name) parts.push(`provider=${meta.provider_name}`);
+	if (meta.raw) {
+		const raw = typeof meta.raw === "string" ? meta.raw : JSON.stringify(meta.raw);
+		parts.push(raw);
+	}
+	return parts;
+}
+function extractErrorDetail(bodyText) {
+	try {
+		const parsed = JSON.parse(bodyText);
+		if (typeof parsed !== "object" || parsed === null) return bodyText;
+		const err = parsed.error;
+		if (typeof err === "object" && err !== null && err.message) {
+			const parts = [];
+			if (err.code != null) parts.push(String(err.code));
+			parts.push(String(err.message));
+			if (err.metadata && typeof err.metadata === "object") parts.push(...formatMetadata(err.metadata));
+			return parts.join(" | ");
+		}
+		if (parsed.message) return String(parsed.message);
+	} catch {}
+	return bodyText;
+}
 async function executeUpstream(upstreamUrl, method, headers, body, signal, path, startedAt, reqId) {
 	let upstream;
 	try {
@@ -14784,8 +14919,23 @@ async function executeUpstream(upstreamUrl, method, headers, body, signal, path,
 			type: "proxy_upstream_error"
 		} }, { status: 502 });
 	}
+	if (upstream.status >= 400) {
+		const bodyText = await upstream.text();
+		const detail = extractErrorDetail(bodyText);
+		const truncated = detail.length > 300 ? `${detail.slice(0, 300)}…` : detail;
+		(upstream.status >= 500 ? logger.error : logger.warn)(withReq(reqId, `${method} ${path} ← ${upstream.status} (${Date.now() - startedAt}ms): ${truncated}`));
+		const responseHeaders = buildResponseHeaders(upstream.headers);
+		if (method === "HEAD") return new Response(null, {
+			status: upstream.status,
+			headers: responseHeaders
+		});
+		return new Response(bodyText, {
+			status: upstream.status,
+			headers: responseHeaders
+		});
+	}
 	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();
@@ -14822,9 +14972,7 @@ function createProxyServer(config, onReady) {
 		hostname: config.host
 	}, onReady);
 }
-/** Shutdown deadline: force-close after this many ms */
 const SHUTDOWN_TIMEOUT_MS = 1e4;
-/** Start the proxy with graceful shutdown on SIGTERM/SIGINT */
 function startProxyServer(config, onReady) {
 	const server = createProxyServer(config, onReady);
 	let shuttingDown = false;
@@ -14848,7 +14996,7 @@ function startProxyServer(config, onReady) {
 }
 //#endregion
 //#region src/version.ts
-const version = "0.6.1";
+const version = "0.7.0";
 //#endregion
 //#region src/cli.ts
 const argv = process.argv.slice(2);