@askalf/dario 4.8.1 → 4.8.3

package/README.md

@@ -509,12 +509,8 @@ Ordered by relevance to a dario reader — projects that route through dario fir
 
 | Project | What it does |
 |---|---|
-| [arnie](https://github.com/askalf/arnie) | Portable IT troubleshooting agent — networking, AD, package managers, log triage. Routes through dario for subscription billing. |
 | [hands](https://github.com/askalf/hands) | Cross-platform computer-use agent — your LLM on your mouse, keyboard, and screen. Windows + macOS + Linux. Routes through dario or any Anthropic-compat. |
 | [deepdive](https://github.com/askalf/deepdive) | Local research agent. One command, cited answer. Plan → search → headless fetch → extract → synthesize. Every LLM call through your own router. |
-| [claude-sync](https://github.com/askalf/claude-sync) | Sync Claude Code sessions across machines. Pack a CC session into a portable `.ccsync` file, ship it via Dropbox / iCloud / USB, unpack on the other side. |
 | [browser-bridge](https://github.com/askalf/browser-bridge) | Stealth headless Chromium in a container, CDP on 9222. Connect from Playwright, Puppeteer, MCP browser tools, any agent that wants a remote browser. |
-| [install-kit](https://github.com/askalf/install-kit) | curl-pipe-bash template for self-hosted Docker apps — banner, prereq probes, `.env` scaffolding with crypto-rand secrets, healthcheck wait loop. |
 | [pgflex](https://github.com/askalf/pgflex) | One Postgres API, two modes — real PostgreSQL for production, PGlite (in-process WASM) for standalone / dev. Same SQL, drop the server when you don't need it. |
 | [redisflex](https://github.com/askalf/redisflex) | One Redis API, two modes — ioredis for production, in-process Map+EventEmitter for dev. Includes a BullMQ-shaped in-memory queue. |
-| [git-providers](https://github.com/askalf/git-providers) | One `GitProvider` interface for GitHub + GitLab + Bitbucket Cloud, plus a 44-entry api-key-provider taxonomy (cloud / CI / monitoring / analytics / ...). |

package/dist/cc-template.d.ts

@@ -318,6 +318,7 @@ export declare function buildCCRequest(clientBody: Record<string, unknown>, bill
     maxTokens?: number | 'client';
     systemPrompt?: string;
     skipFields?: ReadonlySet<string>;
+    honorClientThinking?: boolean;
 }): {
     body: Record<string, unknown>;
     toolMap: Map<string, ToolMapping>;

package/dist/cc-template.js

@@ -1306,7 +1306,30 @@ export function buildCCRequest(clientBody, billingTag, cacheControl, identity, o
     // absent). See dario#87.
     if (!isHaiku) {
         const skip = opts.skipFields;
-        if (supportsAdaptiveThinking(model)) {
+        // Client-supplied thinking shape takes precedence when honorClientThinking
+        // is enabled. SDK clients (vs CC) sometimes need explicit control over
+        // budget_tokens or the type='enabled' vs type='adaptive' choice — e.g.
+        // an agent that wants 8k thinking tokens for hard problems, or a model
+        // that supports thinking but not the 4.6-era adaptive variant. dario's
+        // default builds the CC-style adaptive shape, which is fine for CC
+        // clients but doesn't expose the budget knob to others.
+        //
+        // When honored, we also suppress dario's clear_thinking_* context-edit
+        // pair — that edit is tuned for type='adaptive' and the client's shape
+        // takes responsibility for the request as a whole. Effort still ships.
+        const clientThinking = (clientBody.thinking ?? null);
+        const honoredClientThinking = Boolean(opts.honorClientThinking
+            && clientThinking
+            && typeof clientThinking === 'object'
+            && typeof clientThinking['type'] === 'string');
+        if (honoredClientThinking) {
+            if (!skip || !skip.has('thinking')) {
+                ccRequest.thinking = clientThinking;
+            }
+            // Intentionally do NOT inject context_management.clear_thinking_*
+            // when honoring client thinking — the pairing is shape-specific.
+        }
+        else if (supportsAdaptiveThinking(model)) {
             if (!skip || !skip.has('thinking')) {
                 ccRequest.thinking = { type: 'adaptive' };
             }

package/dist/cli.js

@@ -518,6 +518,11 @@ async function proxy() {
     // Falls back to DARIO_SKIP_FIELDS env var. See ProxyOptions.skipFields
     // for rationale.
     const skipFields = parseSkipFieldsFlag(args, process.env['DARIO_SKIP_FIELDS']);
+    // --honor-client-thinking — pass through the client body's `thinking`
+    // field instead of dario's default CC-style `{type:'adaptive'}`. See
+    // ProxyOptions.honorClientThinking for rationale.
+    const honorClientThinking = args.includes('--honor-client-thinking')
+        || ['1', 'true', 'yes', 'on'].includes((process.env['DARIO_HONOR_CLIENT_THINKING'] ?? '').toLowerCase());
     // 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.
@@ -537,7 +542,7 @@ 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, mergeTools, noAutoDetect, strictTls, pacingMinMs, pacingJitterMs, thinkTimeBaseMs, thinkTimePerTokenMs, thinkTimeJitterMs, thinkTimeMaxMs, sessionStartMinMs, sessionStartJitterMs, stealth, drainOnClose, sessionIdleRotateMs, sessionRotateJitterMs, sessionMaxAgeMs, sessionPerClient, preserveOrchestrationTags, noLiveCapture, strictTemplate, maxConcurrent, maxQueued, queueTimeoutMs, effort, maxTokens, logFile, passthroughBetas, skipFields, systemPrompt, overageGuardEnabled, overageGuardBehavior, overageGuardCooldownMs, overageGuardNotifyOs });
+    await startProxy({ port, host, verbose, verboseBodies, model, passthrough, preserveTools, hybridTools, mergeTools, noAutoDetect, strictTls, pacingMinMs, pacingJitterMs, thinkTimeBaseMs, thinkTimePerTokenMs, thinkTimeJitterMs, thinkTimeMaxMs, sessionStartMinMs, sessionStartJitterMs, stealth, drainOnClose, sessionIdleRotateMs, sessionRotateJitterMs, sessionMaxAgeMs, sessionPerClient, preserveOrchestrationTags, noLiveCapture, strictTemplate, maxConcurrent, maxQueued, queueTimeoutMs, effort, maxTokens, logFile, passthroughBetas, skipFields, systemPrompt, overageGuardEnabled, overageGuardBehavior, overageGuardCooldownMs, overageGuardNotifyOs, honorClientThinking });
 }
 /**
  * Parse `--system-prompt=<verbatim|partial|aggressive|filepath>` (or the
@@ -1384,6 +1389,19 @@ async function help() {
                              that rejects the field despite the beta
                              header. Env: DARIO_SKIP_FIELDS.
 
+    --honor-client-thinking  Pass the client body's \`thinking\` field
+                             through to upstream instead of dario's
+                             default \`{type:"adaptive"}\`. Lets SDK
+                             clients explicitly enable extended
+                             thinking with their own budget (e.g.
+                             \`{type:"enabled", budget_tokens:8000}\`).
+                             When honored, the paired
+                             \`context_management.clear_thinking_*\`
+                             edit is suppressed (shape-specific).
+                             No effect on Haiku or when client omits
+                             \`thinking\`. Env:
+                             DARIO_HONOR_CLIENT_THINKING.
+
     --upstream-proxy=URL / --via=URL
                              Route all of dario's outbound fetch
                              calls (api.anthropic.com, OpenAI-compat

package/dist/proxy.d.ts

@@ -155,6 +155,25 @@ interface ProxyOptions {
      * so Max billing pool routing is unchanged.
      */
     skipFields?: string[];
+    /**
+     * When set, an inbound client body's `thinking` field (e.g.
+     * `{type:"enabled", budget_tokens:N}` or `{type:"adaptive"}`) is passed
+     * through to the upstream INSTEAD of dario's default CC-style
+     * `{type:"adaptive"}`. SDK clients hitting dario can therefore explicitly
+     * enable extended thinking with their own budget, rather than being
+     * locked to CC's default adaptive shape.
+     *
+     * Side effect: when honored, dario also suppresses its
+     * `context_management.clear_thinking_*` edit — that edit is tuned for
+     * `type:"adaptive"` and pairing it with `type:"enabled"` 400s upstream.
+     * The client takes responsibility for the request shape as a whole.
+     *
+     * No effect on Haiku (which skips thinking by construction) or when the
+     * client doesn't supply a `thinking` field. CC clients are unaffected.
+     *
+     * Env: DARIO_HONOR_CLIENT_THINKING=1.
+     */
+    honorClientThinking?: boolean;
     /**
      * System-prompt mode for the Claude backend. Empirically validated as
      * unfingerprinted by the billing classifier in docs/research/system-prompt-classifier-study.md.

package/dist/proxy.js

@@ -1391,6 +1391,7 @@ export async function startProxy(opts = {}) {
                             maxTokens: opts.maxTokens,
                             systemPrompt: opts.systemPrompt,
                             skipFields,
+                            honorClientThinking: opts.honorClientThinking ?? false,
                         });
                         detectedClientForLog = detectedClient;
                         preserveToolsEffective = Boolean(opts.preserveTools)
@@ -1945,12 +1946,19 @@ export async function startProxy(opts = {}) {
             res.writeHead(upstream.status, responseHeaders);
             if (isStream && upstream.body) {
                 // Analytics accumulators for streaming responses — filled by parsing
-                // message_start / message_delta SSE events as they flow through.
+                // message_start / message_delta / content_block_delta SSE events as
+                // they flow through. Token capture must run regardless of pool mode:
+                // gating on `poolAccount` (non-null only in multi-account installs)
+                // skipped the parser entirely on single-account setups, so the
+                // analytics.record() call below persisted zeros for input/output
+                // tokens. SDK streaming clients on single-account installs had their
+                // token usage invisible in /analytics until this fix.
                 let streamInputTokens = 0;
                 let streamOutputTokens = 0;
                 let streamCacheReadTokens = 0;
                 let streamCacheCreateTokens = 0;
-                const analyticsDecoder = (analytics && poolAccount) ? new TextDecoder() : null;
+                let streamThinkingChars = 0;
+                const analyticsDecoder = analytics ? new TextDecoder() : null;
                 let analyticsBuffer = '';
                 // Stream SSE chunks through
                 const reader = upstream.body.getReader();
@@ -2003,6 +2011,17 @@ export async function startProxy(opts = {}) {
                                         if (u?.output_tokens)
                                             streamOutputTokens = u.output_tokens;
                                     }
+                                    else if (e.type === 'content_block_delta') {
+                                        // Mirror the non-streaming parseUsage thinking-token
+                                        // heuristic: ~4 characters per token across thinking_delta
+                                        // events. Closer than 0, and the same formula the parser
+                                        // applies for buffered responses, so streaming + non-
+                                        // streaming numbers stay comparable.
+                                        const d = e.delta;
+                                        if (d?.type === 'thinking_delta' && typeof d.thinking === 'string') {
+                                            streamThinkingChars += d.thinking.length;
+                                        }
+                                    }
                                 }
                                 catch { /* ignore malformed SSE events */ }
                             }
@@ -2082,7 +2101,7 @@ export async function startProxy(opts = {}) {
                         model: requestModel,
                         inputTokens: streamInputTokens, outputTokens: streamOutputTokens,
                         cacheReadTokens: streamCacheReadTokens, cacheCreateTokens: streamCacheCreateTokens,
-                        thinkingTokens: 0,
+                        thinkingTokens: Math.round(streamThinkingChars / 4),
                         claim: rl.claim, util5h: rl.util5h, util7d: rl.util7d, overageUtil: rl.overageUtil,
                         latencyMs: Date.now() - startTime, status: upstream.status, isStream: true, isOpenAI,
                     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "4.8.1",
+  "version": "4.8.3",
   "description": "Use your Claude Pro/Max subscription in any tool — Cursor, Cline, Aider, the Agent SDK, your scripts — at subscription pricing, not per-token API bills. One local Anthropic + OpenAI-compatible endpoint.",
   "type": "module",
   "bin": {