@askalf/dario 2.9.5 → 2.11.0

package/dist/proxy.js

@@ -267,6 +267,112 @@ function stripThinkingFromHistory(body) {
  * 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',
@@ -752,6 +858,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 = [];
             if (body.length > 0) {
                 try {
                     const parsed = JSON.parse(body.toString());
@@ -766,9 +873,21 @@ export async function startProxy(opts = {}) {
                         // context_management: clear_thinking does NOT reduce input token billing.
                         // Real Claude Code strips thinking before building the next request.
                         stripThinkingFromHistory(r);
-                        // 2. Scrub non-CC fields and normalize field ordering
+                        // 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);
-                        // Copy reordered keys back (r is a reference to result)
                         for (const key of Object.keys(r))
                             delete r[key];
                         Object.assign(r, reordered);
@@ -793,7 +912,8 @@ export async function startProxy(opts = {}) {
                         if (!r.max_tokens || r.max_tokens !== 64000) {
                             r.max_tokens = 64000;
                         }
-                        if (supportsThinking && !r.output_config) {
+                        // Force effort to medium — CC default. Client 'high' is a fingerprint.
+                        if (supportsThinking) {
                             r.output_config = { effort: 'medium' };
                         }
                         if (supportsThinking && !r.context_management) {
@@ -941,7 +1061,14 @@ export async function startProxy(opts = {}) {
                             }
                         }
                         else {
-                            res.write(value);
+                            // Reverse tool names in streaming chunks
+                            if (toolMappings.length > 0) {
+                                const text = new TextDecoder().decode(value);
+                                res.write(reverseToolNames(text, toolMappings));
+                            }
+                            else {
+                                res.write(value);
+                            }
                         }
                     }
                     // Flush remaining buffer
@@ -959,9 +1086,10 @@ export async function startProxy(opts = {}) {
             }
             else {
                 // Buffer and forward
-                const responseBody = await upstream.text();
+                let responseBody = await upstream.text();
+                // Reverse tool name mapping so client sees original names
+                responseBody = reverseToolNames(responseBody, toolMappings);
                 if (isOpenAI && upstream.status >= 200 && upstream.status < 300) {
-                    // Translate Anthropic response → OpenAI format
                     try {
                         const parsed = JSON.parse(responseBody);
                         res.end(JSON.stringify(anthropicToOpenai(parsed)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "2.9.5",
+  "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": {
@@ -61,4 +61,4 @@
     "tsx": "^4.19.0",
     "typescript": "^5.7.0"
   }
-}
+}