@askalf/dario 2.5.1 → 2.7.0

package/README.md

@@ -387,7 +387,7 @@ Then run `hermes` normally — it routes through dario using your Claude subscri
 - Tool use / function calling
 - System prompts and multi-turn conversations
 - Prompt caching and extended thinking
-- **Billable beta filtering** — strips `extended-cache-ttl`, `context-management`, `prompt-caching-scope` from client betas to prevent surprise Extra Usage charges
+- **Billable beta filtering** — strips `extended-cache-ttl` from client betas (the only prefix requiring Extra Usage)
 - **Orchestration tag sanitization** — strips agent-injected XML (`<system-reminder>`, `<env>`, `<task_metadata>`, etc.) before forwarding
 - **Token anomaly detection** — warns on context spike (>60% input growth) or output explosion (>2x previous)
 - Concurrency control (max 10 concurrent upstream requests)
@@ -531,6 +531,13 @@ npm install
 npm run dev   # runs with tsx (no build needed)
 ```
 
+## Contributors
+
+| Who | Contributions |
+|-----|---------------|
+| [@GodsBoy](https://github.com/GodsBoy) | Proxy authentication, token redaction, error sanitization ([#2](https://github.com/askalf/dario/pull/2)) |
+| [@belangertrading](https://github.com/belangertrading) | Billing classification investigation — reported, tested 5 versions, confirmed fix via response header analysis ([#4](https://github.com/askalf/dario/issues/4)) |
+
 ## Also by AskAlf
 
 | Project | What it does |

package/dist/proxy.js

@@ -35,7 +35,7 @@ class Semaphore {
             next();
     }
 }
-// Detect installed Claude Code version at startup
+// Detect installed Claude Code binary at startup
 function detectClaudeVersion() {
     try {
         const out = execSync('claude --version', { timeout: 5000, stdio: 'pipe' }).toString().trim();
@@ -46,6 +46,46 @@ function detectClaudeVersion() {
         return '2.1.96';
     }
 }
+let cliAvailable = false;
+function detectCliAvailable() {
+    try {
+        execSync('claude --version', { timeout: 5000, stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Convert a non-streaming Messages API response to SSE event stream. */
+function jsonToSse(jsonBody) {
+    try {
+        const msg = JSON.parse(jsonBody);
+        const events = [];
+        // message_start
+        events.push(`event: message_start\ndata: ${JSON.stringify({ type: 'message_start', message: { ...msg, content: [], stop_reason: null } })}\n\n`);
+        // content blocks
+        const content = msg.content;
+        if (content) {
+            for (let i = 0; i < content.length; i++) {
+                const block = content[i];
+                events.push(`event: content_block_start\ndata: ${JSON.stringify({ type: 'content_block_start', index: i, content_block: { type: block.type, ...(block.type === 'text' ? { text: '' } : { thinking: '' }) } })}\n\n`);
+                if (block.type === 'text' && block.text) {
+                    events.push(`event: content_block_delta\ndata: ${JSON.stringify({ type: 'content_block_delta', index: i, delta: { type: 'text_delta', text: block.text } })}\n\n`);
+                }
+                else if (block.type === 'thinking' && block.thinking) {
+                    events.push(`event: content_block_delta\ndata: ${JSON.stringify({ type: 'content_block_delta', index: i, delta: { type: 'thinking_delta', thinking: block.thinking } })}\n\n`);
+                }
+                events.push(`event: content_block_stop\ndata: ${JSON.stringify({ type: 'content_block_stop', index: i })}\n\n`);
+            }
+        }
+        // message_stop
+        events.push(`event: message_stop\ndata: ${JSON.stringify({ type: 'message_stop' })}\n\n`);
+        return events.join('');
+    }
+    catch {
+        return '';
+    }
+}
 const SESSION_ID = randomUUID();
 const OS_NAME = platform === 'win32' ? 'Windows' : platform === 'darwin' ? 'MacOS' : 'Linux';
 // Claude Code device identity — required for Max plan billing classification.
@@ -365,6 +405,7 @@ export async function startProxy(opts = {}) {
         process.exit(1);
     }
     const cliVersion = detectClaudeVersion();
+    cliAvailable = detectCliAvailable();
     const modelOverride = opts.model ? (MODEL_ALIASES[opts.model] ?? opts.model) : null;
     const identity = loadClaudeIdentity();
     if (identity.deviceId) {
@@ -564,18 +605,42 @@ export async function startProxy(opts = {}) {
                             }),
                         };
                     }
-                    // Enable extended thinking (matches Claude Code default)
-                    // budget_tokens must be >= 1024, and max_tokens must accommodate it
+                    // Enable adaptive thinking (matches Claude Code default)
+                    // adaptive lets the model decide when/how much to think — preferred for Opus/Sonnet 4.6
                     if (!r.thinking) {
+                        r.thinking = { type: 'adaptive' };
+                        // Ensure max_tokens is reasonable for thinking models
                         const clientMax = r.max_tokens || 8192;
-                        const maxTokens = Math.max(clientMax, 16000);
-                        r.max_tokens = maxTokens;
-                        r.thinking = { budget_tokens: maxTokens - 1, type: 'enabled' };
+                        r.max_tokens = Math.max(clientMax, 16000);
+                    }
+                    // Request priority capacity when available
+                    if (!r.service_tier) {
+                        r.service_tier = 'auto';
                     }
                     // Enable context management (matches Claude Code default)
                     if (!r.context_management) {
                         r.context_management = { edits: [{ type: 'clear_thinking_20251015', keep: 'all' }] };
                     }
+                    // Inject Claude Code billing header into system prompt.
+                    // Anthropic uses this to route requests through priority rate limiting
+                    // instead of the general API quota. Without it, Opus/Sonnet get 429
+                    // when overall utilization is high, even though model-specific limits
+                    // have headroom. The CLI binary embeds this in its system prompt.
+                    const billingTag = `x-anthropic-billing-header: cc_version=${cliVersion}; cc_entrypoint=cli; cch=98638;`;
+                    if (typeof r.system === 'string') {
+                        if (!r.system.includes('x-anthropic-billing-header:')) {
+                            r.system = billingTag + '\n' + r.system;
+                        }
+                    }
+                    else if (Array.isArray(r.system)) {
+                        const hasTag = r.system.some(b => typeof b.text === 'string' && b.text.includes('x-anthropic-billing-header:'));
+                        if (!hasTag) {
+                            r.system.unshift({ type: 'text', text: billingTag });
+                        }
+                    }
+                    else {
+                        r.system = billingTag;
+                    }
                     finalBody = Buffer.from(JSON.stringify(r));
                 }
                 catch { /* not JSON, send as-is */ }
@@ -588,7 +653,7 @@ export async function startProxy(opts = {}) {
             // Billing classification is determined by the OAuth token alone, not beta flags.
             // context-management and prompt-caching-scope are safe for all subscription types.
             const clientBeta = req.headers['anthropic-beta'];
-            let beta = 'oauth-2025-04-20,interleaved-thinking-2025-05-14,context-management-2025-06-27,prompt-caching-scope-2026-01-05,claude-code-20250219,advisor-tool-2026-03-01';
+            let beta = 'oauth-2025-04-20,interleaved-thinking-2025-05-14,context-management-2025-06-27,prompt-caching-scope-2026-01-05,claude-code-20250219,advisor-tool-2026-03-01,effort-2025-11-24';
             if (clientBeta) {
                 const filtered = filterBillableBetas(clientBeta);
                 if (filtered)
@@ -607,6 +672,76 @@ export async function startProxy(opts = {}) {
                 body: finalBody ? new Uint8Array(finalBody) : undefined,
                 signal: AbortSignal.timeout(UPSTREAM_TIMEOUT_MS),
             });
+            // Auto-fallback: if API returns 429 and CLI is available, retry through CLI binary.
+            // The CLI gets priority routing from Anthropic's server — a separate rate limit pool
+            // that continues working when the direct API quota is exhausted for expensive models.
+            if (upstream.status === 429 && cliAvailable && !useCli) {
+                // Drain the upstream response
+                await upstream.text().catch(() => { });
+                if (verbose)
+                    console.log(`[dario] #${requestCount} 429 from API — falling back to CLI`);
+                // Determine if the client requested streaming
+                let clientWantsStream = false;
+                if (body.length > 0) {
+                    try {
+                        const p = JSON.parse(body.toString());
+                        clientWantsStream = !!p.stream;
+                    }
+                    catch { }
+                }
+                const cliResult = await handleViaCli(body, modelOverride, verbose);
+                requestCount++;
+                if (cliResult.status >= 200 && cliResult.status < 300) {
+                    if (isOpenAI) {
+                        // Translate to OpenAI format
+                        try {
+                            const parsed = JSON.parse(cliResult.body);
+                            cliResult.body = JSON.stringify(anthropicToOpenai(parsed));
+                        }
+                        catch { }
+                    }
+                    if (clientWantsStream && !isOpenAI) {
+                        // Client requested SSE streaming — convert CLI JSON to SSE events
+                        const sseData = jsonToSse(cliResult.body);
+                        res.writeHead(200, {
+                            'Content-Type': 'text/event-stream',
+                            'Access-Control-Allow-Origin': corsOrigin,
+                            ...SECURITY_HEADERS,
+                        });
+                        res.end(sseData);
+                    }
+                    else if (clientWantsStream && isOpenAI) {
+                        // OpenAI streaming — convert Anthropic JSON to OpenAI SSE
+                        try {
+                            const parsed = JSON.parse(cliResult.body);
+                            const text = parsed.content?.find(c => c.type === 'text')?.text ?? '';
+                            const ts = Math.floor(Date.now() / 1000);
+                            let sseData = `data: ${JSON.stringify({ id: 'chatcmpl-dario', object: 'chat.completion.chunk', created: ts, model: 'claude', choices: [{ index: 0, delta: { content: text }, finish_reason: null }] })}\n\n`;
+                            sseData += `data: ${JSON.stringify({ id: 'chatcmpl-dario', object: 'chat.completion.chunk', created: ts, model: 'claude', choices: [{ index: 0, delta: {}, finish_reason: 'stop' }] })}\n\ndata: [DONE]\n\n`;
+                            res.writeHead(200, {
+                                'Content-Type': 'text/event-stream',
+                                'Access-Control-Allow-Origin': corsOrigin,
+                                ...SECURITY_HEADERS,
+                            });
+                            res.end(sseData);
+                        }
+                        catch {
+                            res.writeHead(cliResult.status, { 'Content-Type': cliResult.contentType, 'Access-Control-Allow-Origin': corsOrigin, ...SECURITY_HEADERS });
+                            res.end(cliResult.body);
+                        }
+                    }
+                    else {
+                        res.writeHead(cliResult.status, { 'Content-Type': cliResult.contentType, 'Access-Control-Allow-Origin': corsOrigin, ...SECURITY_HEADERS });
+                        res.end(cliResult.body);
+                    }
+                }
+                else {
+                    // CLI also failed — return the CLI error
+                    res.writeHead(cliResult.status, { 'Content-Type': cliResult.contentType, 'Access-Control-Allow-Origin': corsOrigin, ...SECURITY_HEADERS });
+                    res.end(cliResult.body);
+                }
+                return;
+            }
             // Detect streaming from content-type (reliable) or body (fallback)
             const contentType = upstream.headers.get('content-type') ?? '';
             const isStream = contentType.includes('text/event-stream');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "2.5.1",
+  "version": "2.7.0",
   "description": "Use your Claude subscription as an API. No API key needed. Local proxy for Claude Max/Pro subscriptions.",
   "type": "module",
   "bin": {
@@ -55,11 +55,11 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.39.0"
+    "@anthropic-ai/sdk": "^0.81.0"
   },
   "devDependencies": {
-    "typescript": "^5.7.0",
+    "@types/node": "^22.0.0",
     "tsx": "^4.19.0",
-    "@types/node": "^22.0.0"
+    "typescript": "^5.7.0"
   }
 }