squeezr-ai 1.23.0 → 1.24.0

package/README.md

@@ -302,7 +302,7 @@ If the output says `a foreign service is` listening on the port, you have three
 2. **Stop the offending service**: `docker ps` to find what owns 8080, then `docker stop <id>`.
 3. **Inspect runtime info**: `cat ~/.squeezr/runtime.json` shows the *actual* port Squeezr is bound to. If it differs from your `ANTHROPIC_BASE_URL`, run `squeezr setup` to refresh your shell profile.
 
-Squeezr v1.23.0+ runs a self-test on every startup that detects this exact failure mode and prints actionable hints. You can re-run it any time with:
+Squeezr v1.24.0+ runs a self-test on every startup that detects this exact failure mode and prints actionable hints. You can re-run it any time with:
 
 ```bash
 curl -s "http://localhost:$(jq -r .port ~/.squeezr/runtime.json)/squeezr/selftest?run=1" | jq

package/dist/__tests__/rateLimitHeaders.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tests that anthropic-ratelimit-* headers from upstream are forwarded back to
+ * the client in streaming responses (issue #4).
+ *
+ * Claude Code reads these headers to populate rate_limits in the statusline JSON.
+ * Previously the proxy consumed them internally but never relayed them.
+ */
+export {};

package/dist/__tests__/rateLimitHeaders.test.js

@@ -0,0 +1,96 @@
+/**
+ * Tests that anthropic-ratelimit-* headers from upstream are forwarded back to
+ * the client in streaming responses (issue #4).
+ *
+ * Claude Code reads these headers to populate rate_limits in the statusline JSON.
+ * Previously the proxy consumed them internally but never relayed them.
+ */
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { createServer } from 'node:http';
+// ── Helper: start a minimal mock Anthropic server ─────────────────────────────
+const RATE_LIMIT_HEADERS = {
+    'anthropic-ratelimit-requests-limit': '50',
+    'anthropic-ratelimit-requests-remaining': '49',
+    'anthropic-ratelimit-requests-reset': '2026-01-01T00:00:00Z',
+    'anthropic-ratelimit-tokens-limit': '100000',
+    'anthropic-ratelimit-tokens-remaining': '99000',
+    'anthropic-ratelimit-tokens-reset': '2026-01-01T00:01:00Z',
+};
+/** Start an upstream mock that returns rate-limit headers + a minimal SSE stream. */
+function startMockAnthropic() {
+    return new Promise((resolve) => {
+        const server = createServer((req, res) => {
+            if (req.url === '/v1/messages' && req.method === 'POST') {
+                // Consume request body so the socket doesn't stall
+                req.resume();
+                req.on('end', () => {
+                    const headers = {
+                        'content-type': 'text/event-stream',
+                        'cache-control': 'no-cache',
+                        ...RATE_LIMIT_HEADERS,
+                    };
+                    res.writeHead(200, headers);
+                    // Minimal well-formed SSE stream
+                    res.write('data: {"type":"message_start","message":{"id":"msg_1","type":"message","role":"assistant","content":[],"model":"claude-opus-4-5","stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":10,"output_tokens":0}}}\n\n');
+                    res.write('data: {"type":"message_stop"}\n\n');
+                    res.end();
+                });
+            }
+            else {
+                res.writeHead(404);
+                res.end();
+            }
+        });
+        server.listen(0, '127.0.0.1', () => {
+            resolve({ port: server.address().port, server });
+        });
+    });
+}
+// ── Tests ─────────────────────────────────────────────────────────────────────
+describe('rate-limit header forwarding (issue #4)', () => {
+    const servers = [];
+    afterEach(async () => {
+        while (servers.length) {
+            const s = servers.pop();
+            await new Promise((r) => s.close(() => r()));
+        }
+        vi.unstubAllEnvs();
+    });
+    it('forwards anthropic-ratelimit-* headers on streaming /v1/messages responses', async () => {
+        const { port: upstreamPort, server: upstream } = await startMockAnthropic();
+        servers.push(upstream);
+        // Dynamically import server after env is set so ANTHROPIC_API points at mock.
+        // We monkey-patch the module-level constant by intercepting fetch.
+        const upstreamBase = `http://127.0.0.1:${upstreamPort}`;
+        // Stub global fetch to redirect api.anthropic.com calls to our mock
+        const realFetch = global.fetch;
+        vi.stubGlobal('fetch', async (input, init) => {
+            const url = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
+            const redirected = url.replace('https://api.anthropic.com', upstreamBase);
+            return realFetch(redirected, init);
+        });
+        // Import app after stubbing fetch
+        const { app } = await import('../server.js');
+        const request = new Request('http://localhost/v1/messages', {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                'x-api-key': 'sk-ant-test-key',
+            },
+            body: JSON.stringify({
+                model: 'claude-opus-4-5',
+                max_tokens: 100,
+                stream: true,
+                messages: [{ role: 'user', content: 'hi' }],
+            }),
+        });
+        const response = await app.fetch(request);
+        expect(response.status).toBe(200);
+        // Consume body so connection closes cleanly
+        await response.text();
+        // The key assertion: rate-limit headers must be present
+        for (const [name, expected] of Object.entries(RATE_LIMIT_HEADERS)) {
+            expect(response.headers.get(name), `Expected header "${name}" to be forwarded`).toBe(expected);
+        }
+    });
+});

package/dist/server.js

@@ -183,6 +183,10 @@ app.post('/v1/messages', async (c) => {
         if (body.stream) {
             const upstream = await proxyStream(`${ANTHROPIC_API}/v1/messages`, body, fwdHeaders);
             updateAnthropicFromHeaders(upstream.headers);
+            for (const [k, v] of upstream.headers.entries()) {
+                if (!SKIP_RESP_HEADERS.has(k.toLowerCase()))
+                    c.header(k, v);
+            }
             return stream(c, async (s) => {
                 const reader = upstream.body.getReader();
                 const decoder = new TextDecoder();
@@ -246,6 +250,12 @@ app.post('/v1/messages', async (c) => {
         const upstream = await proxyStream(`${ANTHROPIC_API}/v1/messages`, body, fwdHeaders);
         // Extract rate limit headers immediately (available before body starts)
         updateAnthropicFromHeaders(upstream.headers);
+        // Forward anthropic-ratelimit-* (and other response) headers so Claude Code
+        // can populate rate_limits in the statusline JSON (issue #4).
+        for (const [k, v] of upstream.headers.entries()) {
+            if (!SKIP_RESP_HEADERS.has(k.toLowerCase()))
+                c.header(k, v);
+        }
         return stream(c, async (s) => {
             const reader = upstream.body.getReader();
             const decoder = new TextDecoder();
@@ -290,8 +300,14 @@ app.post('/v1/messages', async (c) => {
             headers: { ...fwdHeaders, 'content-type': 'application/json' },
             body: JSON.stringify(body),
         });
+        updateAnthropicFromHeaders(continuedResp.headers);
         const continuedBody = await continuedResp.json();
-        return c.json(continuedBody, continuedResp.status);
+        const continuedHeaders = {};
+        for (const [k, v] of continuedResp.headers.entries()) {
+            if (!SKIP_RESP_HEADERS.has(k.toLowerCase()))
+                continuedHeaders[k] = v;
+        }
+        return c.json(continuedBody, continuedResp.status, continuedHeaders);
     }
     const respHeaders = {};
     for (const [k, v] of resp.headers.entries()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squeezr-ai",
-  "version": "1.23.0",
+  "version": "1.24.0",
   "description": "AI proxy that compresses Claude Code, Codex, Aider, Gemini CLI and Ollama context windows to save thousands of tokens per session",
   "keywords": [
     "claude",
@@ -58,7 +58,7 @@
     "@vitest/coverage-v8": "^4.1.2",
     "tsx": "^4.19.3",
     "typescript": "^5.8.3",
-    "vitest": "^3.1.1"
+    "vitest": "^4.1.2"
   },
   "engines": {
     "node": ">=18"