@timo972/cc-router 0.10.0-rc.4 → 0.10.0-rc.5

package/CHANGELOG.md

@@ -55,6 +55,16 @@ This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Fixed
 
+- Anthropic activity rows show their cache rate and token counts. The proxy
+  captures usage by passively parsing the response body, but skipped any
+  compressed response — and since the proxy is byte-transparent, the client's
+  own `accept-encoding` makes upstream compress essentially every response, so
+  no `/messages` row ever carried token fields while Codex rows (whose relay
+  decompresses anyway) did. The capture now decompresses its own copy of the
+  stream (gzip/brotli/deflate) purely for parsing, stops paying for the
+  stream once both usage events have been seen, and remains strictly
+  best-effort: a corrupt or unsupported coding ends the capture, never the
+  response.
 - `cc-router stop` no longer terminates itself — or your editor sessions —
   when it falls back to killing by port. The fallback listed every process
   with a socket on the proxy port (`lsof -ti :port` reports both ends of

package/dist/proxy/server.js

@@ -26,6 +26,7 @@ import { SessionRouter } from "./session-router.js";
 import { createAnthropicProxy } from "./anthropic-proxy.js";
 import { AnthropicUsageRefresher } from "../providers/anthropic/usage-refresher.js";
 import { OpenAIUsageRefresher } from "../providers/openai/usage-fetch.js";
+import { createAnthropicUsageCapture } from "./usage-capture.js";
 import { canUseExtraUsage } from "../providers/anthropic/usage.js";
 import { applyUpstreamFailureRoutingDetailed, reconcileAmbiguousRateLimitCooldown, routeFailureDetails, routeReasonDetails, } from "./lease-lifecycle.js";
 import { persistProviderEnabledState } from "./provider-routing.js";
@@ -1045,8 +1046,11 @@ export async function startServer(opts = {}) {
                 //   message_start  → input_tokens, cache_read/creation_input_tokens
                 //   message_delta   → output_tokens
                 // Non-streaming JSON carries all fields in a single usage object.
-                // We use incremental line parsing (not buffering) so we can capture
-                // both events without holding the full stream in memory.
+                // The proxy is byte-transparent and the client's accept-encoding makes
+                // upstream compress, so the capture decompresses its own copy of the
+                // stream (see usage-capture.ts) — previously compressed responses were
+                // skipped, which in practice was EVERY response: no cache rate or
+                // token counts ever appeared on Anthropic activity rows.
                 const contentType = String(proxyRes.headers["content-type"] ?? "");
                 const encoding = String(proxyRes.headers["content-encoding"] ?? "");
                 const isCompressed = /gzip|br|deflate/.test(encoding);
@@ -1054,51 +1058,17 @@ export async function startServer(opts = {}) {
                 entry.streamLifecycle = streamTracker.state;
                 streamTracker.attach(proxyRes, response);
                 proxyRes.on("data", (chunk) => streamTracker.observeChunk(chunk));
-                if (!isCompressed && (contentType.includes("text/event-stream") || contentType.includes("application/json"))) {
-                    const isSSE = contentType.includes("text/event-stream");
-                    if (isSSE) {
-                        let lineBuf = "";
-                        let gotInput = false;
-                        let gotOutput = false;
-                        proxyRes.on("data", (chunk) => {
-                            if (gotInput && gotOutput)
-                                return;
-                            lineBuf += chunk.toString("utf8");
-                            const lines = lineBuf.split("\n");
-                            lineBuf = lines.pop() ?? ""; // keep incomplete last line
-                            for (const line of lines) {
-                                if (!line.startsWith("data: "))
-                                    continue;
-                                try {
-                                    const evt = JSON.parse(line.slice(6));
-                                    if (!gotInput && evt.type === "message_start" && evt.message?.usage) {
-                                        applyInputUsage(entry, evt.message.usage);
-                                        gotInput = true;
-                                    }
-                                    if (!gotOutput && evt.type === "message_delta" && evt.usage) {
-                                        applyOutputUsage(entry, evt.usage);
-                                        gotOutput = true;
-                                    }
-                                }
-                                catch { /* partial JSON across chunk boundary — next chunk will complete it */ }
-                            }
-                        });
-                    }
-                    else {
-                        // Non-streaming JSON: buffer full body then parse once
-                        let buf = "";
-                        proxyRes.on("data", (chunk) => { buf += chunk.toString("utf8"); });
-                        proxyRes.on("end", () => {
-                            try {
-                                const body = JSON.parse(buf);
-                                if (body.usage) {
-                                    applyInputUsage(entry, body.usage);
-                                    applyOutputUsage(entry, body.usage);
-                                }
-                            }
-                            catch { /* ignore */ }
-                        });
-                    }
+                const usageCapture = createAnthropicUsageCapture({
+                    contentType,
+                    contentEncoding: encoding,
+                    // Mutates the already-logged entry in place; the dashboard picks the
+                    // values up on its next poll.
+                    onInputUsage: (usage) => applyInputUsage(entry, usage),
+                    onOutputUsage: (usage) => applyOutputUsage(entry, usage),
+                });
+                if (usageCapture) {
+                    proxyRes.on("data", (chunk) => usageCapture.write(chunk));
+                    proxyRes.on("end", () => usageCapture.end());
                 }
             },
             error: (err, _req, res) => {

package/dist/proxy/usage-capture.js

@@ -0,0 +1,119 @@
+import { createBrotliDecompress, createGunzip, createInflate } from "node:zlib";
+/** Non-streaming bodies are buffered for one parse at end-of-stream; a body
+ *  past this size stops being buffered (usage is best-effort diagnostics —
+ *  unbounded buffering of a pathological body is not worth it). */
+const MAX_JSON_BODY_BYTES = 20 * 1024 * 1024;
+function createDecoder(contentEncoding) {
+    const encoding = contentEncoding.trim().toLowerCase();
+    // `identity` and absent mean the bytes are already readable.
+    if (encoding === "" || encoding === "identity")
+        return null;
+    if (encoding === "gzip" || encoding === "x-gzip")
+        return createGunzip();
+    if (encoding === "br")
+        return createBrotliDecompress();
+    if (encoding === "deflate")
+        return createInflate();
+    // Multi-codings ("gzip, br") and unknown codings are not worth chasing.
+    return undefined;
+}
+export function createAnthropicUsageCapture(options) {
+    const isSSE = options.contentType.includes("text/event-stream");
+    const isJSON = options.contentType.includes("application/json");
+    if (!isSSE && !isJSON)
+        return null;
+    const decoder = createDecoder(options.contentEncoding);
+    if (decoder === undefined)
+        return null;
+    let dead = false;
+    const die = () => {
+        if (dead)
+            return;
+        dead = true;
+        decoder?.destroy();
+    };
+    // ── SSE: incremental line parsing, stop once both events were seen ────────
+    let lineBuf = "";
+    let gotInput = false;
+    let gotOutput = false;
+    const parseSSEChunk = (text) => {
+        lineBuf += text;
+        const lines = lineBuf.split("\n");
+        lineBuf = lines.pop() ?? ""; // keep incomplete last line
+        for (const line of lines) {
+            if (!line.startsWith("data: "))
+                continue;
+            try {
+                const evt = JSON.parse(line.slice(6));
+                if (!gotInput && evt.type === "message_start" && evt.message?.usage) {
+                    options.onInputUsage(evt.message.usage);
+                    gotInput = true;
+                }
+                if (!gotOutput && evt.type === "message_delta" && evt.usage) {
+                    options.onOutputUsage(evt.usage);
+                    gotOutput = true;
+                }
+                // Everything of interest has been seen — stop paying for the rest of
+                // the stream (and free the decompressor's zlib state).
+                if (gotInput && gotOutput)
+                    die();
+            }
+            catch { /* partial JSON across chunk boundary — next chunk completes it */ }
+        }
+    };
+    // ── Non-streaming JSON: buffer, parse once at end ─────────────────────────
+    let jsonBuf = "";
+    const parseJSONBody = () => {
+        try {
+            const body = JSON.parse(jsonBuf);
+            if (body.usage) {
+                options.onInputUsage(body.usage);
+                options.onOutputUsage(body.usage);
+            }
+        }
+        catch { /* not a JSON body after all */ }
+    };
+    const consume = (chunk) => {
+        if (dead)
+            return;
+        if (isSSE) {
+            parseSSEChunk(chunk.toString("utf8"));
+            return;
+        }
+        if (jsonBuf.length + chunk.length > MAX_JSON_BODY_BYTES) {
+            die();
+            return;
+        }
+        jsonBuf += chunk.toString("utf8");
+    };
+    const finish = () => {
+        if (dead)
+            return;
+        if (isJSON)
+            parseJSONBody();
+        dead = true;
+    };
+    if (!decoder) {
+        return {
+            write: (chunk) => consume(chunk),
+            end: () => finish(),
+        };
+    }
+    decoder.on("data", (chunk) => consume(chunk));
+    decoder.on("end", () => finish());
+    // Corrupt or truncated compressed data — the capture just stops; the
+    // proxied bytes were never ours to begin with.
+    decoder.on("error", () => die());
+    return {
+        write: (chunk) => {
+            if (dead)
+                return;
+            decoder.write(chunk);
+        },
+        end: () => {
+            if (dead)
+                return;
+            decoder.end();
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timo972/cc-router",
-  "version": "0.10.0-rc.4",
+  "version": "0.10.0-rc.5",
   "description": "Cache-aware session router for Claude Max OAuth tokens — use multiple Claude Max accounts with Claude Code",
   "type": "module",
   "bin": {