@askalf/dario 3.9.4 → 3.9.6

package/dist/cc-template.d.ts

@@ -44,6 +44,14 @@ export interface ToolMapping {
      * into fields CC's schema doesn't carry. Unset in default mode.
      */
     clientFields?: string[];
+    /**
+     * Reverse-lookup priority for resolving collisions when multiple client
+     * tools map to the same CC tool. Higher wins. Default 10. Set lower for
+     * niche / lossy translations (e.g. OpenClaw's `process` action-discriminator
+     * tool loses most of its schema when flattened to Bash, so bash/exec
+     * should win the Bash reverse slot when both are declared — dario#37).
+     */
+    reverseScore?: number;
 }
 /**
  * Request context extracted once per incoming request. Source for

package/dist/cc-template.js

@@ -100,40 +100,58 @@ 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.
+    //
+    // reverseScore: 1 makes sure that when a client declares BOTH `process` AND
+    // `exec`/`bash` (OpenClaw does — both are exported from bash-tools.ts), the
+    // reverse lookup picks the bash-family mapping for CC's Bash tool slot
+    // instead of routing CC tool calls through process's action-based shape
+    // and breaking every Bash call with "Unknown action" (dario#37).
     process: {
         ccTool: 'Bash',
         translateArgs: (a) => ({ command: a.action || a.cmd || '' }),
         translateBack: (a) => ({ action: a.command ?? '' }),
+        reverseScore: 1,
     },
     read: {
         ccTool: 'Read',
@@ -307,16 +325,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];
@@ -470,11 +506,22 @@ export function buildCCRequest(clientBody, billingTag, cache1h, identity, opts =
 }
 /**
  * Build the CC-name → {clientName, mapping} reverse lookup used by both
- * the non-streaming and streaming reverse-mappers. Two-pass construction
- * preserves the original identity-protection rule: when a client sent a
- * tool with the literal CC name (e.g. `WebSearch`), that pairing claims
- * the CC slot first so a later unmapped-tool fallback that also lands
- * on `WebSearch` can't overwrite it.
+ * the non-streaming and streaming reverse-mappers.
+ *
+ * Two-pass construction preserves the original identity-protection rule:
+ * when a client sent a tool with the literal CC name (e.g. `WebSearch`),
+ * that pairing claims the CC slot first so a later unmapped-tool fallback
+ * that also lands on `WebSearch` can't overwrite it.
+ *
+ * Within the non-identity pass, collisions are broken by `reverseScore`
+ * (higher wins, default 10). This matters when a client declares two
+ * tools that both map to the same CC tool — OpenClaw declares both
+ * `exec` (bash-like, score 10) and `process` (action-discriminator,
+ * score 1) and both map to Bash. Pre-fix, insertion-order last-wins
+ * routed Bash tool calls through `process`, which interpreted the
+ * command string as an action and returned "Unknown action" for
+ * every call. `process` now has reverseScore: 1 so bash/exec wins
+ * (dario#37).
  */
 function buildReverseLookup(toolMap) {
     const reverseMap = new Map();
@@ -485,12 +532,17 @@ function buildReverseLookup(toolMap) {
             reverseMap.set(mapping.ccTool, { clientName, mapping });
         }
     }
+    // Score-based collision resolution in the non-identity pass.
+    const scoreOf = (m) => m.reverseScore ?? 10;
     for (const [clientName, mapping] of toolMap) {
         if (clientName.toLowerCase() === mapping.ccTool.toLowerCase())
             continue;
         if (identityClaimed.has(mapping.ccTool))
             continue;
-        reverseMap.set(mapping.ccTool, { clientName, mapping });
+        const existing = reverseMap.get(mapping.ccTool);
+        if (!existing || scoreOf(mapping) > scoreOf(existing.mapping)) {
+            reverseMap.set(mapping.ccTool, { clientName, mapping });
+        }
     }
     return reverseMap;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "3.9.4",
+  "version": "3.9.6",
   "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": {