@askalf/dario 6.9.1 → 6.9.2

package/README.md

@@ -473,6 +473,7 @@ The split isn't live, but it was announced once on short notice and could return
 | Credentials | Your own subscription tokens, never logged, redacted from errors, `0600` on disk in `0700` dirs |
 | Network | Binds `127.0.0.1` by default; upstream only to configured backends over HTTPS; hardcoded SSRF allow-list; refuses a non-loopback bind without `DARIO_API_KEY` |
 | Telemetry | **None.** No analytics, no tracking, nothing phones home |
+| Overhead | Measured in the open on every PR: [`scripts/bench-overhead.mjs`](./scripts/bench-overhead.mjs) runs a real proxy against an instant upstream beside a bare http server serving the same bytes. On loopback dario adds no measurable p50 wall time over that floor; the CPU per request is the number to watch, and the per-request [timing split](./docs/analytics.md#the-timing-split) shows it live |
 | This README | CI fails if the line count above drifts from `src/` or a link or anchor here stops resolving ([`check-readme-line-count.mjs`](./scripts/check-readme-line-count.mjs), [`check-readme-links.mjs`](./scripts/check-readme-links.mjs)); the TUI screenshots are rendered from the real TUI and the diagrams are briefed art, not screenshots ([how](./scripts/readme/README.md)) |
 
 ```bash

package/dist/proxy.d.ts

@@ -636,6 +636,21 @@ export interface ProxyLogEntry {
  * null (logFile not configured). Errors are swallowed — log writes
  * must never break the request path.
  */
+/**
+ * The `data:` line of one SSE frame, without allocating a per-line array
+ * (the frame is `event: x\ndata: {...}\n\n`; the data line is the one that
+ * starts with the field name, at the start of the frame or after a newline).
+ * Null when the frame has no data line (a comment, a bare event).
+ */
+export declare function sseDataLine(frame: string): string | null;
+/**
+ * Whether the analytics tap needs to parse this frame at all: only the
+ * message_start usage, the message_delta usage and thinking deltas feed a
+ * number it keeps. A text or tool-input delta — most of any stream — is
+ * skipped before JSON.parse. Substring tests on the data line; a frame that
+ * happens to contain these words inside a text delta merely costs a parse.
+ */
+export declare function analyticsFrameOfInterest(dataLine: string): boolean;
 export declare function writeLogLine(stream: WriteStream | null, entry: ProxyLogEntry): void;
 export declare function sanitizeError(err: unknown): string;
 /**

package/dist/proxy.js

@@ -990,6 +990,31 @@ export function requiresClaudeLogin(poolSize, adminEnabled, hasUpstreamApiKey, n
  * null (logFile not configured). Errors are swallowed — log writes
  * must never break the request path.
  */
+/**
+ * The `data:` line of one SSE frame, without allocating a per-line array
+ * (the frame is `event: x\ndata: {...}\n\n`; the data line is the one that
+ * starts with the field name, at the start of the frame or after a newline).
+ * Null when the frame has no data line (a comment, a bare event).
+ */
+export function sseDataLine(frame) {
+    let at = frame.startsWith('data: ') ? 0 : frame.indexOf('\ndata: ');
+    if (at < 0)
+        return null;
+    if (at > 0)
+        at += 1;
+    const end = frame.indexOf('\n', at);
+    return end < 0 ? frame.slice(at) : frame.slice(at, end);
+}
+/**
+ * Whether the analytics tap needs to parse this frame at all: only the
+ * message_start usage, the message_delta usage and thinking deltas feed a
+ * number it keeps. A text or tool-input delta — most of any stream — is
+ * skipped before JSON.parse. Substring tests on the data line; a frame that
+ * happens to contain these words inside a text delta merely costs a parse.
+ */
+export function analyticsFrameOfInterest(dataLine) {
+    return dataLine.includes('"message_start"') || dataLine.includes('"message_delta"') || dataLine.includes('thinking_delta');
+}
 export function writeLogLine(stream, entry) {
     if (!stream)
         return;
@@ -4077,7 +4102,14 @@ export async function startProxy(opts = {}) {
             // hand the client an OpenAI-shaped response for a Messages request. This
             // route still has no reverse translation; the codex route above does,
             // which is why it takes both shapes and this one does not.
-            const fallbackModel = selectPoolFallbackForBody(body)[0] ?? null;
+            // Only the drained-pool branch below reads this, and computing it means
+            // parsing the whole client body again — on a 200 KB Claude Code turn
+            // that was ~2% of dario's own CPU on every request that never took the
+            // branch (scripts/bench-overhead.mjs profile, v6.9.2). Resolved only
+            // when the branch can be taken.
+            const fallbackModel = (!upstreamApiKey && !poolAccount && openaiBackend && isOpenAI)
+                ? (selectPoolFallbackForBody(body)[0] ?? null)
+                : null;
             if (!upstreamApiKey && !poolAccount && fallbackModel && openaiBackend && isOpenAI) {
                 const fallbackBody = buildPoolFallbackBody(body, fallbackModel);
                 if (!fallbackBody) {
@@ -5287,14 +5319,22 @@ export async function startProxy(opts = {}) {
                             upstreamDoneAt = Date.now();
                             break;
                         }
-                        // Parse SSE events for analytics regardless of routing branch
+                        // Parse SSE events for analytics regardless of routing branch.
+                        // Only three frame kinds carry a number this tap reads — the
+                        // message_start usage, the message_delta usage, and thinking
+                        // deltas (for the ~4-chars-per-token estimate). Every other frame
+                        // is a text or tool delta, i.e. most of a stream, and parsing
+                        // them was the single largest cost in dario's own streaming path
+                        // (scripts/bench-overhead.mjs profile, v6.9.2). A substring test
+                        // on the data line decides before JSON.parse; the parse itself
+                        // is unchanged for the frames that pass.
                         if (analyticsDecoder && value) {
                             analyticsBuffer += analyticsDecoder.decode(value, { stream: true });
                             const parts = analyticsBuffer.split('\n\n');
                             analyticsBuffer = parts.pop() ?? '';
                             for (const part of parts) {
-                                const dataLine = part.split('\n').find(l => l.startsWith('data: '));
-                                if (!dataLine)
+                                const dataLine = sseDataLine(part);
+                                if (!dataLine || !analyticsFrameOfInterest(dataLine))
                                     continue;
                                 try {
                                     const e = JSON.parse(dataLine.slice(6));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "6.9.1",
+  "version": "6.9.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, with automatic failover when one hits its limit.",
   "type": "module",
   "bin": {
@@ -42,7 +42,8 @@
     "fix:pkg": "node -e \"const fs=require('fs');fs.writeFileSync('package.json',JSON.stringify(JSON.parse(fs.readFileSync('package.json','utf-8')),null,2)+'\\n')\"",
     "audit:tui": "node tools/tui-audit/audit.mjs",
     "readme:assets": "node scripts/readme/terminal.mjs && node scripts/readme/tui.mjs",
-    "check:readme": "node scripts/check-readme-line-count.mjs && node scripts/check-readme-links.mjs"
+    "check:readme": "node scripts/check-readme-line-count.mjs && node scripts/check-readme-links.mjs",
+    "bench": "node scripts/bench-overhead.mjs"
   },
   "keywords": [
     "llm",