@askalf/dario 6.2.0 → 6.2.1

package/dist/doctor-core.d.ts

@@ -37,6 +37,21 @@ export interface Check {
  * live request, and this release was built on the lesson that a green config is
  * not a working path.
  */
+/**
+ * Mid-stream continuation readiness (v6.2.1). Configuration only, like
+ * failoverReadiness: it says which of the two hops a dying stream can take on
+ * this host, not that either works. The first hop (the same model again) needs
+ * nothing; the second (the other subscription) needs the failover chain AND
+ * somewhere for it to go — the exact INERT state the Failover row exists for.
+ */
+export declare function continuationReadiness(input: {
+    enabled: boolean;
+    chain: readonly string[];
+    codexAccounts: number;
+}): {
+    status: CheckStatus;
+    detail: string;
+};
 export declare function failoverReadiness(input: {
     chain: readonly string[];
     codexAccounts: number;

package/dist/doctor-core.js

@@ -41,6 +41,29 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
  * live request, and this release was built on the lesson that a green config is
  * not a working path.
  */
+/**
+ * Mid-stream continuation readiness (v6.2.1). Configuration only, like
+ * failoverReadiness: it says which of the two hops a dying stream can take on
+ * this host, not that either works. The first hop (the same model again) needs
+ * nothing; the second (the other subscription) needs the failover chain AND
+ * somewhere for it to go — the exact INERT state the Failover row exists for.
+ */
+export function continuationReadiness(input) {
+    if (!input.enabled) {
+        return { status: 'info', detail: 'off — a stream that dies mid-answer ends truncated (unset DARIO_MIDSTREAM_CONTINUE / drop --no-midstream-continue)' };
+    }
+    const secondHop = input.chain.length > 0 && input.codexAccounts > 0;
+    if (secondHop) {
+        return { status: 'ok', detail: `on: a dying stream resumes on the same model, then on ${input.chain.join(' → ')} (two hops)` };
+    }
+    return {
+        status: 'ok',
+        detail: 'on: a dying stream resumes on the same model only — '
+            + (input.chain.length === 0
+                ? 'add --pool-fallback for a second hop on the other subscription'
+                : 'the chain has nowhere to go for a second hop (see Failover)'),
+    };
+}
 export function failoverReadiness(input) {
     const { chain, codexAccounts, backends } = input;
     const hasCodex = codexAccounts > 0;
@@ -1170,6 +1193,9 @@ export async function runChecks(opts = {}) {
             backends: backends.map((b) => b.name),
         });
         checks.push({ status: verdict.status, label: 'Failover', detail: verdict.detail });
+        const midstreamEnabled = !['0', 'false', 'no', 'off'].includes((process.env.DARIO_MIDSTREAM_CONTINUE ?? '').toLowerCase());
+        const cont = continuationReadiness({ enabled: midstreamEnabled, chain, codexAccounts: codexAliases.length });
+        checks.push({ status: cont.status, label: 'Continuation', detail: cont.detail });
     }
     catch (err) {
         checks.push({ status: 'warn', label: 'Failover', detail: `check failed: ${err.message}` });

package/dist/midstream.d.ts

@@ -334,6 +334,34 @@ export declare class MidstreamGuard {
     private continueFrom;
     private log;
 }
+export interface ChaosCutOptions {
+    /** Characters of answer text an upstream stream is allowed before it is cut. */
+    afterChars: number;
+    /** How many streams to cut before the tap goes quiet (default 1). */
+    streams?: number;
+    log?: (line: string) => void;
+}
+/**
+ * The remaining-cuts counter, shared by every wrapper the proxy makes. The
+ * Claude leg and the codex leg wrap different fetch implementations, and a
+ * counter per wrapper would cut up to twice the promised number of streams
+ * (review finding on #1290): one budget for the proxy, not one per provider.
+ */
+export interface ChaosCutState {
+    left: number;
+}
+export declare function chaosCutState(o: ChaosCutOptions): ChaosCutState;
+/**
+ * Wraps an upstream fetch so that the first `streams` streamed answers die
+ * after `afterChars` characters of text — the failure this module exists for,
+ * on demand. A resume (its body carries the anchor quote) is never cut, so
+ * the tap produces a primary death and lets the continuation play out.
+ *
+ * Demo and test affordance, never a default: `DARIO_CHAOS_CUT_AFTER=300
+ * dario proxy` then stream any request and watch the seam. Both providers'
+ * text framing is recognised (`text_delta` / `response.output_text.delta`).
+ */
+export declare function chaosCutFetch(inner: typeof fetch, o: ChaosCutOptions, state?: ChaosCutState): typeof fetch;
 /** Convenience for sites that hold a ServerResponse: the guard writes through `write`, ends through `res.end()`. */
 export declare function guardFor(res: ServerResponse, o: Omit<MidstreamGuardOptions, 'end'>): MidstreamGuard;
 /**

package/dist/midstream.js

@@ -901,6 +901,62 @@ export class MidstreamGuard {
         (this.o.log ?? ((l) => console.log(`[dario] ${l}`)))(line);
     }
 }
+export function chaosCutState(o) {
+    return { left: o.streams ?? 1 };
+}
+/**
+ * Wraps an upstream fetch so that the first `streams` streamed answers die
+ * after `afterChars` characters of text — the failure this module exists for,
+ * on demand. A resume (its body carries the anchor quote) is never cut, so
+ * the tap produces a primary death and lets the continuation play out.
+ *
+ * Demo and test affordance, never a default: `DARIO_CHAOS_CUT_AFTER=300
+ * dario proxy` then stream any request and watch the seam. Both providers'
+ * text framing is recognised (`text_delta` / `response.output_text.delta`).
+ */
+export function chaosCutFetch(inner, o, state = chaosCutState(o)) {
+    const log = o.log ?? ((l) => console.warn(`[dario] ${l}`));
+    return async (input, init) => {
+        const res = await inner(input, init);
+        const url = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
+        const isStream = /\/v1\/messages|\/responses/.test(url);
+        const bodyText = typeof init?.body === 'string' ? init.body : init?.body instanceof Uint8Array ? new TextDecoder().decode(init.body) : '';
+        const isResume = bodyText.includes(ANCHOR_OPEN);
+        if (!isStream || isResume || state.left <= 0 || res.status !== 200 || !res.body)
+            return res;
+        state.left--;
+        const reader = res.body.getReader();
+        const dec = new TextDecoder();
+        let text = '';
+        const body = new ReadableStream({
+            async pull(c) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    c.close();
+                    return;
+                }
+                c.enqueue(value);
+                for (const m of dec.decode(value, { stream: true }).matchAll(/"(?:text|delta)":"((?:[^"\\]|\\.)*)"/g)) {
+                    try {
+                        text += JSON.parse(`"${m[1]}"`);
+                    }
+                    catch { /* not a text fragment */ }
+                }
+                if (text.length >= o.afterChars) {
+                    log(`CHAOS: cutting this stream after ${text.length} chars (${state.left} more to go)`);
+                    await new Promise((r) => setTimeout(r, 30)); // let what is queued reach the reader first
+                    try {
+                        await reader.cancel();
+                    }
+                    catch { /* already gone */ }
+                    c.error(new Error('chaos: read ECONNRESET'));
+                }
+            },
+            cancel() { reader.cancel().catch(() => { }); },
+        });
+        return new Response(body, { status: res.status, statusText: res.statusText, headers: res.headers });
+    };
+}
 /** Convenience for sites that hold a ServerResponse: the guard writes through `write`, ends through `res.end()`. */
 export function guardFor(res, o) {
     return new MidstreamGuard({ ...o, end: () => { if (!res.writableEnded)

package/dist/proxy.js

@@ -26,7 +26,7 @@ import { createTokenBucket } from './rate-limit.js';
 import { getOpenAIBackend, isOpenAIModel, forwardToOpenAI } from './openai-backend.js';
 import { forwardToCodex, getCodexModelSlugs, peekCodexModelSlugs, isCodexModel, pickCodexFallback, pickClaudeTarget, CODEX_BACKEND_BASE_URL } from './codex-backend.js';
 import { effortForCodex } from './effort.js';
-import { MidstreamGuard, guardFor, loopbackBaseFor, CONTINUATION_HEADER, MAX_CONTINUATION_DEPTH, continuationDepth } from './midstream.js';
+import { MidstreamGuard, guardFor, loopbackBaseFor, chaosCutFetch, chaosCutState, CONTINUATION_HEADER, MAX_CONTINUATION_DEPTH, continuationDepth } from './midstream.js';
 import { isClaudeServableModel } from './claude-model.js';
 import { MODEL_UNROUTABLE } from './upstream-rejection.js';
 import { readCompareTarget, teeResponse, runCompare, writeCompareRecord, COMPARE_RESULT_HEADER } from './compare.js';
@@ -1093,7 +1093,22 @@ export async function startProxy(opts = {}) {
     // Upstream auth override: a per-token API key forwards to the standard API
     // pool via `x-api-key`, bypassing OAuth/Max + the account pool entirely.
     // Env-only so the key never lands in `ps`/argv. Default (empty) = OAuth/Max.
-    const upstreamFetch = opts.fetchImpl ?? fetch;
+    // DARIO_CHAOS_CUT_AFTER=<chars> [DARIO_CHAOS_CUT_STREAMS=<n>]: the first n
+    // streamed answers die on purpose after that many characters, so the
+    // mid-stream continuation can be watched on demand. Demo and test only —
+    // loud at startup, never a default. Applied to the codex leg as well.
+    const chaosCutAfter = Number.parseInt(process.env.DARIO_CHAOS_CUT_AFTER ?? '', 10);
+    const chaosCut = Number.isFinite(chaosCutAfter) && chaosCutAfter > 0
+        ? { afterChars: chaosCutAfter, streams: Math.max(1, Number.parseInt(process.env.DARIO_CHAOS_CUT_STREAMS ?? '1', 10) || 1) }
+        : null;
+    if (chaosCut)
+        console.warn(`[dario] ⚠  CHAOS: the first ${chaosCut.streams} streamed answer${chaosCut.streams === 1 ? '' : 's'} will be cut after ${chaosCut.afterChars} chars (DARIO_CHAOS_CUT_AFTER) — demo/test only`);
+    // One cut budget for the whole proxy. The two legs wrap different fetch
+    // implementations (the Claude leg honours opts.fetchImpl, the codex leg is
+    // the global fetch), so the counter lives outside both wrappers.
+    const chaosState = chaosCut ? chaosCutState(chaosCut) : null;
+    const upstreamFetch = chaosCut && chaosState ? chaosCutFetch(opts.fetchImpl ?? fetch, chaosCut, chaosState) : (opts.fetchImpl ?? fetch);
+    const codexFetch = chaosCut && chaosState ? chaosCutFetch(fetch, chaosCut, chaosState) : fetch;
     const upstreamApiKey = (opts.upstreamApiKey ?? process.env.ANTHROPIC_UPSTREAM_API_KEY ?? '').trim();
     if (upstreamApiKey)
         console.error('[dario] upstream auth: per-token API key (x-api-key) — OAuth/Max + account pool bypassed');
@@ -3397,7 +3412,7 @@ export async function startProxy(opts = {}) {
                                 },
                             })
                             : null;
-                        const served = codexAvailable && await forwardToCodex(req, res, body, codexCreds, corsOrigin, SECURITY_HEADERS, upstreamTimeoutMs, verbose, isOpenAI ? 'openai' : 'anthropic', fetch, canDefer, 
+                        const served = codexAvailable && await forwardToCodex(req, res, body, codexCreds, corsOrigin, SECURITY_HEADERS, upstreamTimeoutMs, verbose, isOpenAI ? 'openai' : 'anthropic', codexFetch, canDefer, 
                         // Before this hook a codex request left no trace: nothing in
                         // /analytics, nothing in the request log, no per-account count.
                         // The dock (and anyone reading /analytics) saw a proxy that

package/docs/midstream-continuation.md

@@ -134,6 +134,32 @@ is never closed with a synthetic `end_turn`; only the resume's own
 | `--pool-fallback=…` | where the second hop goes; without an entry for the other provider a stream gets the same-model resume only |
 
 On by default: it only ever acts where the alternative is a broken stream.
+`dario doctor` reports which hops this host can take:
+
+```
+[ OK ]  Continuation  on: a dying stream resumes on the same model, then on gpt-5.6-sol → claude-sonnet-5 (two hops)
+[ OK ]  Continuation  on: a dying stream resumes on the same model only — add --pool-fallback for a second hop on the other subscription
+[INFO]  Continuation  off — a stream that dies mid-answer ends truncated (unset DARIO_MIDSTREAM_CONTINUE / drop --no-midstream-continue)
+```
+
+## Seeing it happen
+
+Nothing about a healthy stream shows the feature, so there is a tap that
+kills one on purpose:
+
+```bash
+DARIO_CHAOS_CUT_AFTER=300 dario proxy
+```
+
+The first streamed answer dies after 300 characters — the upstream socket is
+cut from dario's side, exactly the failure a real reset produces — and the
+continuation finishes it. Point any client at the proxy, ask for something
+long, and watch the answer keep going past the cut; a raw `curl -N` shows the
+seam comment. `DARIO_CHAOS_CUT_STREAMS=3` cuts the first three instead of one.
+The tap spares resumes, so it shows the first hop — the same model finishing
+its own answer; the other subscription takes over only when that model cannot
+serve the resume. dario warns loudly at startup while the tap is set; it is a
+demo and test affordance, never a default.
 
 ## How it was proven
 

package/package.json

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