@askalf/dario 6.6.0 → 6.6.1

package/dist/analytics.d.ts

@@ -41,7 +41,39 @@ export interface RequestRecord {
     status: number;
     isStream: boolean;
     isOpenAI: boolean;
+    /**
+     * Set when the stream died with content on the wire and the mid-stream
+     * guard acted (v6.1, src/midstream.ts): what came of it and, when a resume
+     * delivered, which leg served the rest. Absent on every ordinary request.
+     */
+    continuation?: RequestContinuation;
+}
+export interface RequestContinuation {
+    /** See midstream.ts ContinuationOutcome. */
+    outcome: 'continued' | 'continued-unfinished' | 'resume-failed' | 'no-target';
+    /** Label of the leg that served the rest (`gpt-5.6-terra (codex)`), when one did. */
+    by?: string;
+    /** Characters the client already had when the stream died. */
+    partialChars: number;
+}
+/**
+ * How the continuations in a window went. `attempted` is every stream that
+ * died with content on the wire and a guard in place; the other four
+ * partition it. The number that says whether --pool-fallback is set up to
+ * catch a dying stream, and how often one dies at all.
+ */
+export interface ContinuationStats {
+    attempted: number;
+    /** The client holds one complete message. */
+    finished: number;
+    /** A resume delivered content and then died too; the stream was left open-ended. */
+    unfinished: number;
+    /** Every choice delivered nothing; the stream ended truncated as before. */
+    failed: number;
+    /** Nothing to resume through — no --pool-fallback entry for the other provider. */
+    noTarget: number;
 }
+export declare function continuationStats(records: readonly RequestRecord[]): ContinuationStats;
 /**
  * The four billing buckets a request can land in, derived from the
  * `anthropic-ratelimit-unified-representative-claim` response header.
@@ -316,6 +348,8 @@ interface WindowStats {
     estimatedCost: number;
     avgLatencyMs: number;
     errorRate: number;
+    /** Mid-stream continuations in the window and how they went (v6.1 guard, counted since v6.6.1). */
+    continuations: ContinuationStats;
     claimBreakdown: Record<string, number>;
     /** Count of requests in each derived billing bucket. See #34. */
     billingBucketBreakdown: Record<BillingBucket, number>;

package/dist/analytics.js

@@ -18,6 +18,29 @@
  */
 import { EventEmitter } from 'node:events';
 import { createHash } from 'node:crypto';
+export function continuationStats(records) {
+    const out = { attempted: 0, finished: 0, unfinished: 0, failed: 0, noTarget: 0 };
+    for (const r of records) {
+        if (!r.continuation)
+            continue;
+        out.attempted++;
+        switch (r.continuation.outcome) {
+            case 'continued':
+                out.finished++;
+                break;
+            case 'continued-unfinished':
+                out.unfinished++;
+                break;
+            case 'resume-failed':
+                out.failed++;
+                break;
+            case 'no-target':
+                out.noTarget++;
+                break;
+        }
+    }
+    return out;
+}
 /**
  * Map the raw `representative-claim` header value to a human-friendly
  * billing bucket. Pure function; no state; safe to call from any context.
@@ -372,6 +395,7 @@ export class Analytics extends EventEmitter {
                 totalInputTokens: 0, totalOutputTokens: 0, totalThinkingTokens: 0,
                 totalCacheReadTokens: 0, totalCacheCreateTokens: 0, cachedPromptPercent: 0,
                 estimatedCost: 0, avgLatencyMs: 0, errorRate: 0,
+                continuations: { attempted: 0, finished: 0, unfinished: 0, failed: 0, noTarget: 0 },
                 claimBreakdown: {},
                 billingBucketBreakdown: {
                     subscription: 0,
@@ -418,6 +442,7 @@ export class Analytics extends EventEmitter {
             estimatedCost: Math.round(cost * 10000) / 10000,
             avgLatencyMs: Math.round(avgLatency),
             errorRate: Math.round((errors / records.length) * 10000) / 10000,
+            continuations: continuationStats(records),
             claimBreakdown: claims,
             billingBucketBreakdown: buckets,
             subscriptionPercent: subscriptionPct,

package/dist/cli.js

@@ -2450,6 +2450,19 @@ async function usage() {
         if ((win.estimatedCost ?? 0) > 0) {
             console.log(`  Est. cost:       $${(win.estimatedCost ?? 0).toFixed(4)} (would-be API cost)`);
         }
+        // Streams that died with content on the wire, and what the mid-stream
+        // guard made of them. Silent when none did — the common case.
+        const c = win.continuations;
+        if (c && c.attempted > 0) {
+            const parts = [`${c.finished} finished`];
+            if (c.unfinished > 0)
+                parts.push(`${c.unfinished} unfinished`);
+            if (c.failed > 0)
+                parts.push(`${c.failed} failed`);
+            if (c.noTarget > 0)
+                parts.push(`${c.noTarget} no target — set --pool-fallback for the other provider`);
+            console.log(`  Continuations:   ${c.attempted} stream${c.attempted === 1 ? '' : 's'} died mid-answer: ${parts.join(', ')}`);
+        }
     }
     if (perAccount && Object.keys(perAccount).length > 0) {
         console.log('');

package/dist/midstream.d.ts

@@ -65,6 +65,14 @@ export declare const CONTINUATION_HEADER = "x-dario-continuation";
 export declare const MAX_CONTINUATION_DEPTH = 2;
 /** The depth a request carries, 0 for an ordinary client request. */
 export declare function continuationDepth(headerValue: string | string[] | undefined): number;
+/**
+ * The loopback also names the request it resumes (the guard's request
+ * number), so the resume leg's own log row can point back at the row whose
+ * stream died. Log-side only: nothing routes on it.
+ */
+export declare const CONTINUATION_OF_HEADER = "x-dario-continuation-of";
+/** The request number a resume leg names, or undefined when absent / not a number. */
+export declare function continuationOfRequest(headerValue: string | string[] | undefined): number | undefined;
 /** Characters of the partial the model is asked to repeat verbatim (the seam anchor). */
 export declare const ANCHOR_CHARS = 40;
 export interface SseFrame {
@@ -304,11 +312,24 @@ export interface MidstreamGuardOptions {
     log?: (line: string) => void;
 }
 export type FinishOutcome = 'clean' | 'continued' | 'continued-unfinished' | 'ended' | 'not-continuable' | 'no-target' | 'resume-failed';
+/**
+ * What a continuation attempt came to, for the request's analytics row and
+ * log line: the four FinishOutcomes where the guard actually acted. A clean
+ * stream, one the client left, and one that was never continuable are not
+ * attempts and are not recorded.
+ */
+export type ContinuationOutcome = 'continued' | 'continued-unfinished' | 'resume-failed' | 'no-target';
 export declare class MidstreamGuard {
     private readonly o;
     readonly state: ClientStreamState;
     private readonly splitter;
     private finished;
+    /** Set by finish(): the attempt's outcome, or null when the stream needed none. */
+    outcome: ContinuationOutcome | null;
+    /** The label of the leg that put content on the wire (`gpt-5.6-terra (codex)`, `claude-opus-5 (same model)`). */
+    continuedBy: string | null;
+    /** Characters the client had when the stream died — where the seam sits. */
+    partialChars: number;
     constructor(o: MidstreamGuardOptions);
     /**
      * The site knows the upstream turn failed (a codex `response.failed`, a

package/dist/midstream.js

@@ -69,6 +69,20 @@ export function continuationDepth(headerValue) {
     const n = Number.parseInt(v, 10);
     return Number.isFinite(n) && n > 0 ? n : 1;
 }
+/**
+ * The loopback also names the request it resumes (the guard's request
+ * number), so the resume leg's own log row can point back at the row whose
+ * stream died. Log-side only: nothing routes on it.
+ */
+export const CONTINUATION_OF_HEADER = 'x-dario-continuation-of';
+/** The request number a resume leg names, or undefined when absent / not a number. */
+export function continuationOfRequest(headerValue) {
+    const v = Array.isArray(headerValue) ? headerValue[0] : headerValue;
+    if (v === undefined)
+        return undefined;
+    const n = Number.parseInt(v, 10);
+    return Number.isFinite(n) && n >= 0 ? n : undefined;
+}
 /** Characters of the partial the model is asked to repeat verbatim (the seam anchor). */
 export const ANCHOR_CHARS = 40;
 /** Upper bound on continuation text held back while looking for the anchor. */
@@ -702,6 +716,12 @@ export class MidstreamGuard {
     state;
     splitter = new SseFrameSplitter();
     finished = false;
+    /** Set by finish(): the attempt's outcome, or null when the stream needed none. */
+    outcome = null;
+    /** The label of the leg that put content on the wire (`gpt-5.6-terra (codex)`, `claude-opus-5 (same model)`). */
+    continuedBy = null;
+    /** Characters the client had when the stream died — where the seam sits. */
+    partialChars = 0;
     constructor(o) {
         this.o = o;
         this.state = new ClientStreamState(o.shape);
@@ -762,6 +782,7 @@ export class MidstreamGuard {
         // dead before its first byte) hands over to the next; the first one that
         // puts content on the wire ends the search, finished or not.
         const partial = s.textSoFar;
+        this.partialChars = partial.length;
         let tried = 0;
         for (let choice = (this.o.depth ?? 0) + 1; choice <= MAX_CONTINUATION_DEPTH; choice++) {
             let target = null;
@@ -781,15 +802,19 @@ export class MidstreamGuard {
                 continue;
             }
             this.o.end();
-            return outcome === 'finished' ? 'continued' : 'continued-unfinished';
+            this.continuedBy = target.label;
+            this.outcome = outcome === 'finished' ? 'continued' : 'continued-unfinished';
+            return this.outcome;
         }
         if (tried === 0) {
             this.log(`#${this.o.requestNo} stream died after ${partial.length} chars — no continuation target (set --pool-fallback with an entry for the other provider)`);
             cleanEnd();
-            return 'no-target';
+            this.outcome = 'no-target';
+            return this.outcome;
         }
         cleanEnd();
-        return 'resume-failed';
+        this.outcome = 'resume-failed';
+        return this.outcome;
     }
     /**
      * 'failed': nothing of the resume reached the client — the site ends the
@@ -817,7 +842,7 @@ export class MidstreamGuard {
             r.onBeforeResume?.();
             const res = await fetchImpl(`${r.loopbackBase}${path}`, {
                 method: 'POST',
-                headers: { 'content-type': 'application/json', [CONTINUATION_HEADER]: String((this.o.depth ?? 0) + 1), ...r.loopbackHeaders },
+                headers: { 'content-type': 'application/json', [CONTINUATION_HEADER]: String((this.o.depth ?? 0) + 1), [CONTINUATION_OF_HEADER]: String(this.o.requestNo), ...r.loopbackHeaders },
                 body: JSON.stringify(body),
                 signal: abort.signal,
             });

package/dist/proxy.d.ts

@@ -586,6 +586,15 @@ export interface ProxyLogEntry {
     client?: string;
     preserve_tools?: boolean;
     stream?: boolean;
+    /** Mid-stream continuation outcome, when this request's guard acted (see analytics RequestContinuation). */
+    continued?: 'continued' | 'continued-unfinished' | 'resume-failed' | 'no-target';
+    continued_by?: string;
+    /** Characters the client already had when the stream died. */
+    continued_after?: number;
+    /** On a resume leg: how deep it sits (1 = resume of a client request, 2 = resume of a resume). */
+    continuation_depth?: number;
+    /** On a resume leg: the request number whose stream it resumes (the guard's number). */
+    continuation_of?: number;
     reject?: string;
     error?: string;
     event?: string;

package/dist/proxy.js

@@ -27,7 +27,19 @@ import { createTokenBucket } from './rate-limit.js';
 import { getOpenAIBackend, isOpenAIModel, forwardToOpenAI } from './openai-backend.js';
 import { forwardToCodex, forwardResponsesToCodex, getCodexModelSlugs, peekCodexModelSlugs, isCodexModel, pickCodexFallback, pickClaudeTarget, CODEX_BACKEND_BASE_URL } from './codex-backend.js';
 import { effortForCodex } from './effort.js';
-import { MidstreamGuard, guardFor, loopbackBaseFor, chaosCutFetch, chaosCutState, CONTINUATION_HEADER, MAX_CONTINUATION_DEPTH, continuationDepth } from './midstream.js';
+import { MidstreamGuard, guardFor, loopbackBaseFor, chaosCutFetch, chaosCutState, CONTINUATION_HEADER, CONTINUATION_OF_HEADER, MAX_CONTINUATION_DEPTH, continuationDepth, continuationOfRequest } from './midstream.js';
+/**
+ * The continuation fields for a request's analytics row, from its guard.
+ * Only the client's own request (depth 0) carries them: a resume leg is a
+ * loopback request with a guard of its own, and counting its attempt too
+ * would show one dying client stream as two. The log line still carries
+ * every leg's outcome — that is where the hop-by-hop story is read.
+ */
+function continuationOf(guard, depth) {
+    if (!guard || !guard.outcome || depth > 0)
+        return undefined;
+    return { outcome: guard.outcome, ...(guard.continuedBy ? { by: guard.continuedBy } : {}), partialChars: guard.partialChars };
+}
 import { responsesRequestToAnthropic, unsupportedOnClaudeError, ResponsesRequestError, ResponsesOut, wrapResponsesClient } from './responses-inbound.js';
 import { isClaudeServableModel } from './claude-model.js';
 import { MODEL_UNROUTABLE } from './upstream-rejection.js';
@@ -3129,6 +3141,12 @@ export async function startProxy(opts = {}) {
             // never continued itself (MAX_CONTINUATION_DEPTH).
             const requestDepth = continuationDepth(req.headers[CONTINUATION_HEADER]);
             const isContinuation = requestDepth >= MAX_CONTINUATION_DEPTH;
+            // A resume leg's log row points back at the request whose stream died
+            // (its guard's number) and says how deep it sits, so the hop-by-hop
+            // story is readable from the log alone. Empty on a client request.
+            const continuationLeg = requestDepth > 0
+                ? { continuation_depth: requestDepth, continuation_of: continuationOfRequest(req.headers[CONTINUATION_OF_HEADER]) }
+                : {};
             /**
              * First hop: the SAME model again, through the front door. The pool
              * picks a seat (sticky binding keeps the prompt cache warm), and if the
@@ -3650,6 +3668,7 @@ export async function startProxy(opts = {}) {
                                 // overage guard (#288) leaves it alone.
                                 claim: CODEX_CLAIM, util5h: 0, util7d: 0, overageUtil: 0,
                                 latencyMs: o.latencyMs, status: o.status, isStream: o.stream, isOpenAI,
+                                continuation: continuationOf(codexGuard, requestDepth),
                             });
                             writeLogLine(logFileStream, {
                                 ts: new Date().toISOString(), req: codexReq,
@@ -3657,6 +3676,8 @@ export async function startProxy(opts = {}) {
                                 status: o.status, latency_ms: o.latencyMs, in_tokens: o.inputTokens, out_tokens: o.outputTokens,
                                 cache_read: o.cacheReadTokens, cache_create: o.cacheCreateTokens,
                                 claim: CODEX_CLAIM, bucket: 'subscription', account: o.alias, consumer, stream: o.stream,
+                                ...(codexGuard?.outcome ? { continued: codexGuard.outcome, continued_by: codexGuard.continuedBy ?? undefined, continued_after: codexGuard.partialChars } : {}),
+                                ...continuationLeg,
                             });
                             if (verbose)
                                 console.log(formatUsageLogLine(codexReq, {
@@ -5182,6 +5203,7 @@ export async function startProxy(opts = {}) {
                         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,
+                        continuation: continuationOf(guard, requestDepth),
                     });
                 }
                 writeLogLine(logFileStream, {
@@ -5198,6 +5220,8 @@ export async function startProxy(opts = {}) {
                     client: detectedClientForLog,
                     preserve_tools: preserveToolsEffective,
                     stream: true,
+                    ...(guard?.outcome ? { continued: guard.outcome, continued_by: guard.continuedBy ?? undefined, continued_after: guard.partialChars } : {}),
+                    ...continuationLeg,
                 });
                 if (verbose)
                     console.log(formatUsageLogLine(requestCount, {

package/docs/midstream-continuation.md

@@ -161,6 +161,32 @@ 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.
 
+## Seeing it after the fact
+
+A continuation leaves three traces. The SSE comment on the wire
+(`: dario continuation gpt-5.6-terra (codex live) after 1204 chars`) is the
+one a raw capture shows; every SSE parser ignores it. The request log
+(`--log-file`) tells the hop-by-hop story: the row of a request whose stream
+died carries `continued` (`continued`, `continued-unfinished`,
+`resume-failed`, `no-target`), `continued_by` (the leg that served the rest)
+and `continued_after` (characters the client already had); every resume leg
+has a row of its own with `continuation_depth` (1, or 2 for the resume of a
+resume) and `continuation_of`, the number of the request it resumed — and,
+when it died too, its own `continued_*` fields. A two-hop resume is three
+rows that point at each other. `/analytics` tallies per window under
+`continuations`: `attempted`, split into `finished`, `unfinished`, `failed`
+and `noTarget`. Only the client's own request counts there — a resume leg is
+a loopback request with a guard of its own, and counting its attempt too
+would show one dying stream as two. `dario usage` prints the tally as one
+line when anything died:
+
+```
+  Continuations:   3 streams died mid-answer: 2 finished, 1 unfinished
+```
+
+`noTarget` above zero is the line to act on: streams are dying and there is
+no `--pool-fallback` entry for the other provider to finish them.
+
 ## How it was proven
 
 `test/midstream-continuation-wiring.mjs` runs a real proxy against a fake

package/package.json

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