@askalf/dario 6.22.1 → 6.22.3

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/dist/proxy.js

@@ -68,6 +68,7 @@ import { waitForIdle, drainThenClose, shutdownTimers, DEFAULT_SHUTDOWN_GRACE_MS
 import { clampTimerMs } from './timer-ms.js';
 import { upstreamDeadline } from './upstream-deadline.js';
 import { redactSecrets } from './redact.js';
+import { parseRequestLogQuery, readRequestLog } from './request-log.js';
 import { BAKED_BASE_MODELS, withLongContextVariants, buildOpenAIModelsList, getModelCatalog, getCachedBases, resolveAliasAgainst, prewarmModelCatalog, retryModelCatalogNow, isSuspendedModel } from './model-catalog.js';
 import { classifyUpstreamRejection, diagnosticSnippet, POOL_PARKED } from './upstream-rejection.js';
 import { ProviderCooldowns, canAttempt, allProvidersCooled, cooldownRetryAfterMs, parseRetryAfterMs, ALL_PROVIDERS_RATE_LIMITED, } from './provider-cooldown.js';
@@ -1146,7 +1147,7 @@ export function sanitizeError(err) {
  * inherit read-only auth by accident.
  */
 export const ANALYTICS_READ_PATHS = [
-    '/analytics', '/analytics/ledger', '/analytics/stream', '/analytics/view', '/analytics/donuts.svg', '/metrics',
+    '/analytics', '/analytics/ledger', '/analytics/requests', '/analytics/stream', '/analytics/view', '/analytics/donuts.svg', '/metrics',
 ];
 export function isAnalyticsReadPath(urlPath) {
     return ANALYTICS_READ_PATHS.includes(urlPath);
@@ -3369,6 +3370,27 @@ export async function startProxy(opts = {}) {
             res.end(JSON.stringify({ path: ledger.path, ...ledger.snapshot(), priced: ledger.priced() }));
             return;
         }
+        // The request log read back by byte offset (request-log.ts), for a reader
+        // that cannot share the file. A 404 says the log is off, as the ledger's does.
+        if (urlPath === '/analytics/requests' && req.method === 'GET') {
+            if (!logFilePath) {
+                res.writeHead(404, JSON_HEADERS);
+                res.end(JSON.stringify({ error: 'request log disabled', hint: 'start with --log-file=<path> / DARIO_LOG_FILE' }));
+                return;
+            }
+            const { after, mark } = parseRequestLogQuery(req.url ?? '/');
+            try {
+                const page = await readRequestLog(logFilePath, after, mark);
+                res.writeHead(200, JSON_HEADERS);
+                res.end(JSON.stringify(page));
+            }
+            catch (err) {
+                console.error(`[dario] request log read failed: ${sanitizeError(err)}`);
+                res.writeHead(500, JSON_HEADERS);
+                res.end(JSON.stringify({ error: 'request log unreadable' }));
+            }
+            return;
+        }
         // Analytics live stream — SSE of new RequestRecord JSON, one event
         // per record as it lands. Drives the v4 TUI's Hits tab. Sends a
         // backlog of the most-recent 50 records on connect so a freshly-

package/dist/request-log.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The `--log-file` request log by byte offset, for GET /analytics/requests.
+ *
+ * A page is whole lines. The last line of a read may still be on its way to
+ * disk, so anything after the final newline waits for the next read. A line too
+ * long for a page can never be served, so once it is complete it is passed over
+ * and counted, or a reader would stop there for good.
+ *
+ * An offset means nothing in a different file, and a replacement can be longer
+ * than the reader's offset, so the size alone cannot show it. Each page carries
+ * a mark, a hash of the first and last KiB of what has been read. A reader hands
+ * it back with the offset, and a mark that no longer matches sends it to the
+ * start. Every line opens with its own timestamp, so a different log differs at
+ * the head: that covers a rename, a truncation and a reused inode alike, where a
+ * file identity would miss a log truncated in place and grown past the offset.
+ *
+ * The log is append-only, and the mark is built on that. Hashing all of what has
+ * been read would cost a pass over the whole file per page, so an edit to the
+ * middle of it that keeps both ends is the one change this cannot see. Nothing in
+ * dario rewrites the file, and a rotation does not leave its first line in place.
+ */
+export declare const REQUEST_LOG_PAGE_BYTES: number;
+export interface RequestLogPage {
+    /** The file's size at this read. `size - next` is what is still unread. */
+    size: number;
+    /** The offset to ask for next. Equal to `after` when no whole line is ready. */
+    next: number;
+    /** Hand this back with `next`. Empty at the start of the file, where there is nothing to check. */
+    mark: string;
+    records: unknown[];
+    /** Whole lines that did not parse. They are passed over, and counted here so that is visible. */
+    unreadable: number;
+}
+/** `?after=` and `?mark=` from a request URL. Anything unusable reads as the start of the file. */
+export declare function parseRequestLogQuery(url: string): {
+    after: number;
+    mark: string;
+};
+/**
+ * One page of the log from byte `after`. A log with nothing in it yet is an
+ * empty page, not an error. `pageBytes` is the caller's, never the request's.
+ */
+export declare function readRequestLog(path: string, after?: number, mark?: string, pageBytes?: number): Promise<RequestLogPage>;

package/dist/request-log.js

@@ -0,0 +1,107 @@
+/**
+ * The `--log-file` request log by byte offset, for GET /analytics/requests.
+ *
+ * A page is whole lines. The last line of a read may still be on its way to
+ * disk, so anything after the final newline waits for the next read. A line too
+ * long for a page can never be served, so once it is complete it is passed over
+ * and counted, or a reader would stop there for good.
+ *
+ * An offset means nothing in a different file, and a replacement can be longer
+ * than the reader's offset, so the size alone cannot show it. Each page carries
+ * a mark, a hash of the first and last KiB of what has been read. A reader hands
+ * it back with the offset, and a mark that no longer matches sends it to the
+ * start. Every line opens with its own timestamp, so a different log differs at
+ * the head: that covers a rename, a truncation and a reused inode alike, where a
+ * file identity would miss a log truncated in place and grown past the offset.
+ *
+ * The log is append-only, and the mark is built on that. Hashing all of what has
+ * been read would cost a pass over the whole file per page, so an edit to the
+ * middle of it that keeps both ends is the one change this cannot see. Nothing in
+ * dario rewrites the file, and a rotation does not leave its first line in place.
+ */
+import { createHash } from 'node:crypto';
+import { open } from 'node:fs/promises';
+export const REQUEST_LOG_PAGE_BYTES = 1024 * 1024;
+/** Longer than a log line, so each end of a mark takes in a line's timestamp and request number. */
+const MARK_BYTES = 1024;
+/** `?after=` and `?mark=` from a request URL. Anything unusable reads as the start of the file. */
+export function parseRequestLogQuery(url) {
+    const params = new URL(url, 'http://dario.invalid').searchParams;
+    const after = Number(params.get('after'));
+    return {
+        after: Number.isSafeInteger(after) && after > 0 ? after : 0,
+        mark: params.get('mark') ?? '',
+    };
+}
+async function markAt(file, offset) {
+    const length = Math.min(MARK_BYTES, offset);
+    if (length <= 0)
+        return '';
+    const hash = createHash('sha256');
+    const window = Buffer.alloc(MARK_BYTES);
+    for (const start of [0, offset - length]) {
+        const { bytesRead } = await file.read(window, 0, length, start);
+        hash.update(window.subarray(0, bytesRead));
+    }
+    return hash.digest('hex').slice(0, 32);
+}
+/** The offset just past the next newline at or after `from`, or null when none has reached disk yet. */
+async function pastNextNewline(file, from, scratch) {
+    let at = from;
+    for (;;) {
+        const { bytesRead } = await file.read(scratch, 0, scratch.length, at);
+        if (bytesRead === 0)
+            return null;
+        const newline = scratch.subarray(0, bytesRead).indexOf(0x0a);
+        if (newline >= 0)
+            return at + newline + 1;
+        at += bytesRead;
+    }
+}
+/**
+ * One page of the log from byte `after`. A log with nothing in it yet is an
+ * empty page, not an error. `pageBytes` is the caller's, never the request's.
+ */
+export async function readRequestLog(path, after = 0, mark = '', pageBytes = REQUEST_LOG_PAGE_BYTES) {
+    let file;
+    try {
+        file = await open(path, 'r');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return { size: 0, next: 0, mark: '', records: [], unreadable: 0 };
+        throw err;
+    }
+    try {
+        const { size } = await file.stat();
+        if (after > size || (after > 0 && mark && await markAt(file, after) !== mark)) {
+            return { size, next: 0, mark: '', records: [], unreadable: 0 };
+        }
+        const page = Buffer.alloc(pageBytes);
+        const { bytesRead } = await file.read(page, 0, pageBytes, after);
+        const end = page.subarray(0, bytesRead).lastIndexOf(0x0a);
+        if (end < 0) {
+            const past = bytesRead === pageBytes ? await pastNextNewline(file, after + pageBytes, page) : null;
+            if (past !== null)
+                return { size, next: past, mark: await markAt(file, past), records: [], unreadable: 1 };
+            return { size, next: after, mark: await markAt(file, after), records: [], unreadable: 0 };
+        }
+        const records = [];
+        let unreadable = 0;
+        for (const line of page.subarray(0, end).toString('utf-8').split('\n')) {
+            if (!line)
+                continue;
+            try {
+                records.push(JSON.parse(line));
+            }
+            catch {
+                unreadable++;
+            }
+        }
+        const next = after + end + 1;
+        return { size, next, mark: await markAt(file, next), records, unreadable };
+    }
+    finally {
+        await file.close();
+    }
+}

package/docs/analytics.md

@@ -11,6 +11,7 @@ Every surface below is a view over those two. Nothing here collects anything new
 | `GET /analytics` | window summary (with `window.perFiveMinutes`, the hour in twelve bins) + `queue` snapshot + `overage` (the halt state, for a reader who cannot open `/admin/resume`) + `lifetime` ledger summary | JSON |
 | `GET /analytics/ledger` | the ledger's per-day table, with `priced`: the same rows as USD at each day's rate | JSON |
 | `GET /analytics/stream` | live tail of request records (drives the TUI) | SSE |
+| `GET /analytics/requests` | the `--log-file` request log by byte offset: `?after=<next>&mark=<mark>` gives `{ size, next, mark, records, unreadable }`, up to 1 MiB of whole lines. Hand back `next` and `mark` together. The mark covers the first and last KiB of what has been read: when it no longer matches, the file was replaced or truncated and `next` is 0. The log is append-only, so an edit to the middle of what was read that keeps both ends is not detected. Survives a restart, which the stream does not. 404 when the log is off | JSON |
 | `GET /metrics` | the same state as Prometheus text exposition | text/plain 0.0.4 |
 | `GET /analytics/donuts.svg` | spend by model / by key / by billing | SVG |
 | `GET /analytics/view` | the server-rendered summary (the page before 6.17; still served) | HTML fragment |

package/docs/cli-and-endpoints.md

@@ -22,7 +22,7 @@
 | `GET /health` · `GET /livez` | Serviceability (503 when not) · liveness. `/health?probe=1` sends one real request |
 | `GET /status` · `GET /accounts` · `GET /analytics` | OAuth detail · per-seat utilization and grant age · per-account / per-model stats and burn rate |
 | `POST /v1/messages/count_tokens` · `POST /v1/complete` | Token counting and the legacy Text Completions shape |
-| `GET /analytics/stream` · `GET /analytics/ledger` · `GET /codex` | Live analytics over SSE · the ledger's per-day table · ChatGPT-seat status and utilisation (used %, window, reset, headroom), read without spending or exposing a token |
+| `GET /analytics/stream` · `GET /analytics/requests` · `GET /analytics/ledger` · `GET /codex` | Live analytics over SSE · the `--log-file` request log by byte offset · the ledger's per-day table · ChatGPT-seat status and utilisation (used %, window, reset, headroom), read without spending or exposing a token |
 | `/admin/*` | Provisioning, `GET /admin/accounts`, `/admin/keys`, `POST /admin/resume`; only with `DARIO_ADMIN=1` ([admin API](admin-api.md)) |
 
 Flags: [commands.md](commands.md), plus `dario --help --all` for the ones it doesn't list yet (`--effort`, `--max-tokens`, `--model-alias`, `--fast-model`, session rotation, concurrency caps, the pacing knobs behind `--stealth`) · env vars grouped by task, for Docker / k8s / systemd: [configuration.md](configuration.md) · SDK examples: [usage.md](usage.md).

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.3",
   "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": {