@askalf/dario 3.30.12 → 3.30.13

package/README.md

@@ -277,7 +277,7 @@ Dario's built-in `TOOL_MAP` carries **~66 schema-verified entries** covering the
 | GitHub Copilot | `run_in_terminal`, `insert_edit_into_file`, `semantic_search`, `codebase_search`, `list_dir`, `fetch_webpage` |
 | OpenHands | `execute_bash`, `str_replace_editor` |
 | OpenClaw | `exec`, `process`, `web_search`, `web_fetch`, `browser`, `message` |
-| Hermes | `terminal`, `patch`, `web_extract`, `clarify` |
+| Hermes Agent (Nous Research) | `terminal`, `process`, `read_file`, `write_file`, `patch`, `search_files`, `web_search`, `web_extract`, `todo` mapped directly. Hermes-specific tools (`browser_*`, `vision_analyze`, `image_generate`, `skill_*`, `memory`, `session_search`, `cronjob`, `send_message`, `ha_*`, `mixture_of_agents`, `delegate_task`, `execute_code`, `text_to_speech`) have no CC equivalent and auto-preserve through the identity detector (`You are Hermes Agent` or `created by Nous Research` in the system prompt flips dario into preserve-tools for Hermes sessions automatically — v3.30.13). Also consider `--max-tokens=client` so Hermes's 64k/128k per-model caps survive dario's outbound pin. |
 
 Text-tool clients (Cline / Kilo Code / Roo Code and forks) are auto-detected via system-prompt fingerprint and automatically flipped into preserve-tools mode, because mixing CC's `tools` array with their XML protocol makes the model emit `<function_calls><invoke>` that their parsers can't read. If you run dario specifically for fingerprint fidelity and would rather pick `--preserve-tools` yourself, `--no-auto-detect` (v3.20.1, aka `--no-auto-preserve`) disables the heuristic — explicit operator choice then wins.
 

package/dist/cc-template.d.ts

@@ -104,8 +104,20 @@ export declare function scrubFrameworkIdentifiers(text: string): string;
  * names like "Cline" / "Roo" are still present. Tool-protocol
  * markers are scrub-proof on their own.
  *
- * Returns the matched family (`cline` / `kilo` / `roo` / `cline-like`)
- * or null when no text-tool protocol signature is present.
+ * Returns the matched family (`cline` / `kilo` / `roo` / `cline-like` /
+ * `hermes`) or null when no signature is present.
+ *
+ * Hermes Agent (Nous Research) is a different case from the Cline family —
+ * it uses the standard Anthropic JSON tool-use protocol (not XML). But it
+ * ships ~40 tools, 15+ of which have no CC equivalent (browser_*, vision_*,
+ * image_generate, text_to_speech, skills_*, memory, session_search,
+ * cronjob, send_message, ha_*, mixture_of_agents, delegate_task, …). In
+ * default mode dario distributes unmapped tools onto random CC slots which
+ * silently misroutes them. preserve-tools is the correct default for
+ * Hermes for the same outcome as Cline (client's tool schema passes
+ * through untouched) even though the reason is different. The function
+ * conflates both cases because the downstream dispatch is identical.
+ * Reported via @vmvarg4 on X after the v3.30.5 marketing push.
  */
 export declare function detectTextToolClient(systemText: string): string | null;
 /**
@@ -170,6 +182,19 @@ export interface RequestContext {
  * Replaces the entire request structure — tools, fields, ordering — with
  * what real CC sends. Only the conversation content is preserved.
  */
+/** Default outbound max_tokens when neither a passthrough nor an explicit value is set. Matches CC 2.1.116's wire default. */
+export declare const DEFAULT_MAX_TOKENS = 32000;
+/**
+ * Resolve the outbound `max_tokens` value.
+ *
+ *   undefined / 32000 etc. → number pins outbound (preserves dario's CC-wire default)
+ *   'client' → extract from `clientBody.max_tokens`; fall back to DEFAULT_MAX_TOKENS
+ *              when the client didn't send a value or sent something non-numeric
+ *
+ * dario#88 (Hermes compat — Hermes requests up to 128k for Opus 4.7, 64k for
+ * Sonnet; pinning to 32k silently truncated its output capacity).
+ */
+export declare function resolveMaxTokens(flag: number | 'client' | undefined, clientBody: Record<string, unknown>): number;
 /** Valid values for the `--effort` flag. `'client'` passes through the client's own `output_config.effort` (falling back to `'high'` if the client didn't send one). dario#87. */
 export type EffortValue = 'low' | 'medium' | 'high' | 'xhigh' | 'client';
 export declare const VALID_EFFORT_VALUES: ReadonlyArray<EffortValue>;
@@ -195,6 +220,7 @@ export declare function buildCCRequest(clientBody: Record<string, unknown>, bill
     hybridTools?: boolean;
     noAutoDetect?: boolean;
     effort?: EffortValue;
+    maxTokens?: number | 'client';
 }): {
     body: Record<string, unknown>;
     toolMap: Map<string, ToolMapping>;

package/dist/cc-template.js

@@ -213,8 +213,20 @@ export function scrubFrameworkIdentifiers(text) {
  * names like "Cline" / "Roo" are still present. Tool-protocol
  * markers are scrub-proof on their own.
  *
- * Returns the matched family (`cline` / `kilo` / `roo` / `cline-like`)
- * or null when no text-tool protocol signature is present.
+ * Returns the matched family (`cline` / `kilo` / `roo` / `cline-like` /
+ * `hermes`) or null when no signature is present.
+ *
+ * Hermes Agent (Nous Research) is a different case from the Cline family —
+ * it uses the standard Anthropic JSON tool-use protocol (not XML). But it
+ * ships ~40 tools, 15+ of which have no CC equivalent (browser_*, vision_*,
+ * image_generate, text_to_speech, skills_*, memory, session_search,
+ * cronjob, send_message, ha_*, mixture_of_agents, delegate_task, …). In
+ * default mode dario distributes unmapped tools onto random CC slots which
+ * silently misroutes them. preserve-tools is the correct default for
+ * Hermes for the same outcome as Cline (client's tool schema passes
+ * through untouched) even though the reason is different. The function
+ * conflates both cases because the downstream dispatch is identical.
+ * Reported via @vmvarg4 on X after the v3.30.5 marketing push.
  */
 export function detectTextToolClient(systemText) {
     if (!systemText)
@@ -225,6 +237,14 @@ export function detectTextToolClient(systemText) {
         return 'kilo';
     if (/\bYou are Roo\b/.test(systemText))
         return 'roo';
+    // Hermes Agent (Nous Research) — canonical opener from agent/prompt_builder.py.
+    // Also accept "created by Nous Research" as a secondary anchor since
+    // downstream forks may edit the leading identity line but tend to keep
+    // attribution intact.
+    if (/\bYou are Hermes Agent\b/.test(systemText))
+        return 'hermes';
+    if (/\bcreated by Nous Research\b/.test(systemText))
+        return 'hermes';
     // Protocol-signature fallback — unique to the Cline family and its
     // forks; survives a forked system prompt that edited the identity
     // string out but kept the tool protocol intact.
@@ -708,6 +728,34 @@ const TOOL_MAP = {
     },
     exit_worktree: { ccTool: 'ExitWorktree' },
 };
+/**
+ * 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.
+ */
+/** Default outbound max_tokens when neither a passthrough nor an explicit value is set. Matches CC 2.1.116's wire default. */
+export const DEFAULT_MAX_TOKENS = 32000;
+/**
+ * Resolve the outbound `max_tokens` value.
+ *
+ *   undefined / 32000 etc. → number pins outbound (preserves dario's CC-wire default)
+ *   'client' → extract from `clientBody.max_tokens`; fall back to DEFAULT_MAX_TOKENS
+ *              when the client didn't send a value or sent something non-numeric
+ *
+ * dario#88 (Hermes compat — Hermes requests up to 128k for Opus 4.7, 64k for
+ * Sonnet; pinning to 32k silently truncated its output capacity).
+ */
+export function resolveMaxTokens(flag, clientBody) {
+    if (flag === undefined)
+        return DEFAULT_MAX_TOKENS;
+    if (flag === 'client') {
+        const clientMT = clientBody.max_tokens;
+        if (typeof clientMT === 'number' && Number.isFinite(clientMT) && clientMT > 0)
+            return Math.floor(clientMT);
+        return DEFAULT_MAX_TOKENS;
+    }
+    return flag;
+}
 export const VALID_EFFORT_VALUES = ['low', 'medium', 'high', 'xhigh', 'client'];
 /**
  * Resolve the outbound `output_config.effort` value.
@@ -992,7 +1040,7 @@ export function buildCCRequest(clientBody, billingTag, cacheControl, identity, o
             session_id: identity.sessionId,
         }),
     };
-    ccRequest.max_tokens = 32000;
+    ccRequest.max_tokens = resolveMaxTokens(opts.maxTokens, clientBody);
     // Model-specific fields — order: thinking, context_management, output_config
     if (!isHaiku) {
         ccRequest.thinking = { type: 'adaptive' };

package/dist/cli.d.ts

@@ -10,6 +10,13 @@
  *   dario logout    — Remove saved credentials
  */
 import { type EffortValue } from './cc-template.js';
+/**
+ * Parse `--max-tokens=<N|client>` + `DARIO_MAX_TOKENS` env (dario#88).
+ * Numeric values pin; `client` (case-insensitive) = passthrough client's
+ * max_tokens; unset = dario's default pin applies. Invalid values exit
+ * non-zero with guidance. Exported for tests.
+ */
+export declare function resolveMaxTokensFlag(args: string[], env: string | undefined): number | 'client' | undefined;
 /**
  * Parse the `--effort` flag + `DARIO_EFFORT` env. Validates against the
  * allowed set; unrecognised values cause a non-zero exit with the list of

package/dist/cli.js

@@ -271,6 +271,14 @@ async function proxy() {
     // should watch the `representative-claim` response header via -v logs
     // and revert to default if subscription billing breaks.
     const effort = resolveEffortFlag(args, process.env['DARIO_EFFORT']);
+    // --max-tokens=<N|client> — override outbound max_tokens (dario#88,
+    // Hermes compat). Default unset pins 32000 (CC 2.1.116's wire default).
+    // 'client' passes through whatever the client sent (Hermes requests up
+    // to 128k for Opus 4.7, 64k for Sonnet — default pin silently truncates
+    // their output capacity). Anthropic enforces a per-model ceiling on
+    // the server side, so passing through a too-high value returns a clean
+    // 400 rather than silently accepting beyond-model-max.
+    const maxTokens = resolveMaxTokensFlag(args, process.env['DARIO_MAX_TOKENS']);
     // Non-loopback bind without DARIO_API_KEY turns dario into an open
     // OAuth-subscription relay for anyone on the reachable network. Refuse
     // to start rather than rely on the operator to read the startup banner.
@@ -290,7 +298,27 @@ async function proxy() {
         console.error(`[dario] Override (not recommended): pass --unsafe-no-auth if you have out-of-band network controls and accept the risk.`);
         process.exit(1);
     }
-    await startProxy({ port, host, verbose, verboseBodies, model, passthrough, preserveTools, hybridTools, noAutoDetect, strictTls, pacingMinMs, pacingJitterMs, drainOnClose, sessionIdleRotateMs, sessionRotateJitterMs, sessionMaxAgeMs, sessionPerClient, preserveOrchestrationTags, noLiveCapture, strictTemplate, maxConcurrent, maxQueued, queueTimeoutMs, effort });
+    await startProxy({ port, host, verbose, verboseBodies, model, passthrough, preserveTools, hybridTools, noAutoDetect, strictTls, pacingMinMs, pacingJitterMs, drainOnClose, sessionIdleRotateMs, sessionRotateJitterMs, sessionMaxAgeMs, sessionPerClient, preserveOrchestrationTags, noLiveCapture, strictTemplate, maxConcurrent, maxQueued, queueTimeoutMs, effort, maxTokens });
+}
+/**
+ * Parse `--max-tokens=<N|client>` + `DARIO_MAX_TOKENS` env (dario#88).
+ * Numeric values pin; `client` (case-insensitive) = passthrough client's
+ * max_tokens; unset = dario's default pin applies. Invalid values exit
+ * non-zero with guidance. Exported for tests.
+ */
+export function resolveMaxTokensFlag(args, env) {
+    const withValue = args.find(a => a.startsWith('--max-tokens='));
+    const raw = withValue ? withValue.slice('--max-tokens='.length) : env;
+    if (raw === undefined || raw === '')
+        return undefined;
+    const normalized = raw.trim();
+    if (normalized.toLowerCase() === 'client')
+        return 'client';
+    const n = Number.parseInt(normalized, 10);
+    if (Number.isFinite(n) && n > 0)
+        return n;
+    console.error(`[dario] Invalid --max-tokens value: ${JSON.stringify(raw)}. Must be a positive integer or the literal "client".`);
+    process.exit(1);
 }
 /**
  * Parse the `--effort` flag + `DARIO_EFFORT` env. Validates against the
@@ -722,6 +750,16 @@ async function help() {
                              to 'overage' billing; watch -v logs for
                              representative-claim changes.
                              Env: DARIO_EFFORT. (dario#87)
+    --max-tokens=<N|client>  Override outbound max_tokens. Default
+                             (unset) pins 32000 (CC 2.1.116 wire default).
+                             Set a number to pin that value; set 'client'
+                             to pass through the client's requested
+                             max_tokens (Hermes requests 64k–128k; the
+                             default pin silently truncates its output
+                             capacity). Anthropic enforces the per-model
+                             ceiling server-side, so too-high values
+                             return a clean 400.
+                             Env: DARIO_MAX_TOKENS. (dario#88)
     --port=PORT              Port to listen on (default: 3456)
     --host=ADDRESS           Address to bind to (default: 127.0.0.1)
                              Use 0.0.0.0 for LAN; see README for DARIO_API_KEY

package/dist/proxy.d.ts

@@ -80,6 +80,16 @@ interface ProxyOptions {
      * dario#87.
      */
     effort?: EffortValue;
+    /**
+     * Override the outbound `max_tokens` value. Default (undefined) pins
+     * `32000` — CC 2.1.116's wire default, below Anthropic's per-model
+     * limits. A number pins a specific value. `'client'` passes through
+     * whatever the client requested (up to Anthropic's per-model ceiling
+     * on the server side). Hermes (and other agents) request up to 128k
+     * for Opus and 64k for Sonnet; the default 32k pin silently truncates
+     * their output capacity. dario#88 (Hermes compat).
+     */
+    maxTokens?: number | 'client';
 }
 export declare function sanitizeError(err: unknown): string;
 /**

package/dist/proxy.js

@@ -979,6 +979,7 @@ export async function startProxy(opts = {}) {
                             hybridTools: opts.hybridTools ?? false,
                             noAutoDetect: opts.noAutoDetect ?? false,
                             effort: opts.effort,
+                            maxTokens: opts.maxTokens,
                         });
                         // Log the auto-preserve-tools switch once per text-tool
                         // client family. Skip when the operator already opted into

package/package.json

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