@askalf/dario 3.9.3 → 3.9.5

package/dist/cc-template.js

@@ -100,36 +100,47 @@ function injectContextFields(input, clientFields, ctx) {
 }
 const TOOL_MAP = {
     // Direct maps
+    // Note on translateBack field names: the vast majority of client bash-like
+    // tools use `command` (the Anthropic convention), not `cmd`. OpenClaw's
+    // `exec` tool takes `{command, workdir, env, ...}` (dario#36 triage).
+    // Hybrid mode overrides these with the actual client schema via clientFields,
+    // but default mode relies on these output names being the common case.
     bash: {
         ccTool: 'Bash',
         translateArgs: (a) => ({ command: a.cmd || a.command || a.c || '' }),
-        translateBack: (a) => ({ cmd: a.command ?? '' }),
+        translateBack: (a) => ({ command: a.command ?? '' }),
     },
     exec: {
         ccTool: 'Bash',
         translateArgs: (a) => ({ command: a.cmd || a.command || a.c || '' }),
-        translateBack: (a) => ({ cmd: a.command ?? '' }),
+        translateBack: (a) => ({ command: a.command ?? '' }),
     },
     shell: {
         ccTool: 'Bash',
         translateArgs: (a) => ({ command: a.cmd || a.command || a.c || '' }),
-        translateBack: (a) => ({ cmd: a.command ?? '' }),
+        translateBack: (a) => ({ command: a.command ?? '' }),
     },
     run: {
         ccTool: 'Bash',
         translateArgs: (a) => ({ command: a.cmd || a.command || '' }),
-        translateBack: (a) => ({ cmd: a.command ?? '' }),
+        translateBack: (a) => ({ command: a.command ?? '' }),
     },
     command: {
         ccTool: 'Bash',
         translateArgs: (a) => ({ command: a.cmd || a.command || '' }),
-        translateBack: (a) => ({ cmd: a.command ?? '' }),
+        translateBack: (a) => ({ command: a.command ?? '' }),
     },
     terminal: {
         ccTool: 'Bash',
         translateArgs: (a) => ({ command: a.cmd || a.command || '' }),
-        translateBack: (a) => ({ cmd: a.command ?? '' }),
+        translateBack: (a) => ({ command: a.command ?? '' }),
     },
+    // `process` is OpenClaw's session-manager tool — it's an action-discriminator
+    // shape {action: "list"|"poll"|"log"|..., sessionId?, ...}. Flattening it onto
+    // Bash.command loses all sibling fields (data, keys, hex, literal, text, ...),
+    // so the model upstream can't actually drive it. Kept mapped for fingerprint
+    // continuity but the reverse translation is inherently lossy — clients with a
+    // process-style tool should use --preserve-tools instead of --hybrid-tools.
     process: {
         ccTool: 'Bash',
         translateArgs: (a) => ({ command: a.action || a.cmd || '' }),
@@ -307,16 +318,34 @@ export function buildCCRequest(clientBody, billingTag, cache1h, identity, opts =
                 claimedCC.add(mapping.ccTool);
             }
         }
+        // Unmapped-tool handling differs by mode:
+        //
+        // - Default mode: round-robin to CC fallback tools. The model sees the CC
+        //   tool set, any tool call is "something", and we best-effort relay it
+        //   back to the client tool name. Broken-by-design for clients with rich
+        //   discriminator tools (OpenClaw lobster/memory_get, dario#36), but
+        //   preserves the old behavior for simple clients that don't have many
+        //   unmapped tools.
+        //
+        // - Hybrid mode: DROP unmapped tools entirely. We can't forward them to
+        //   the upstream (adding to CC_TOOL_DEFINITIONS breaks the fingerprint),
+        //   and round-robin mapping produces nonsense shapes on the reverse path
+        //   (lobster.translateBack(Glob.input) → {pattern: "..."} when lobster
+        //   wants {action: "run"}). Better to let the model not see those tools
+        //   than to pretend they exist and corrupt every call. Users needing
+        //   every client tool to actually work must use --preserve-tools.
         const CC_FALLBACK_TOOLS = ['Bash', 'Read', 'Grep', 'Glob', 'WebSearch', 'WebFetch'];
         for (const tool of clientTools) {
             const name = (tool.name || '').toLowerCase();
             if (TOOL_MAP[name])
                 continue;
             unmappedTools.push(tool.name);
-            // Exclude CC tools the client already uses so we never create a
-            // two-client-names-to-one-CC-tool collision. If every fallback is
-            // claimed (rare: client already uses 6+ CC tools), fall back to the
-            // full pool and accept the ambiguity.
+            if (opts.hybridTools)
+                continue; // dropped — see comment above
+            // Default mode: round-robin distribution. Exclude CC tools the client
+            // already uses so we never create a two-client-names-to-one-CC-tool
+            // collision. If every fallback is claimed (rare: client already uses 6+
+            // CC tools), fall back to the full pool and accept the ambiguity.
             const pool = CC_FALLBACK_TOOLS.filter(t => !claimedCC.has(t));
             const fallbackPool = pool.length > 0 ? pool : CC_FALLBACK_TOOLS;
             const fallbackTool = fallbackPool[(unmappedTools.length - 1) % fallbackPool.length];

package/dist/proxy.js

@@ -420,6 +420,14 @@ export async function startProxy(opts = {}) {
     };
     let requestCount = 0;
     const semaphore = new Semaphore(MAX_CONCURRENT);
+    // Cache context-1m beta availability. Set false once per account (or process
+    // in single-account mode) after the first "long context" rejection, so we
+    // skip sending context-1m on every subsequent request instead of paying the
+    // round-trip + retry cost each time. Keyed by account alias; `__default__`
+    // is the single-account slot. Reported by @boeingchoco in dario#36 — the
+    // retry loop was firing on every POST with hybrid-tools + OC.
+    const context1mUnavailable = new Set();
+    const ACCOUNT_KEY_SINGLE = '__default__';
     // Rate governor — minimum 500ms between requests. Fast enough for agents,
     // slow enough to not look like a scripted flood of identical traffic.
     let lastRequestTime = 0;
@@ -693,8 +701,14 @@ export async function startProxy(opts = {}) {
             }
             else {
                 // CC v2.1.104 beta set — 8 flags in the order Claude Code sends them.
-                // context-1m requires Extra Usage — if it 400s, we auto-retry without it.
-                beta = 'claude-code-20250219,oauth-2025-04-20,context-1m-2025-08-07,interleaved-thinking-2025-05-14,context-management-2025-06-27,prompt-caching-scope-2026-01-05,advisor-tool-2026-03-01,effort-2025-11-24';
+                // context-1m requires Extra Usage — if it 400s, we auto-retry without
+                // it, and cache the rejection so subsequent requests on this account
+                // skip context-1m entirely (dario#36).
+                const acctKey = poolAccount?.alias ?? ACCOUNT_KEY_SINGLE;
+                const skipContext1m = context1mUnavailable.has(acctKey);
+                beta = skipContext1m
+                    ? 'claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,context-management-2025-06-27,prompt-caching-scope-2026-01-05,advisor-tool-2026-03-01,effort-2025-11-24'
+                    : 'claude-code-20250219,oauth-2025-04-20,context-1m-2025-08-07,interleaved-thinking-2025-05-14,context-management-2025-06-27,prompt-caching-scope-2026-01-05,advisor-tool-2026-03-01,effort-2025-11-24';
                 if (clientBeta) {
                     const baseSet = new Set(beta.split(','));
                     const filtered = filterBillableBetas(clientBeta)
@@ -792,8 +806,13 @@ export async function startProxy(opts = {}) {
                         || peekedBody.includes('Extra usage is required')
                         || peekedBody.includes('long_context');
                     if (isLongContextError) {
-                        if (verbose)
-                            console.log(`[dario] #${requestCount} context-1m rejected (${upstream.status}) — retrying without it`);
+                        // Cache the rejection so future requests on this account skip
+                        // context-1m up front instead of re-paying the 400/429 round-trip.
+                        const acctKey = poolAccount?.alias ?? ACCOUNT_KEY_SINGLE;
+                        const firstRejection = !context1mUnavailable.has(acctKey);
+                        context1mUnavailable.add(acctKey);
+                        if (verbose && firstRejection)
+                            console.log(`[dario] #${requestCount} context-1m rejected (${upstream.status}) — retrying without it (cached for session)`);
                         const reducedBeta = beta.replace(',context-1m-2025-08-07', '').replace('context-1m-2025-08-07,', '');
                         const retryHeaders = { ...headers, 'anthropic-beta': reducedBeta };
                         const retry = await fetch(targetBase, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "3.9.3",
+  "version": "3.9.5",
   "description": "A local LLM router. One endpoint, every provider — Claude subscriptions, OpenAI, OpenRouter, Groq, local LiteLLM, any OpenAI-compat endpoint — your tools don't need to change.",
   "type": "module",
   "bin": {