@askalf/dario 2.11.0 → 3.0.0

package/README.md

@@ -455,7 +455,7 @@ Add to your `openclaw.json` models config:
 ### Direct API Mode
 - All Claude models (Opus 4.6, Sonnet 4.6, Haiku 4.5) + 1M extended context aliases (`opus1m`, `sonnet1m`)
 - **Native billing classification** — device identity, per-request billing tag with SHA-256 checksums matching real Claude Code (extracted via binary RE), ensures Max plan limits work correctly
-- **Stealth layer** (v2.9.0) — strips thinking blocks from conversation history (saves 50-80% input tokens), scrubs non-CC fields (`temperature`, `top_p`, `top_k`, `stop_sequences`, `service_tier`), reorders JSON fields to match Claude Code's exact field order, and normalizes system prompts to exactly 3 blocks. Every request is indistinguishable from real Claude Code traffic.
+- **Template replay** (v3.0) — instead of transforming requests signal-by-signal, dario replaces the entire request with a Claude Code template. CC's exact tool definitions, field structure, and parameters are sent upstream. Only your conversation content is preserved. Tested with 40 third-party tools — all route to `five_hour`. See [Discussion #13](https://github.com/askalf/dario/discussions/13) for why this matters.
 - **Adaptive thinking** — matches Claude Code's `{ type: 'adaptive' }` mode for optimal reasoning (auto-skipped for Haiku 4.5)
 - **Effort control** — injects `output_config: { effort: 'medium' }` matching Claude Code's default, or passes through client-specified effort level
 - **Enriched 429 errors** — rate limit errors include utilization %, limiting window, and reset time instead of Anthropic's default `"Error"` message

package/dist/cc-template.d.ts

@@ -0,0 +1,434 @@
+/**
+ * Claude Code request template — the exact tool definitions, system structure,
+ * and request shape that real Claude Code sends.
+ *
+ * Instead of transforming third-party requests signal-by-signal, we replace
+ * the entire request with a CC template and inject only the conversation content.
+ * The upstream sees a genuine CC request. Anthropic can't detect it without
+ * flagging their own binary.
+ *
+ * Source: MITM capture + binary RE of Claude Code v2.1.100
+ */
+/** Claude Code's exact tool definitions (from binary RE + MITM capture). */
+export declare const CC_TOOL_DEFINITIONS: ({
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            command: {
+                type: "string";
+                description: string;
+            };
+            timeout: {
+                type: "number";
+                description: string;
+            };
+            file_path?: undefined;
+            offset?: undefined;
+            limit?: undefined;
+            content?: undefined;
+            old_string?: undefined;
+            new_string?: undefined;
+            replace_all?: undefined;
+            pattern?: undefined;
+            path?: undefined;
+            output_mode?: undefined;
+            url?: undefined;
+            query?: undefined;
+            notebook_path?: undefined;
+            cell_number?: undefined;
+            new_source?: undefined;
+            prompt?: undefined;
+            description?: undefined;
+            question?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            file_path: {
+                type: "string";
+                description: string;
+            };
+            offset: {
+                type: "integer";
+                description: string;
+            };
+            limit: {
+                type: "integer";
+                description: string;
+            };
+            command?: undefined;
+            timeout?: undefined;
+            content?: undefined;
+            old_string?: undefined;
+            new_string?: undefined;
+            replace_all?: undefined;
+            pattern?: undefined;
+            path?: undefined;
+            output_mode?: undefined;
+            url?: undefined;
+            query?: undefined;
+            notebook_path?: undefined;
+            cell_number?: undefined;
+            new_source?: undefined;
+            prompt?: undefined;
+            description?: undefined;
+            question?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            file_path: {
+                type: "string";
+                description: string;
+            };
+            content: {
+                type: "string";
+                description: string;
+            };
+            command?: undefined;
+            timeout?: undefined;
+            offset?: undefined;
+            limit?: undefined;
+            old_string?: undefined;
+            new_string?: undefined;
+            replace_all?: undefined;
+            pattern?: undefined;
+            path?: undefined;
+            output_mode?: undefined;
+            url?: undefined;
+            query?: undefined;
+            notebook_path?: undefined;
+            cell_number?: undefined;
+            new_source?: undefined;
+            prompt?: undefined;
+            description?: undefined;
+            question?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            file_path: {
+                type: "string";
+                description: string;
+            };
+            old_string: {
+                type: "string";
+                description: string;
+            };
+            new_string: {
+                type: "string";
+                description: string;
+            };
+            replace_all: {
+                type: "boolean";
+                description: string;
+                default: boolean;
+            };
+            command?: undefined;
+            timeout?: undefined;
+            offset?: undefined;
+            limit?: undefined;
+            content?: undefined;
+            pattern?: undefined;
+            path?: undefined;
+            output_mode?: undefined;
+            url?: undefined;
+            query?: undefined;
+            notebook_path?: undefined;
+            cell_number?: undefined;
+            new_source?: undefined;
+            prompt?: undefined;
+            description?: undefined;
+            question?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            pattern: {
+                type: "string";
+                description: string;
+            };
+            path: {
+                type: "string";
+                description: string;
+            };
+            command?: undefined;
+            timeout?: undefined;
+            file_path?: undefined;
+            offset?: undefined;
+            limit?: undefined;
+            content?: undefined;
+            old_string?: undefined;
+            new_string?: undefined;
+            replace_all?: undefined;
+            output_mode?: undefined;
+            url?: undefined;
+            query?: undefined;
+            notebook_path?: undefined;
+            cell_number?: undefined;
+            new_source?: undefined;
+            prompt?: undefined;
+            description?: undefined;
+            question?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            pattern: {
+                type: "string";
+                description: string;
+            };
+            path: {
+                type: "string";
+                description: string;
+            };
+            output_mode: {
+                type: "string";
+                enum: string[];
+                description: string;
+            };
+            command?: undefined;
+            timeout?: undefined;
+            file_path?: undefined;
+            offset?: undefined;
+            limit?: undefined;
+            content?: undefined;
+            old_string?: undefined;
+            new_string?: undefined;
+            replace_all?: undefined;
+            url?: undefined;
+            query?: undefined;
+            notebook_path?: undefined;
+            cell_number?: undefined;
+            new_source?: undefined;
+            prompt?: undefined;
+            description?: undefined;
+            question?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            url: {
+                type: "string";
+                description: string;
+            };
+            command?: undefined;
+            timeout?: undefined;
+            file_path?: undefined;
+            offset?: undefined;
+            limit?: undefined;
+            content?: undefined;
+            old_string?: undefined;
+            new_string?: undefined;
+            replace_all?: undefined;
+            pattern?: undefined;
+            path?: undefined;
+            output_mode?: undefined;
+            query?: undefined;
+            notebook_path?: undefined;
+            cell_number?: undefined;
+            new_source?: undefined;
+            prompt?: undefined;
+            description?: undefined;
+            question?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            query: {
+                type: "string";
+                description: string;
+            };
+            command?: undefined;
+            timeout?: undefined;
+            file_path?: undefined;
+            offset?: undefined;
+            limit?: undefined;
+            content?: undefined;
+            old_string?: undefined;
+            new_string?: undefined;
+            replace_all?: undefined;
+            pattern?: undefined;
+            path?: undefined;
+            output_mode?: undefined;
+            url?: undefined;
+            notebook_path?: undefined;
+            cell_number?: undefined;
+            new_source?: undefined;
+            prompt?: undefined;
+            description?: undefined;
+            question?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            notebook_path: {
+                type: "string";
+                description: string;
+            };
+            cell_number: {
+                type: "integer";
+                description: string;
+            };
+            new_source: {
+                type: "string";
+                description: string;
+            };
+            command?: undefined;
+            timeout?: undefined;
+            file_path?: undefined;
+            offset?: undefined;
+            limit?: undefined;
+            content?: undefined;
+            old_string?: undefined;
+            new_string?: undefined;
+            replace_all?: undefined;
+            pattern?: undefined;
+            path?: undefined;
+            output_mode?: undefined;
+            url?: undefined;
+            query?: undefined;
+            prompt?: undefined;
+            description?: undefined;
+            question?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            prompt: {
+                type: "string";
+                description: string;
+            };
+            description: {
+                type: "string";
+                description: string;
+            };
+            command?: undefined;
+            timeout?: undefined;
+            file_path?: undefined;
+            offset?: undefined;
+            limit?: undefined;
+            content?: undefined;
+            old_string?: undefined;
+            new_string?: undefined;
+            replace_all?: undefined;
+            pattern?: undefined;
+            path?: undefined;
+            output_mode?: undefined;
+            url?: undefined;
+            query?: undefined;
+            notebook_path?: undefined;
+            cell_number?: undefined;
+            new_source?: undefined;
+            question?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: {
+            question: {
+                type: "string";
+                description: string;
+            };
+            command?: undefined;
+            timeout?: undefined;
+            file_path?: undefined;
+            offset?: undefined;
+            limit?: undefined;
+            content?: undefined;
+            old_string?: undefined;
+            new_string?: undefined;
+            replace_all?: undefined;
+            pattern?: undefined;
+            path?: undefined;
+            output_mode?: undefined;
+            url?: undefined;
+            query?: undefined;
+            notebook_path?: undefined;
+            cell_number?: undefined;
+            new_source?: undefined;
+            prompt?: undefined;
+            description?: undefined;
+        };
+        required: string[];
+    };
+})[];
+/** Client tool name → CC tool mapping with parameter translation. */
+interface ToolMapping {
+    ccTool: string;
+    translateArgs?: (args: Record<string, unknown>) => Record<string, unknown>;
+    translateBack?: (args: Record<string, unknown>) => Record<string, unknown>;
+}
+/**
+ * Build a CC-template request from a client request.
+ * Replaces the entire request structure — tools, fields, ordering — with
+ * what real CC sends. Only the conversation content is preserved.
+ */
+export declare function buildCCRequest(clientBody: Record<string, unknown>, billingTag: string, agentIdentity: string, cache1h: {
+    type: 'ephemeral';
+    ttl: '1h';
+}, identity: {
+    deviceId: string;
+    accountUuid: string;
+    sessionId: string;
+}): {
+    body: Record<string, unknown>;
+    toolMap: Map<string, ToolMapping>;
+    unmappedTools: string[];
+};
+/**
+ * Reverse-map CC tool calls in a response back to client tool names.
+ */
+export declare function reverseMapResponse(responseBody: string, toolMap: Map<string, ToolMapping>): string;
+export {};

package/dist/cc-template.js

@@ -0,0 +1,303 @@
+/**
+ * Claude Code request template — the exact tool definitions, system structure,
+ * and request shape that real Claude Code sends.
+ *
+ * Instead of transforming third-party requests signal-by-signal, we replace
+ * the entire request with a CC template and inject only the conversation content.
+ * The upstream sees a genuine CC request. Anthropic can't detect it without
+ * flagging their own binary.
+ *
+ * Source: MITM capture + binary RE of Claude Code v2.1.100
+ */
+/** Claude Code's exact tool definitions (from binary RE + MITM capture). */
+export const CC_TOOL_DEFINITIONS = [
+    {
+        name: 'Bash',
+        description: 'Execute a bash command and return its output. The working directory persists between commands. Use this for system commands, file operations, git, npm, etc.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                command: { type: 'string', description: 'The command to execute' },
+                timeout: { type: 'number', description: 'Optional timeout in milliseconds (max 600000)' },
+            },
+            required: ['command'],
+        },
+    },
+    {
+        name: 'Read',
+        description: 'Reads a file from the local filesystem. The file_path parameter must be an absolute path.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                file_path: { type: 'string', description: 'The absolute path to the file to read' },
+                offset: { type: 'integer', description: 'The line number to start reading from' },
+                limit: { type: 'integer', description: 'The number of lines to read' },
+            },
+            required: ['file_path'],
+        },
+    },
+    {
+        name: 'Write',
+        description: 'Writes a file to the local filesystem. This tool will overwrite the existing file if there is one.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                file_path: { type: 'string', description: 'The absolute path to the file to write' },
+                content: { type: 'string', description: 'The content to write to the file' },
+            },
+            required: ['file_path', 'content'],
+        },
+    },
+    {
+        name: 'Edit',
+        description: 'Performs exact string replacements in files. The edit will FAIL if old_string is not unique in the file.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                file_path: { type: 'string', description: 'The absolute path to the file to modify' },
+                old_string: { type: 'string', description: 'The text to replace' },
+                new_string: { type: 'string', description: 'The text to replace it with' },
+                replace_all: { type: 'boolean', description: 'Replace all occurrences', default: false },
+            },
+            required: ['file_path', 'old_string', 'new_string'],
+        },
+    },
+    {
+        name: 'Glob',
+        description: 'Fast file pattern matching tool that works with any codebase size. Returns matching file paths.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                pattern: { type: 'string', description: 'The glob pattern to match files against' },
+                path: { type: 'string', description: 'The directory to search in' },
+            },
+            required: ['pattern'],
+        },
+    },
+    {
+        name: 'Grep',
+        description: 'A powerful search tool built on ripgrep. Supports full regex syntax.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                pattern: { type: 'string', description: 'The regular expression pattern to search for' },
+                path: { type: 'string', description: 'File or directory to search in' },
+                output_mode: { type: 'string', enum: ['content', 'files_with_matches', 'count'], description: 'Output mode' },
+            },
+            required: ['pattern'],
+        },
+    },
+    {
+        name: 'WebFetch',
+        description: 'Fetches a URL from the internet and returns the content.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'The URL to fetch' },
+            },
+            required: ['url'],
+        },
+    },
+    {
+        name: 'WebSearch',
+        description: 'Searches the web using a search engine and returns results.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'The search query' },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'NotebookEdit',
+        description: 'Edits a Jupyter notebook cell.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                notebook_path: { type: 'string', description: 'Path to the notebook file' },
+                cell_number: { type: 'integer', description: 'Cell number to edit' },
+                new_source: { type: 'string', description: 'New cell source code' },
+            },
+            required: ['notebook_path', 'cell_number', 'new_source'],
+        },
+    },
+    {
+        name: 'Agent',
+        description: 'Launch a new agent to handle complex tasks. The agent runs in an isolated context.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                prompt: { type: 'string', description: 'The task for the agent to perform' },
+                description: { type: 'string', description: 'A short description of the task' },
+            },
+            required: ['description', 'prompt'],
+        },
+    },
+    {
+        name: 'AskUserQuestion',
+        description: 'Ask the user a question and wait for their response.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                question: { type: 'string', description: 'The question to ask' },
+            },
+            required: ['question'],
+        },
+    },
+];
+const TOOL_MAP = {
+    // Direct maps
+    bash: { ccTool: 'Bash', translateArgs: (a) => ({ command: a.cmd || a.command || a.c || '' }) },
+    exec: { ccTool: 'Bash', translateArgs: (a) => ({ command: a.cmd || a.command || a.c || '' }) },
+    shell: { ccTool: 'Bash', translateArgs: (a) => ({ command: a.cmd || a.command || a.c || '' }) },
+    run: { ccTool: 'Bash', translateArgs: (a) => ({ command: a.cmd || a.command || '' }) },
+    command: { ccTool: 'Bash', translateArgs: (a) => ({ command: a.cmd || a.command || '' }) },
+    terminal: { ccTool: 'Bash', translateArgs: (a) => ({ command: a.cmd || a.command || '' }) },
+    process: { ccTool: 'Bash', translateArgs: (a) => ({ command: a.action || a.cmd || '' }) },
+    read: { ccTool: 'Read', translateArgs: (a) => ({ file_path: a.path || a.file_path || '' }) },
+    read_file: { ccTool: 'Read', translateArgs: (a) => ({ file_path: a.path || a.file_path || '' }) },
+    write: { ccTool: 'Write', translateArgs: (a) => ({ file_path: a.path || a.file_path || '', content: a.content || '' }) },
+    write_file: { ccTool: 'Write', translateArgs: (a) => ({ file_path: a.path || a.file_path || '', content: a.content || '' }) },
+    edit: { ccTool: 'Edit', translateArgs: (a) => ({ file_path: a.path || a.file_path || '', old_string: a.old || a.old_string || '', new_string: a.new || a.new_string || '' }) },
+    edit_file: { ccTool: 'Edit' },
+    glob: { ccTool: 'Glob' },
+    find_files: { ccTool: 'Glob', translateArgs: (a) => ({ pattern: a.pattern || a.query || '' }) },
+    list_files: { ccTool: 'Glob', translateArgs: (a) => ({ pattern: a.pattern || '*' }) },
+    grep: { ccTool: 'Grep' },
+    search: { ccTool: 'Grep', translateArgs: (a) => ({ pattern: a.query || a.pattern || '' }) },
+    search_files: { ccTool: 'Grep', translateArgs: (a) => ({ pattern: a.query || a.pattern || '' }) },
+    web_search: { ccTool: 'WebSearch', translateArgs: (a) => ({ query: a.query || a.q || '' }) },
+    websearch: { ccTool: 'WebSearch', translateArgs: (a) => ({ query: a.query || a.q || '' }) },
+    web_fetch: { ccTool: 'WebFetch', translateArgs: (a) => ({ url: a.url || a.u || '' }) },
+    webfetch: { ccTool: 'WebFetch', translateArgs: (a) => ({ url: a.url || a.u || '' }) },
+    fetch: { ccTool: 'WebFetch', translateArgs: (a) => ({ url: a.url || '' }) },
+    browse: { ccTool: 'WebFetch', translateArgs: (a) => ({ url: a.url || '' }) },
+    notebook: { ccTool: 'NotebookEdit' },
+    notebook_edit: { ccTool: 'NotebookEdit' },
+};
+/**
+ * Build a CC-template request from a client request.
+ * Replaces the entire request structure — tools, fields, ordering — with
+ * what real CC sends. Only the conversation content is preserved.
+ */
+export function buildCCRequest(clientBody, billingTag, agentIdentity, cache1h, identity) {
+    const model = clientBody.model || 'claude-sonnet-4-6';
+    const isHaiku = model.toLowerCase().includes('haiku');
+    const messages = clientBody.messages || [];
+    const clientTools = clientBody.tools;
+    const stream = clientBody.stream ?? false;
+    // ── Strip thinking from history ──
+    for (const msg of messages) {
+        if (msg.role === 'assistant' && Array.isArray(msg.content)) {
+            msg.content = msg.content.filter(b => b.type !== 'thinking');
+        }
+        // Strip cache_control from message blocks
+        if (Array.isArray(msg.content)) {
+            for (const block of msg.content) {
+                delete block.cache_control;
+            }
+        }
+    }
+    // ── Build tool mapping ──
+    const activeToolMap = new Map();
+    const unmappedTools = [];
+    if (clientTools) {
+        for (const tool of clientTools) {
+            const name = (tool.name || '').toLowerCase();
+            const mapping = TOOL_MAP[name];
+            if (mapping) {
+                activeToolMap.set(tool.name, mapping);
+            }
+            else {
+                unmappedTools.push(tool.name);
+                // Unknown tools become Bash commands with description as context
+                activeToolMap.set(tool.name, {
+                    ccTool: 'Bash',
+                    translateArgs: (a) => ({
+                        command: `echo "Tool ${tool.name} called with: ${JSON.stringify(a).slice(0, 200)}"`,
+                    }),
+                });
+            }
+        }
+    }
+    // ── Remap tool_use references in message history ──
+    for (const msg of messages) {
+        if (Array.isArray(msg.content)) {
+            for (const block of msg.content) {
+                if (block.type === 'tool_use' && typeof block.name === 'string') {
+                    const mapping = activeToolMap.get(block.name);
+                    if (mapping) {
+                        block.name = mapping.ccTool;
+                        if (mapping.translateArgs && block.input) {
+                            block.input = mapping.translateArgs(block.input);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // ── Merge system prompt ──
+    let systemText = '';
+    const sys = clientBody.system;
+    if (typeof sys === 'string') {
+        systemText = sys;
+    }
+    else if (Array.isArray(sys)) {
+        systemText = sys
+            .filter(b => b.text && !b.text.includes('x-anthropic-billing-header:'))
+            .map(b => b.text)
+            .join('\n\n');
+    }
+    // ── Build the CC request from template ──
+    const ccRequest = {
+        model,
+        messages,
+        system: [
+            { type: 'text', text: billingTag },
+            { type: 'text', text: agentIdentity, cache_control: cache1h },
+            { type: 'text', text: systemText || 'You are a helpful assistant.', cache_control: cache1h },
+        ],
+        max_tokens: 64000,
+    };
+    // Model-specific fields
+    if (!isHaiku) {
+        ccRequest.thinking = { type: 'adaptive' };
+        ccRequest.output_config = { effort: 'medium' };
+        ccRequest.context_management = { edits: [{ type: 'clear_thinking_20251015', keep: 'all' }] };
+    }
+    // Always include metadata
+    ccRequest.metadata = {
+        user_id: JSON.stringify({
+            device_id: identity.deviceId,
+            account_uuid: identity.accountUuid,
+            session_id: identity.sessionId,
+        }),
+    };
+    ccRequest.stream = stream;
+    // Use CC's exact tool definitions — not the client's
+    if (clientTools && clientTools.length > 0) {
+        ccRequest.tools = CC_TOOL_DEFINITIONS;
+    }
+    return { body: ccRequest, toolMap: activeToolMap, unmappedTools };
+}
+/**
+ * Reverse-map CC tool calls in a response back to client tool names.
+ */
+export function reverseMapResponse(responseBody, toolMap) {
+    if (toolMap.size === 0)
+        return responseBody;
+    let result = responseBody;
+    // Build reverse map: CC tool name → original client tool name
+    const reverseMap = new Map();
+    for (const [clientName, mapping] of toolMap) {
+        // Only add if not a direct CC tool name
+        if (clientName.toLowerCase() !== mapping.ccTool.toLowerCase()) {
+            reverseMap.set(mapping.ccTool, clientName);
+        }
+    }
+    for (const [ccName, clientName] of reverseMap) {
+        result = result.replace(new RegExp(`"name"\\s*:\\s*"${ccName}"`, 'g'), `"name":"${clientName}"`);
+    }
+    return result;
+}

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
@@ -859,6 +860,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 +870,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 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));
                 }
@@ -1062,9 +1021,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 +1047,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,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "2.11.0",
+  "version": "3.0.0",
   "description": "Use your Claude subscription as an API. No API key needed. Local proxy for Claude Max/Pro subscriptions.",
   "type": "module",
   "bin": {