@askalf/dario 4.8.120 → 4.8.122

package/dist/model-catalog.d.ts

@@ -32,7 +32,7 @@
  * — the same ordering normalizeUpstreamIds() produces for live data.
  */
 export declare const BAKED_BASE_MODELS: readonly string[];
-/** The set of suspended families, resolved from env at call time. */
+/** The set of suspended families, resolved from env (memoized by raw value). */
 export declare function suspendedFamilies(): Set<string>;
 /** True when `model` (any spelling) belongs to a suspended family. */
 export declare function isSuspendedModel(model: string): boolean;

package/dist/model-catalog.js

@@ -67,14 +67,23 @@ export const BAKED_BASE_MODELS = [
  * to re-suspend if access is ever pulled again.
  */
 const DEFAULT_SUSPENDED_MODELS = '';
-/** The set of suspended families, resolved from env at call time. */
+// Memoized by the raw env value (#642-audit): isSuspendedModel runs per request,
+// and this rebuilt a Set from process.env every call. Keyed on the raw string so
+// a runtime change to DARIO_SUSPENDED_MODELS still re-parses; the common (empty)
+// value allocates the Set once.
+let _suspendedCache = null;
+/** The set of suspended families, resolved from env (memoized by raw value). */
 export function suspendedFamilies() {
     const raw = process.env.DARIO_SUSPENDED_MODELS ?? DEFAULT_SUSPENDED_MODELS;
-    return new Set(raw
+    if (_suspendedCache && _suspendedCache.raw === raw)
+        return _suspendedCache.set;
+    const set = new Set(raw
         .split(',')
         .map((s) => s.trim())
         .filter((s) => s.length > 0)
         .map((s) => modelFamily(s) ?? s.toLowerCase()));
+    _suspendedCache = { raw, set };
+    return set;
 }
 /** True when `model` (any spelling) belongs to a suspended family. */
 export function isSuspendedModel(model) {

package/dist/proxy.d.ts

@@ -174,6 +174,14 @@ export declare function buildOrchestrationPatterns(preserveTags?: Set<string>):
  * opt any tag out of the scrub. dario#78.
  */
 export declare function sanitizeMessages(body: Record<string, unknown>, preserveTags?: Set<string>): void;
+/**
+ * Translate Anthropic SSE → OpenAI SSE. Returns a stateful per-CALL closure so
+ * concurrent /v1/chat/completions streams don't share tool-call index/id state
+ * (#642-audit: the previous module-global counters cross-contaminated
+ * interleaved streams and emitted malformed tool_calls deltas). One translator
+ * per request, mirroring createStreamingReverseMapper.
+ */
+export declare function createOpenAIStreamTranslator(): (line: string) => string | null;
 export declare const OPENAI_MODELS_LIST: {
     object: string;
     data: Array<{

package/dist/proxy.js

@@ -455,6 +455,21 @@ function sanitizeContent(text, patterns) {
     }
     return result.replace(/\n{3,}/g, '\n\n').trim();
 }
+// Memoize the compiled preserve-tag pattern set by Set reference (#642-audit):
+// opts.preserveOrchestrationTags is a single Set instance passed on every
+// request, so recompile the ~28 patterns once instead of per request. The
+// default (no-preserve) path already uses the precompiled constant.
+let _orchPreserveKey;
+let _orchPatterns;
+function orchestrationPatternsFor(preserveTags) {
+    if (preserveTags === undefined)
+        return ORCHESTRATION_PATTERNS_DEFAULT;
+    if (preserveTags !== _orchPreserveKey) {
+        _orchPreserveKey = preserveTags;
+        _orchPatterns = buildOrchestrationPatterns(preserveTags);
+    }
+    return _orchPatterns;
+}
 /**
  * Strip orchestration tags from all messages in a request body.
  *
@@ -465,7 +480,7 @@ export function sanitizeMessages(body, preserveTags) {
     const messages = body.messages;
     if (!messages)
         return;
-    const patterns = preserveTags === undefined ? ORCHESTRATION_PATTERNS_DEFAULT : buildOrchestrationPatterns(preserveTags);
+    const patterns = orchestrationPatternsFor(preserveTags);
     for (const msg of messages) {
         if (typeof msg.content === 'string') {
             msg.content = sanitizeContent(msg.content, patterns);
@@ -544,48 +559,55 @@ function anthropicToOpenai(body) {
         usage: { prompt_tokens: u?.input_tokens ?? 0, completion_tokens: u?.output_tokens ?? 0, total_tokens: (u?.input_tokens ?? 0) + (u?.output_tokens ?? 0) },
     };
 }
-/** Translate Anthropic SSE → OpenAI SSE. */
-// Track tool call state across stream chunks
-let _streamToolIndex = 0;
-let _streamToolId = '';
-function translateStreamChunk(line) {
-    if (!line.startsWith('data: '))
-        return null;
-    const json = line.slice(6).trim();
-    if (json === '[DONE]')
-        return 'data: [DONE]\n\n';
-    try {
-        const e = JSON.parse(json);
-        const ts = Math.floor(Date.now() / 1000);
-        if (e.type === 'content_block_start') {
-            const block = e.content_block;
-            if (block?.type === 'tool_use' && block.name) {
-                _streamToolId = block.id ?? `call_${_streamToolIndex}`;
-                return `data: ${JSON.stringify({ id: 'chatcmpl-dario', object: 'chat.completion.chunk', created: ts, model: 'claude', choices: [{ index: 0, delta: { tool_calls: [{ index: _streamToolIndex, id: _streamToolId, type: 'function', function: { name: block.name, arguments: '' } }] }, finish_reason: null }] })}\n\n`;
+/**
+ * Translate Anthropic SSE → OpenAI SSE. Returns a stateful per-CALL closure so
+ * concurrent /v1/chat/completions streams don't share tool-call index/id state
+ * (#642-audit: the previous module-global counters cross-contaminated
+ * interleaved streams and emitted malformed tool_calls deltas). One translator
+ * per request, mirroring createStreamingReverseMapper.
+ */
+export function createOpenAIStreamTranslator() {
+    let toolIndex = 0;
+    let toolId = '';
+    return function translateStreamChunk(line) {
+        if (!line.startsWith('data: '))
+            return null;
+        const json = line.slice(6).trim();
+        if (json === '[DONE]')
+            return 'data: [DONE]\n\n';
+        try {
+            const e = JSON.parse(json);
+            const ts = Math.floor(Date.now() / 1000);
+            if (e.type === 'content_block_start') {
+                const block = e.content_block;
+                if (block?.type === 'tool_use' && block.name) {
+                    toolId = block.id ?? `call_${toolIndex}`;
+                    return `data: ${JSON.stringify({ id: 'chatcmpl-dario', object: 'chat.completion.chunk', created: ts, model: 'claude', choices: [{ index: 0, delta: { tool_calls: [{ index: toolIndex, id: toolId, type: 'function', function: { name: block.name, arguments: '' } }] }, finish_reason: null }] })}\n\n`;
+                }
             }
-        }
-        if (e.type === 'content_block_delta') {
-            const d = e.delta;
-            if (d?.type === 'text_delta' && d.text)
-                return `data: ${JSON.stringify({ id: 'chatcmpl-dario', object: 'chat.completion.chunk', created: ts, model: 'claude', choices: [{ index: 0, delta: { content: d.text }, finish_reason: null }] })}\n\n`;
-            if (d?.type === 'input_json_delta' && d.partial_json)
-                return `data: ${JSON.stringify({ id: 'chatcmpl-dario', object: 'chat.completion.chunk', created: ts, model: 'claude', choices: [{ index: 0, delta: { tool_calls: [{ index: _streamToolIndex, function: { arguments: d.partial_json } }] }, finish_reason: null }] })}\n\n`;
-        }
-        if (e.type === 'content_block_stop') {
-            if (_streamToolId) {
-                _streamToolIndex++;
-                _streamToolId = '';
+            if (e.type === 'content_block_delta') {
+                const d = e.delta;
+                if (d?.type === 'text_delta' && d.text)
+                    return `data: ${JSON.stringify({ id: 'chatcmpl-dario', object: 'chat.completion.chunk', created: ts, model: 'claude', choices: [{ index: 0, delta: { content: d.text }, finish_reason: null }] })}\n\n`;
+                if (d?.type === 'input_json_delta' && d.partial_json)
+                    return `data: ${JSON.stringify({ id: 'chatcmpl-dario', object: 'chat.completion.chunk', created: ts, model: 'claude', choices: [{ index: 0, delta: { tool_calls: [{ index: toolIndex, function: { arguments: d.partial_json } }] }, finish_reason: null }] })}\n\n`;
+            }
+            if (e.type === 'content_block_stop') {
+                if (toolId) {
+                    toolIndex++;
+                    toolId = '';
+                }
+                return null;
+            }
+            if (e.type === 'message_stop') {
+                toolIndex = 0;
+                toolId = '';
+                return `data: ${JSON.stringify({ id: 'chatcmpl-dario', object: 'chat.completion.chunk', created: ts, model: 'claude', choices: [{ index: 0, delta: {}, finish_reason: 'stop' }] })}\n\ndata: [DONE]\n\n`;
             }
-            return null;
-        }
-        if (e.type === 'message_stop') {
-            _streamToolIndex = 0;
-            _streamToolId = '';
-            return `data: ${JSON.stringify({ id: 'chatcmpl-dario', object: 'chat.completion.chunk', created: ts, model: 'claude', choices: [{ index: 0, delta: {}, finish_reason: 'stop' }] })}\n\ndata: [DONE]\n\n`;
         }
-    }
-    catch { }
-    return null;
+        catch { }
+        return null;
+    };
 }
 // Baked /v1/models payload — what the proxy advertises before (or without)
 // a successful upstream catalog fetch. The live route serves the
@@ -1751,9 +1773,15 @@ export async function startProxy(opts = {}) {
             // recognizes through its own Anthropic gateway, bypassing localhost).
             let forcedProvider = cliProviderOverride;
             let requestEffort; // dario#419 — per-request effort parsed from a model-name suffix (model:high / model-high)
+            // Parsed body, shared between the provider-prefix detection below and the
+            // template-build block further down so the same bytes are not JSON.parsed
+            // twice per request (#642-audit). Mutations in the prefix block re-serialize
+            // `body` FROM this object, so it always represents the current body.
+            let parsedBody = null;
             if (body.length > 0) {
                 try {
                     const parsed = JSON.parse(body.toString());
+                    parsedBody = parsed;
                     const rawModel = parsed.model ?? '';
                     const prefix = parseProviderPrefix(rawModel);
                     if (prefix) {
@@ -1859,7 +1887,11 @@ export async function startProxy(opts = {}) {
             } : undefined;
             if (body.length > 0) {
                 try {
-                    const parsed = JSON.parse(body.toString());
+                    // Reuse the object parsed for provider-prefix detection above — the same
+                    // bytes, so re-parsing is wasted work on large bodies (#642-audit). Falls
+                    // back to a fresh parse when the earlier block didn't run (e.g. the body
+                    // was not JSON, or an OpenAI-backend reroute skipped it).
+                    const parsed = parsedBody ?? JSON.parse(body.toString());
                     // Strip orchestration tags from messages (Aider, Cursor, etc.)
                     sanitizeMessages(parsed, opts.preserveOrchestrationTags);
                     const result = isOpenAI ? openaiToAnthropic(parsed, modelOverride) : (modelOverride ? { ...parsed, model: modelOverride } : parsed);
@@ -2779,14 +2811,29 @@ export async function startProxy(opts = {}) {
                 const streamMapper = ccToolMap && !isOpenAI
                     ? createStreamingReverseMapper(ccToolMap, reqCtx)
                     : null;
+                // Per-request OpenAI SSE translator — isolated tool-call state so
+                // concurrent /v1/chat/completions streams don't cross-contaminate (#642-audit).
+                const openaiTranslate = isOpenAI ? createOpenAIStreamTranslator() : null;
                 // Gated writer — a no-op once the downstream client has gone away
                 // in drain-on-close mode. The read loop keeps consuming so the
                 // upstream sees a full-length read; writes to a closed socket are
                 // suppressed to avoid EPIPE/warnings and pointless work.
+                // Honor downstream backpressure (#642-audit): when res.write() returns
+                // false the client's socket buffer is full, so pause the read loop until
+                // it drains instead of buffering the whole (fast) upstream in memory.
+                let needsDrain = false;
                 const writeToClient = (chunk) => {
-                    if (!clientDisconnected)
-                        res.write(chunk);
+                    if (clientDisconnected)
+                        return;
+                    if (res.write(chunk) === false)
+                        needsDrain = true;
                 };
+                // Resolves on 'close' too, so a vanished client can't wedge the loop.
+                const waitForDrain = () => new Promise((resolve) => {
+                    const done = () => { res.off('drain', done); res.off('close', done); resolve(); };
+                    res.once('drain', done);
+                    res.once('close', done);
+                });
                 try {
                     let buffer = '';
                     const MAX_LINE_LENGTH = 1_000_000; // 1MB max per SSE line
@@ -2860,7 +2907,7 @@ export async function startProxy(opts = {}) {
                             const lines = buffer.split('\n');
                             buffer = lines.pop() ?? '';
                             for (const line of lines) {
-                                const translated = translateStreamChunk(line);
+                                const translated = openaiTranslate(line);
                                 if (translated)
                                     writeToClient(translated);
                             }
@@ -2873,10 +2920,16 @@ export async function startProxy(opts = {}) {
                         else {
                             writeToClient(value);
                         }
+                        // Backpressure (#642-audit): if the last writes filled the client
+                        // buffer, pause reading upstream until it drains.
+                        if (needsDrain && !clientDisconnected) {
+                            needsDrain = false;
+                            await waitForDrain();
+                        }
                     }
                     // Flush remaining buffer
                     if (isOpenAI && buffer.trim()) {
-                        const translated = translateStreamChunk(buffer);
+                        const translated = openaiTranslate(buffer);
                         if (translated)
                             writeToClient(translated);
                     }
@@ -2889,6 +2942,11 @@ export async function startProxy(opts = {}) {
                 catch (err) {
                     if (verbose)
                         console.error('[dario] Stream error:', sanitizeError(err));
+                    // Tear down the upstream body reader deterministically on an abnormal
+                    // mid-stream error (e.g. a bare upstream socket reset) so the undici
+                    // socket is released now, not at GC (#642-audit). No-op if aborted.
+                    if (!upstreamAbort.signal.aborted)
+                        upstreamAbort.abort();
                 }
                 res.end();
                 // Stamp the response-completion timestamp + token count so the

package/package.json

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