@askalf/dario 6.22.1 → 6.22.2

package/dist/cc-template.js

@@ -46,6 +46,14 @@ export function isAdvertisableToolDefinition(def) {
     const schema = def.input_schema;
     return !!schema && typeof schema === 'object' && typeof schema.type === 'string';
 }
+/**
+ * A client entry for a tool Anthropic defines (`advisor_20260301`): it carries a
+ * `type` other than `custom` and no `input_schema`, because the definition lives
+ * on the server. Nothing can be remapped onto it and nothing can stand in for it.
+ */
+function isAnthropicDefinedTool(def) {
+    return typeof def.type === 'string' && def.type !== 'custom';
+}
 /** Names in the bundle whose definition is not advertisable (see above). Empty on a clean bake. */
 export const CC_TOOL_DEFINITIONS_UNADVERTISABLE = new Set(TEMPLATE.tools.filter((t) => !isAdvertisableToolDefinition(t)).map((t) => String(t.name)));
 /** CC's exact tool definitions for the current platform — filtered from the bundled union. */
@@ -765,6 +773,18 @@ export function detectNonCCByTools(clientTools) {
         // Union set, not the host-filtered one: a win32 client's PowerShell is
         // native regardless of the platform dario itself runs on (v4.8.136).
         if (CC_NATIVE_NAMES_UNION.has(rawName)) {
+            // A union name whose bundled definition is not advertisable is a server
+            // tool: CC never carries a client-callable schema for it (dario#1376).
+            // A client entry of that name that DOES declare an advertisable schema
+            // is the client's own tool wearing a CC name — count it unmapped and
+            // withhold native evidence, or one such entry suppresses every preserve
+            // route (`unmapped > 0 && !native`, and the skipped entry keeps the
+            // ratio below 0.8) and the whole surface goes to remap (#1812).
+            const foreignWearingCCName = CC_TOOL_DEFINITIONS_UNADVERTISABLE.has(rawName) && isAdvertisableToolDefinition(tool);
+            if (foreignWearingCCName) {
+                unmapped++;
+                continue;
+            }
             native = true;
             continue;
         }
@@ -1996,7 +2016,11 @@ export function buildCCRequest(clientBody, billingTag, cacheControl, identity, o
         //   name, arguments untouched, renamed back on the response. A tool that
         //   cannot be carried that way fails the request with its name.
         const CC_FALLBACK_TOOLS = ['Bash', 'Read', 'Grep', 'Glob', 'WebSearch', 'WebFetch'];
-        const namesCCTool = clientTools.some((t) => typeof t.name === 'string' && !isMcpToolName(t.name) && CC_TOOL_NAMES_LOWER.has(t.name.toLowerCase()));
+        // An Anthropic-defined entry for a bundled name counts: it goes out on its
+        // own, so the advertise step never reaches the template and a tool beside it
+        // needs the MCP shape to be seen at all (#1812).
+        const namesCCTool = clientTools.some((t) => typeof t.name === 'string' && !isMcpToolName(t.name) && (CC_TOOL_NAMES_LOWER.has(t.name.toLowerCase())
+            || (CC_TOOL_DEFINITIONS_UNADVERTISABLE.has(t.name) && isAnthropicDefinedTool(t))));
         const declaredNames = new Set(clientTools.map((t) => t.name));
         const uncarried = [];
         for (const tool of clientTools) {
@@ -2246,12 +2270,19 @@ export function buildCCRequest(clientBody, billingTag, cacheControl, identity, o
             // `advisor` captured with an empty schema) is still identity-mapped
             // above; the only usable definition is the client's own, so it goes out
             // verbatim, as MCP tools do. The client's schema is what its parser
-            // expects back in any case.
-            const clientOwnNative = clientTools.filter((t) => typeof t.name === 'string' && CC_TOOL_DEFINITIONS_UNADVERTISABLE.has(t.name) && isAdvertisableToolDefinition(t));
+            // expects back in any case. An Anthropic-defined entry has no schema, so
+            // it is forwarded as declared; dropping it loses the declaration with no
+            // error the client can see (#1812).
+            const clientOwnNative = clientTools.filter((t) => typeof t.name === 'string' && CC_TOOL_DEFINITIONS_UNADVERTISABLE.has(t.name)
+                && (isAdvertisableToolDefinition(t) || isAnthropicDefinedTool(t)));
+            // CC sends its own tools in name order, so a client's definition of one
+            // takes its place among them: `advisor` goes first, not after `Read`.
+            const natives = [...availableCC, ...clientOwnNative]
+                .sort((a, b) => String(a.name).localeCompare(String(b.name)));
             // Client tools outside CC's set follow the MCP tools, under the
             // MCP-shaped names the tool map gave them.
-            ccRequest.tools = availableCC.length > 0 || mcpTools.length > 0 || clientOwnNative.length > 0 || mcpShapedTools.length > 0
-                ? dedupeToolsByName([...availableCC, ...clientOwnNative, ...mcpTools, ...mcpShapedTools])
+            ccRequest.tools = natives.length > 0 || mcpTools.length > 0 || mcpShapedTools.length > 0
+                ? dedupeToolsByName([...natives, ...mcpTools, ...mcpShapedTools])
                 : CC_TOOL_DEFINITIONS;
         }
     }

package/docs/integrations/agent-compat.md

@@ -27,6 +27,8 @@ MCP tools take a third path: anything named `mcp__<server>__<tool>` is neither r
 
 A request that names Claude Code tools and also declares a tool outside `TOOL_MAP` (`Grep`, `Read`, `submit_review`) stays in remap, and the extra tool gets the MCP treatment: it goes out as `mcp__client__<name>` with the client's own schema, after the CC tools, and the model's calls come back under the client's name. Remap advertises only the CC tools such a request declares, so the fallback slot it used to ride was never on the wire. A tool that cannot be carried that way (an Anthropic-defined tool such as `computer_20251124`, a tool with no `input_schema`, or a name longer than 51 characters) fails the request with a 400 that names it. `--preserve-tools` forwards all of them verbatim instead.
 
+Anthropic's `advisor` tool (`advisor_20260301`) is the exception. Its name is in Claude Code's own tool list and the bundle holds only a stub for it, so dario forwards the client's entry as declared and leaves any `server_tool_use` and `advisor_tool_result` blocks in the response untouched. This has not been verified against the live API. An Anthropic-defined entry whose name is in `TOOL_MAP` takes the mapped tool instead: `bash_20250124` becomes `Bash`, and `web_search_20250305` becomes Claude Code's client-side `WebSearch`, so that call comes back for the client to run (#1812).
+
 If your agent's tool names aren't pre-mapped and its tools carry fields CC's schema doesn't have, there are two escape hatches: **`--preserve-tools`** (forward your schema verbatim, lose the CC wire shape) or **`--hybrid-tools`** (keep the CC wire shape, fill request-context fields from headers). See [Custom tool schemas](#custom-tool-schemas).
 
 The OpenAI-compat backend forwards tool definitions byte-for-byte and doesn't need any of this.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "6.22.1",
+  "version": "6.22.2",
   "description": "Use your Claude and ChatGPT subscriptions in Cursor, Cline, Aider, Claude Code and the Agent SDK at subscription pricing, not per-token API bills. One local Anthropic + OpenAI-compatible endpoint: either plan answers either wire shape, opt-in failover when one hits its limit, and a ledger of what each plan absorbed.",
   "type": "module",
   "bin": {