@askalf/dario 2.11.0 → 3.0.2

package/dist/proxy.js

@@ -6,6 +6,7 @@ import { join } from 'node:path';
 import { homedir, tmpdir } from 'node:os';
 import { arch, platform } from 'node:process';
 import { getAccessToken, getStatus } from './oauth.js';
+import { buildCCRequest, reverseMapResponse } from './cc-template.js';
 const ANTHROPIC_API = 'https://api.anthropic.com';
 const DEFAULT_PORT = 3456;
 const MAX_BODY_BYTES = 10 * 1024 * 1024; // 10 MB — generous for large prompts, prevents abuse
@@ -236,194 +237,12 @@ function sanitizeMessages(body) {
         }
     }
 }
-/**
- * Strip thinking blocks from prior assistant messages.
- * Real Claude Code strips thinking from conversation history before building the next request.
- * The API's context_management: clear_thinking does NOT reduce input token billing —
- * tokens are counted before server-side edits. Client-side stripping is the only way
- * to avoid burning the 5h window on stale thinking traces.
- * Only strips from prior turns — the most recent assistant message is left intact.
- */
-function stripThinkingFromHistory(body) {
-    const messages = body.messages;
-    if (!messages)
-        return;
-    // Strip thinking blocks from ALL assistant messages.
-    // Real Claude Code never sends thinking blocks in the messages array —
-    // it strips them before building the next request. The API will generate
-    // fresh thinking for the current turn; prior thinking is dead weight.
-    for (const msg of messages) {
-        if (msg.role !== 'assistant')
-            continue;
-        if (Array.isArray(msg.content)) {
-            msg.content = msg.content.filter(b => b.type !== 'thinking');
-        }
-    }
-}
 /**
  * Scrub non-Claude-Code fields and normalize field ordering.
  * Real Claude Code never sends these fields. Their presence is a fingerprint.
  * JSON field order is also detectable — Claude Code always sends fields in a
  * specific order. We rebuild the object to match.
  */
-const NON_CC_FIELDS = new Set(['service_tier', 'top_p', 'top_k', 'stop_sequences', 'temperature']);
-// ── Tool name rewriting ──
-// Anthropic fingerprints on tool names — non-CC names trigger overage classification.
-// Map third-party tool names to CC equivalents on the way in, reverse on the way out.
-const CC_TOOLS = new Set([
-    'Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep', 'Browser', 'WebFetch', 'WebSearch',
-    'NotebookEdit', 'NotebookRead', 'TodoRead', 'TodoWrite',
-    'Agent', 'MCPListTools', 'MCPCallTool',
-    'AskUserQuestion', 'EnterPlanMode', 'ExitPlanMode',
-    'EnterWorktree', 'ExitWorktree', 'TaskCreate', 'TaskUpdate',
-]);
-// Common third-party tool names → CC equivalents
-const TOOL_NAME_MAP = {
-    bash: 'Bash', sh: 'Bash', exec: 'Bash', shell: 'Bash', run: 'Bash', execute: 'Bash',
-    command: 'Bash', terminal: 'Bash', process: 'Bash',
-    read: 'Read', read_file: 'Read', file_read: 'Read', get_file: 'Read',
-    write: 'Write', write_file: 'Write', file_write: 'Write', create_file: 'Write', save_file: 'Write',
-    edit: 'Edit', edit_file: 'Edit', modify_file: 'Edit', patch: 'Edit', replace: 'Edit',
-    glob: 'Glob', find_files: 'Glob', list_files: 'Glob', ls: 'Glob',
-    grep: 'Grep', search: 'Grep', search_files: 'Grep', find_in_files: 'Grep', rg: 'Grep',
-    web_search: 'WebSearch', websearch: 'WebSearch', google: 'WebSearch',
-    web_fetch: 'WebFetch', webfetch: 'WebFetch', fetch: 'WebFetch', http: 'WebFetch', curl: 'WebFetch',
-    browse: 'Browser', browser: 'Browser', open_url: 'Browser',
-    notebook: 'NotebookEdit', notebook_edit: 'NotebookEdit',
-};
-/**
- * Rewrite tool names in the request to match CC toolset.
- * Returns the mapping so we can reverse it in the response.
- * Tools that don't map to a known CC name get wrapped as MCPCallTool.
- */
-function rewriteToolNames(body) {
-    const tools = body.tools;
-    if (!tools || !Array.isArray(tools))
-        return [];
-    const mappings = [];
-    const usedNames = new Set();
-    // First pass: collect CC tool names already in the list
-    for (const tool of tools) {
-        if (CC_TOOLS.has(tool.name))
-            usedNames.add(tool.name);
-    }
-    let mcpIndex = 0;
-    for (const tool of tools) {
-        const originalName = tool.name;
-        if (!originalName)
-            continue;
-        // Already a CC tool name
-        if (CC_TOOLS.has(originalName))
-            continue;
-        // Check direct map — but avoid duplicates
-        const directMap = TOOL_NAME_MAP[originalName.toLowerCase()];
-        if (directMap && !usedNames.has(directMap)) {
-            mappings.push({ original: originalName, mapped: directMap });
-            tool.name = directMap;
-            usedNames.add(directMap);
-        }
-        else {
-            // Wrap as mcp_<original_name> — MCP tools use this prefix in real CC
-            const mcpName = `mcp_${originalName}`;
-            mappings.push({ original: originalName, mapped: mcpName });
-            tool.name = mcpName;
-        }
-    }
-    // Cap tool count — CC sends max ~22 tools. Excess tools get consolidated
-    // into a single MCPCallTool dispatch with routing table.
-    const MAX_TOOLS = 22;
-    if (tools.length > MAX_TOOLS) {
-        const keep = tools.slice(0, MAX_TOOLS - 1); // keep first N-1
-        const overflow = tools.slice(MAX_TOOLS - 1);
-        // Build dispatch tool that wraps all overflow tools
-        const dispatchDesc = overflow.map((t) => `${t.name}: ${(t.description || '').slice(0, 50)}`).join('\n');
-        const dispatchTool = {
-            name: 'mcp_dispatch',
-            description: `Route to one of these tools:\n${dispatchDesc}`,
-            input_schema: {
-                type: 'object',
-                properties: {
-                    tool_name: { type: 'string', description: 'Which tool to call', enum: overflow.map((t) => t.name) },
-                    input: { type: 'object', description: 'Arguments to pass to the tool' },
-                },
-                required: ['tool_name', 'input'],
-            },
-        };
-        // Track overflow mappings for reverse
-        for (const t of overflow) {
-            mappings.push({ original: t.name, mapped: 'mcp_dispatch' });
-        }
-        // Replace tools array
-        keep.push(dispatchTool);
-        body.tools = keep;
-    }
-    return mappings;
-}
-/**
- * Reverse tool name mapping in the response body.
- * Restores original tool names in tool_use content blocks.
- */
-function reverseToolNames(body, mappings) {
-    if (mappings.length === 0)
-        return body;
-    let result = body;
-    for (const { original, mapped } of mappings) {
-        // Replace in tool_use blocks: "name":"MCPCallTool" → "name":"original"
-        result = result.replace(new RegExp(`"name"\\s*:\\s*"${mapped}"`, 'g'), `"name":"${original}"`);
-    }
-    return result;
-}
-// Claude Code's field order (from MITM capture). Fields not in this list are appended at end.
-const CC_FIELD_ORDER = [
-    'model', 'messages', 'system', 'max_tokens', 'thinking', 'output_config',
-    'context_management', 'metadata', 'stream', 'tools', 'tool_choice',
-];
-function scrubAndReorderFields(body) {
-    // Remove non-CC fields
-    for (const field of NON_CC_FIELDS) {
-        delete body[field];
-    }
-    // Rebuild with Claude Code field ordering
-    const ordered = {};
-    for (const key of CC_FIELD_ORDER) {
-        if (key in body) {
-            ordered[key] = body[key];
-            delete body[key];
-        }
-    }
-    // Append any remaining fields (custom client fields we don't recognize)
-    for (const [key, value] of Object.entries(body)) {
-        ordered[key] = value;
-    }
-    return ordered;
-}
-/**
- * Normalize system prompt to exactly 3 blocks.
- * Real Claude Code always sends exactly 3 system blocks:
- * [0] billing tag (no cache), [1] agent identity (cache 1h), [2] system prompt (cache 1h)
- * If the client sends multiple system blocks, merge them into block [2].
- */
-function normalizeSystemTo3Blocks(system, billingTag, agentIdentity, cache1h) {
-    let systemText;
-    if (typeof system === 'string') {
-        systemText = system;
-    }
-    else if (Array.isArray(system)) {
-        // Merge all text blocks into one, skip any existing billing tags
-        systemText = system
-            .filter(b => b.text && !b.text.includes('x-anthropic-billing-header:'))
-            .map(b => b.text)
-            .join('\n\n');
-    }
-    else {
-        systemText = '';
-    }
-    return [
-        { type: 'text', text: billingTag },
-        { type: 'text', text: agentIdentity, cache_control: cache1h },
-        { type: 'text', text: systemText || 'You are a helpful assistant.', cache_control: cache1h },
-    ];
-}
 // OpenAI model names → Anthropic (fallback if client sends GPT names)
 const OPENAI_MODEL_MAP = {
     'gpt-5.4': 'claude-opus-4-6',
@@ -699,7 +518,7 @@ export async function startProxy(opts = {}) {
         'accept': 'application/json',
         'Content-Type': 'application/json',
         'anthropic-dangerous-direct-browser-access': 'true',
-        'user-agent': `claude-cli/${cliVersion} (external, cli)`,
+        'user-agent': `claude-cli/${cliVersion} (external, cli, workload/cron)`,
         'x-app': 'cli',
         'x-claude-code-session-id': SESSION_ID,
         'x-stainless-arch': arch,
@@ -735,7 +554,7 @@ export async function startProxy(opts = {}) {
     const JSON_HEADERS = { 'Content-Type': 'application/json', ...SECURITY_HEADERS };
     const MODELS_JSON = JSON.stringify(OPENAI_MODELS_LIST);
     const ERR_UNAUTH = JSON.stringify({ error: 'Unauthorized', message: 'Invalid or missing API key' });
-    const ERR_FORBIDDEN = JSON.stringify({ error: 'Forbidden', message: 'Path not allowed' });
+    const ERR_FORBIDDEN = JSON.stringify({ error: 'Forbidden', message: 'Path not allowed. Supported paths: POST /v1/messages, POST /v1/chat/completions, GET /v1/models' });
     const ERR_METHOD = JSON.stringify({ error: 'Method not allowed' });
     function checkAuth(req) {
         if (!apiKeyBuf)
@@ -858,7 +677,7 @@ export async function startProxy(opts = {}) {
             }
             // Parse body once, apply OpenAI translation, model override, and sanitization
             let finalBody = body.length > 0 ? body : undefined;
-            let toolMappings = [];
+            let ccToolMap = null;
             if (body.length > 0) {
                 try {
                     const parsed = JSON.parse(body.toString());
@@ -868,67 +687,24 @@ export async function startProxy(opts = {}) {
                     const r = result;
                     // In passthrough mode, skip all Claude-specific injection — OAuth swap only
                     if (!passthrough) {
-                        // ── Stealth layer: make request indistinguishable from real Claude Code ──
-                        // 1. Strip thinking blocks from prior assistant turns (client-side).
-                        // context_management: clear_thinking does NOT reduce input token billing.
-                        // Real Claude Code strips thinking before building the next request.
-                        stripThinkingFromHistory(r);
-                        // 2. Strip client cache_control from messages (prevents overflow — max 4 breakpoints)
-                        const msgs = r.messages;
-                        if (msgs) {
-                            for (const msg of msgs) {
-                                if (Array.isArray(msg.content)) {
-                                    for (const block of msg.content) {
-                                        delete block.cache_control;
-                                    }
-                                }
-                            }
-                        }
-                        // 3. Rewrite tool names to CC equivalents (Anthropic fingerprints on tool names)
-                        toolMappings = rewriteToolNames(r);
-                        // 3. Scrub non-CC fields and normalize field ordering
-                        const reordered = scrubAndReorderFields(r);
-                        for (const key of Object.keys(r))
-                            delete r[key];
-                        Object.assign(r, reordered);
-                        // 3. Inject device identity metadata for session tracking
-                        if (identity.deviceId) {
-                            r.metadata = {
-                                user_id: JSON.stringify({
-                                    device_id: identity.deviceId,
-                                    account_uuid: identity.accountUuid,
-                                    session_id: SESSION_ID,
-                                }),
-                            };
-                        }
-                        // 4. Model-aware defaults matching Claude Code behavior
-                        const modelName = (r.model || '').toLowerCase();
-                        const supportsThinking = !modelName.includes('haiku');
-                        if (supportsThinking && !r.thinking) {
-                            r.thinking = { type: 'adaptive' };
-                        }
-                        // Claude Code always sends max_tokens: 64000. Values above this
-                        // are a fingerprint — cap to match real CC behavior.
-                        if (!r.max_tokens || r.max_tokens !== 64000) {
-                            r.max_tokens = 64000;
-                        }
-                        // Force effort to medium — CC default. Client 'high' is a fingerprint.
-                        if (supportsThinking) {
-                            r.output_config = { effort: 'medium' };
-                        }
-                        if (supportsThinking && !r.context_management) {
-                            r.context_management = { edits: [{ type: 'clear_thinking_20251015', keep: 'all' }] };
-                        }
-                        // 5. Build per-request billing tag matching Claude Code binary (Oz$ algorithm)
+                        // ── Template replay: replace the entire request with a CC template ──
+                        // Instead of transforming signals one by one, we build a new request
+                        // from CC's exact template and inject only the conversation content.
+                        // The upstream sees a genuine CC request structure.
                         const userMsg = extractFirstUserMessage(r);
                         const buildTag = computeBuildTag(userMsg, cliVersion);
                         const cch = computeCch();
                         const fullVersion = `${cliVersion}.${buildTag}`;
-                        const billingTag = `x-anthropic-billing-header: cc_version=${fullVersion}; cc_entrypoint=cli; cch=${cch};`;
-                        // 6. Normalize system prompt to exactly 3 blocks (real Claude Code always sends 3)
+                        const billingTag = `x-anthropic-billing-header: cc_version=${fullVersion}; cc_entrypoint=cli; cch=${cch}; cc_workload=cron;`;
                         const AGENT_IDENTITY = 'You are a Claude agent, built on Anthropic\'s Claude Agent SDK.';
                         const CACHE_1H = { type: 'ephemeral', ttl: '1h' };
-                        r.system = normalizeSystemTo3Blocks(r.system, billingTag, AGENT_IDENTITY, CACHE_1H);
+                        const { body: ccBody, toolMap } = buildCCRequest(r, billingTag, AGENT_IDENTITY, CACHE_1H, { deviceId: identity.deviceId, accountUuid: identity.accountUuid, sessionId: SESSION_ID });
+                        // Store tool map for response reverse-mapping
+                        ccToolMap = toolMap;
+                        // Replace request body entirely with CC template
+                        for (const key of Object.keys(r))
+                            delete r[key];
+                        Object.assign(r, ccBody);
                     }
                     finalBody = Buffer.from(JSON.stringify(r));
                 }
@@ -949,7 +725,8 @@ export async function startProxy(opts = {}) {
             }
             else {
                 // Claude-optimized: full beta set matching real Claude Code (exact order from MITM capture)
-                beta = 'claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14,context-management-2025-06-27,prompt-caching-scope-2026-01-05,advisor-tool-2026-03-01,effort-2025-11-24,fast-mode-2026-02-01';
+                // Beta set from CC v2.1.104 binary RE — some are CC-internal/gated, only include publicly accepted ones
+                beta = 'claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14,context-management-2025-06-27,prompt-caching-scope-2026-01-05,advisor-tool-2026-03-01,effort-2025-11-24,fast-mode-2026-02-01,redact-thinking-2026-02-12,context-1m-2025-08-07,web-search-2025-03-05,advanced-tool-use-2025-11-20,tool-search-tool-2025-10-19';
                 if (clientBeta) {
                     const baseSet = new Set(beta.split(','));
                     const filtered = filterBillableBetas(clientBeta)
@@ -961,7 +738,7 @@ export async function startProxy(opts = {}) {
             const headers = {
                 ...staticHeaders,
                 'Authorization': `Bearer ${accessToken}`,
-                'anthropic-version': req.headers['anthropic-version'] || '2023-06-01',
+                'anthropic-version': passthrough ? (req.headers['anthropic-version'] || '2023-06-01') : '2023-06-01',
                 'anthropic-beta': beta,
                 // Real Claude Code adds x-client-request-id for firstParty + api.anthropic.com
                 'x-client-request-id': randomUUID(),
@@ -1062,9 +839,9 @@ export async function startProxy(opts = {}) {
                         }
                         else {
                             // Reverse tool names in streaming chunks
-                            if (toolMappings.length > 0) {
+                            if (ccToolMap && ccToolMap.size > 0) {
                                 const text = new TextDecoder().decode(value);
-                                res.write(reverseToolNames(text, toolMappings));
+                                res.write(reverseMapResponse(text, ccToolMap));
                             }
                             else {
                                 res.write(value);
@@ -1088,7 +865,8 @@ export async function startProxy(opts = {}) {
                 // Buffer and forward
                 let responseBody = await upstream.text();
                 // Reverse tool name mapping so client sees original names
-                responseBody = reverseToolNames(responseBody, toolMappings);
+                if (ccToolMap)
+                    responseBody = reverseMapResponse(responseBody, ccToolMap);
                 if (isOpenAI && upstream.status >= 200 && upstream.status < 300) {
                     try {
                         const parsed = JSON.parse(responseBody);

package/package.json

@@ -1,64 +1,64 @@
-{
-  "name": "@askalf/dario",
-  "version": "2.11.0",
-  "description": "Use your Claude subscription as an API. No API key needed. Local proxy for Claude Max/Pro subscriptions.",
-  "type": "module",
-  "bin": {
-    "dario": "./dist/cli.js"
-  },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "audit": "npm audit --production --audit-level=high",
-    "prepublishOnly": "npm run build",
-    "start": "node dist/cli.js",
-    "dev": "tsx src/cli.ts",
-    "e2e": "node test/e2e.mjs",
-    "compat": "node test/compat.mjs"
-  },
-  "keywords": [
-    "claude",
-    "anthropic",
-    "oauth",
-    "proxy",
-    "api",
-    "bridge",
-    "subscription",
-    "claude-max",
-    "claude-pro",
-    "llm",
-    "ai",
-    "cli",
-    "developer-tools"
-  ],
-  "author": "askalf (https://github.com/askalf)",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/askalf/dario.git"
-  },
-  "homepage": "https://github.com/askalf/dario",
-  "bugs": {
-    "url": "https://github.com/askalf/dario/issues"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "tsx": "^4.19.0",
-    "typescript": "^5.7.0"
-  }
+{
+  "name": "@askalf/dario",
+  "version": "3.0.2",
+  "description": "Use your Claude subscription as an API. No API key needed. Local proxy for Claude Max/Pro subscriptions.",
+  "type": "module",
+  "bin": {
+    "dario": "./dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "audit": "npm audit --production --audit-level=high",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/cli.js",
+    "dev": "tsx src/cli.ts",
+    "e2e": "node test/e2e.mjs",
+    "compat": "node test/compat.mjs"
+  },
+  "keywords": [
+    "claude",
+    "anthropic",
+    "oauth",
+    "proxy",
+    "api",
+    "bridge",
+    "subscription",
+    "claude-max",
+    "claude-pro",
+    "llm",
+    "ai",
+    "cli",
+    "developer-tools"
+  ],
+  "author": "askalf (https://github.com/askalf)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/askalf/dario.git"
+  },
+  "homepage": "https://github.com/askalf/dario",
+  "bugs": {
+    "url": "https://github.com/askalf/dario/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  }
 }