@askalf/dario 6.0.53 → 6.1.0

package/README.md

@@ -27,7 +27,7 @@
 
 <p><strong>One local endpoint. Every AI tool you own. The subscriptions you already pay for.</strong></p>
 
-<sub><code>npm i -g @askalf/dario</code> · <strong>0</strong> runtime deps · <a href="https://www.npmjs.com/package/@askalf/dario">SLSA-attested</a> every release · nothing phones home · ~33k lines you can read in a weekend · independent, unofficial, third-party (<a href="DISCLAIMER.md">DISCLAIMER.md</a>)</sub>
+<sub><code>npm i -g @askalf/dario</code> · <strong>0</strong> runtime deps · <a href="https://www.npmjs.com/package/@askalf/dario">SLSA-attested</a> every release · nothing phones home · ~34k lines you can read in a weekend · independent, unofficial, third-party (<a href="DISCLAIMER.md">DISCLAIMER.md</a>)</sub>
 
 <sub><a href="#start-in-60-seconds">Start</a> · <a href="#point-your-tools-at-it">Your tools</a> · <a href="#what-it-does-with-a-request">Routing</a> · <a href="#two-plans-one-endpoint">Two plans</a> · <a href="#many-seats-one-endpoint">Pool</a> · <a href="#it-tracks-a-moving-target">Drift</a> · <a href="#trust--transparency">Trust</a> · <a href="#will-my-account-get-suspended">Risk</a> · <a href="#commands">Commands</a> · <a href="#faq">FAQ</a> · <a href="docs/returning.md">Coming back after a while?</a></sub>
 
@@ -289,6 +289,8 @@ That is a **chain**, read left to right; each provider takes the first entry it
 
 A single-entry chain is one-way and means what it always meant, so an existing config is unaffected. Failover is opt-in: without `--pool-fallback`, a drained pool still returns its honest 429/503. Only a **429 or 5xx** fails over; a 400 surfaces, because a bad request that fails over just reproduces itself on the other provider and buries the real cause. A 429 also cools that provider for a bounded interval, its `retry-after` if it sent one and 60 s otherwise, never longer than 15 min, and an entry that already declined is not asked again within the same request. When every entry is cooling, the request ends on one honest `429` with a `retry-after` instead of a retry storm. The Claude entry has to be a model the pool can actually serve, checked positively against the live catalog, so a typo can't trade a recoverable 429 for an unrecoverable 404.
 
+The chain also covers a stream that dies **mid-answer**. Until 6.1 that was the one failure nothing could catch: bytes were on the wire, so the socket reset, the in-band `overloaded_error`, the codex `response.failed` all ended the stream where they happened, with no `message_stop`, and the client threw away every word it already had. Now dario finishes the same stream from the other subscription — the resume picks up inside the still-open content block, a comment marks the seam (`: dario continuation gpt-5.6-sol (codex live) after 1240 chars`), and the client sees one message. The model is asked to repeat the last few words verbatim and dario trims the repeat, so the join is rendered by a model and cut by a parser, never guessed. Text only — a cut inside a tool call ends as it always did. On by default, `--no-midstream-continue` turns it off, and without a chain entry for the other provider it is inert. [How it works](docs/midstream-continuation.md).
+
 `dario doctor` tells you which of these you are actually in:
 
 ```

package/dist/cli.js

@@ -625,6 +625,11 @@ async function proxy() {
     // ProxyOptions.honorClientThinking for rationale.
     const honorClientThinking = args.includes('--honor-client-thinking')
         || ['1', 'true', 'yes', 'on'].includes((process.env['DARIO_HONOR_CLIENT_THINKING'] ?? '').toLowerCase());
+    // --no-midstream-continue / DARIO_MIDSTREAM_CONTINUE=0 — turn off finishing
+    // a streamed answer that dies mid-way from the other subscription (v6.1).
+    // On by default; see ProxyOptions.midstreamContinue.
+    const midstreamContinue = !(args.includes('--no-midstream-continue')
+        || ['0', 'false', 'no', 'off'].includes((process.env['DARIO_MIDSTREAM_CONTINUE'] ?? '').toLowerCase()));
     // --preserve-output-format — carry the client body's `output_config.format`
     // (structured-output JSON schema) through to upstream instead of dropping it
     // during the CC rebuild. See ProxyOptions.preserveOutputFormat for rationale.
@@ -649,7 +654,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, fastModel, noClaudeAuth, 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, maxConcurrentPerConsumer, poolStrategy, poolSharedState, poolSharedStateIntervalMs, effort, maxTokens, poolFallbackModel, modelAliases, logFile, passthroughBetas, skipFields, systemPrompt, overageGuardEnabled, overageGuardBehavior, overageGuardCooldownMs, overageGuardNotifyOs, honorClientThinking, preserveOutputFormat });
+    await startProxy({ port, host, verbose, verboseBodies, model, fastModel, noClaudeAuth, 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, maxConcurrentPerConsumer, poolStrategy, poolSharedState, poolSharedStateIntervalMs, effort, maxTokens, poolFallbackModel, modelAliases, logFile, passthroughBetas, skipFields, systemPrompt, overageGuardEnabled, overageGuardBehavior, overageGuardCooldownMs, overageGuardNotifyOs, honorClientThinking, preserveOutputFormat, midstreamContinue });
 }
 /**
  * Parse `--system-prompt=<verbatim|partial|aggressive|filepath>` (or the
@@ -1686,6 +1691,19 @@ async function help() {
                              is fully generated even if nobody reads
                              it) for fingerprint fidelity. Bounded by
                              the 5-minute upstream timeout. (v3.25)
+    --no-midstream-continue  Do not finish a streamed answer that dies
+                             mid-way from the other subscription. By
+                             default a stream that breaks with content
+                             already on the wire (socket reset,
+                             overloaded_error, codex response.failed)
+                             is resumed through dario's own front door
+                             at the other provider's entry in
+                             --pool-fallback, spliced onto the same
+                             client stream, and closed cleanly; the
+                             client sees one message. Off, or with no
+                             fallback entry for the other provider,
+                             the stream ends truncated as before.
+                             Env: DARIO_MIDSTREAM_CONTINUE=0. (v6.1)
     --session-idle-rotate=MS Idle ms before an account's session id
                              rotates (default: 900000 = 15 min).
                              Real CC rotates once per conversation, not

package/dist/codex-backend.d.ts

@@ -3,6 +3,7 @@ import type { CodexAccountCredentials } from './codex-accounts.js';
 import { type ResponsesReasoningConfig, type ResponsesUsage } from './anthropic-responses-translate.js';
 import { type ModelResolver, type ClaudeTarget } from './claude-model.js';
 import { type EffortValue } from './effort.js';
+import type { MidstreamGuard } from './midstream.js';
 export declare const CODEX_BACKEND_BASE_URL: string;
 /**
  * Client version sent on the model-discovery call. The backend REQUIRES the
@@ -143,6 +144,13 @@ export type CodexRequestShape = 'openai' | 'anthropic';
  * the chat-path half was the same bug, pre-existing.
  */
 export declare function isTerminalResponsesEvent(type: string): boolean;
+/**
+ * Whether a raw Responses SSE line carries a failed terminal event — the same
+ * test the chat translator applies once it has parsed the line, run here so a
+ * mid-stream continuation guard learns of the failure before the translator's
+ * error + `[DONE]` frames are written.
+ */
+export declare function isFailedResponsesLine(line: string): boolean;
 /** True when a terminal Responses payload describes a FAILURE rather than a turn. */
 export declare function isFailedResponse(resp: unknown): boolean;
 /** The upstream message on a failed Responses payload, for the error body. */
@@ -289,4 +297,11 @@ export declare function forwardToCodex(req: IncomingMessage, res: ServerResponse
  * a chat/completions caller sets `reasoning_effort` itself and that already
  * translates. Undefined leaves the request exactly as it was.
  */
-effort?: ResponsesReasoningConfig['effort']): Promise<boolean>;
+effort?: ResponsesReasoningConfig['effort'], 
+/**
+ * Mid-stream continuation guard (v6.1, src/midstream.ts). When present,
+ * every streamed frame goes through it and it owns the streaming exits: a
+ * stream that dies with content on the wire is finished from the Claude
+ * pool instead of ending truncated.
+ */
+midstream?: MidstreamGuard | null): Promise<boolean>;

package/dist/codex-backend.js

@@ -419,6 +419,23 @@ export function chatCompletionsToResponses(body) {
 export function isTerminalResponsesEvent(type) {
     return type === 'response.completed' || type === 'response.incomplete' || type === 'response.failed';
 }
+/**
+ * Whether a raw Responses SSE line carries a failed terminal event — the same
+ * test the chat translator applies once it has parsed the line, run here so a
+ * mid-stream continuation guard learns of the failure before the translator's
+ * error + `[DONE]` frames are written.
+ */
+export function isFailedResponsesLine(line) {
+    if (!line.startsWith('data: ') || !line.includes('"response.'))
+        return false;
+    try {
+        const e = JSON.parse(line.slice(6));
+        return e.type === 'response.failed' || (isTerminalResponsesEvent(e.type ?? '') && isFailedResponse(e.response));
+    }
+    catch {
+        return false;
+    }
+}
 /** True when a terminal Responses payload describes a FAILURE rather than a turn. */
 export function isFailedResponse(resp) {
     if (!resp || typeof resp !== 'object')
@@ -761,7 +778,14 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
  * a chat/completions caller sets `reasoning_effort` itself and that already
  * translates. Undefined leaves the request exactly as it was.
  */
-effort) {
+effort, 
+/**
+ * Mid-stream continuation guard (v6.1, src/midstream.ts). When present,
+ * every streamed frame goes through it and it owns the streaming exits: a
+ * stream that dies with content on the wire is finished from the Claude
+ * pool instead of ending truncated.
+ */
+midstream) {
     void req;
     const isAnthropic = shape === 'anthropic';
     // Reported exactly once, on every exit that answered the client. Without
@@ -832,8 +856,22 @@ effort) {
     res.on('close', onClientClose);
     // Every streamed write goes through here: after a disconnect the socket is
     // gone and writing to it is wasted at best, an EPIPE at worst.
-    const write = (chunk) => { if (!clientGone)
-        res.write(chunk); };
+    const write = (chunk) => {
+        if (clientGone)
+            return;
+        if (midstream)
+            midstream.write(chunk);
+        else
+            res.write(chunk);
+    };
+    // The streaming exits: the guard decides whether the stream is complete,
+    // continuable, or simply over.
+    const endStream = async () => {
+        if (midstream)
+            await midstream.finish();
+        else
+            res.end();
+    };
     // Usage seen so far, so a stream the client abandoned still reports what the
     // subscription already spent. Populated once the translators exist.
     let usageSoFar = () => null;
@@ -908,6 +946,11 @@ effort) {
                         terminalResponse = r;
                     if (t === 'response.failed')
                         anthropicFailed = true;
+                    // Flag it BEFORE the translator closes the turn: on this shape a
+                    // failed turn still ends in message_delta + message_stop, which the
+                    // guard must withhold to see the stream as unfinished.
+                    if (midstream && (anthropicFailed || isFailedResponse(r)))
+                        midstream.markUpstreamFailed();
                 }
                 const produced = antTranslator.push(ev);
                 if (!clientWantsStream)
@@ -951,6 +994,8 @@ effort) {
                     const lines = buffered.split('\n');
                     buffered = lines.pop() ?? '';
                     for (const line of lines) {
+                        if (midstream && isFailedResponsesLine(line))
+                            midstream.markUpstreamFailed();
                         const out = translator.chunk(line);
                         if (out && clientWantsStream)
                             write(out);
@@ -999,7 +1044,7 @@ effort) {
                 for (const out of antTranslator.end())
                     write(formatResponsesAnthropicSSE(out));
                 finished = true;
-                res.end();
+                await endStream();
             }
             else {
                 res.writeHead(200, {
@@ -1014,7 +1059,7 @@ effort) {
         }
         else if (clientWantsStream) {
             finished = true;
-            res.end();
+            await endStream();
         }
         else {
             res.writeHead(200, {
@@ -1072,9 +1117,12 @@ effort) {
             res.end(errBody('Upstream Codex backend error', { account: creds.alias }));
         }
         else {
+            // Headers are out and the socket reset under a live stream — the case
+            // the guard exists for. Without one this is the truncated stream it
+            // always was.
             finished = true;
             try {
-                res.end();
+                await endStream();
             }
             catch { /* already closed */ }
         }

package/dist/midstream.d.ts

@@ -0,0 +1,321 @@
+/**
+ * Mid-stream continuation (v6.1) — the answer does not stop when the plan does.
+ *
+ * Until now a streamed `/v1/messages` (or `/v1/chat/completions`) answer that
+ * died part-way through — an upstream socket reset, an in-band
+ * `overloaded_error`, a codex `response.failed` — ended with `res.end()` and
+ * the client got a truncated stream: no `message_stop`, no `[DONE]`, an SDK
+ * that throws "stream ended without producing a Message", and every word
+ * already on screen wasted. Once bytes were on the wire the request was
+ * treated as too late to hand to anyone else.
+ *
+ * This module finishes the SAME client stream from the other subscription
+ * instead. It sits between the request handler and the client socket:
+ *
+ *   1. every frame written to the client passes through `write()`, which
+ *      tracks what the client has already seen (message_start, the open
+ *      content block, the text so far) and WITHHOLDS a terminal error frame
+ *      rather than forwarding it;
+ *   2. `finish()` replaces the site's `res.end()`. A clean stream ends as
+ *      before. A stream that died with content on the wire re-issues the
+ *      request through dario's own front door (a loopback POST — so the pool,
+ *      the codex translator, cch and every other rule apply to the resume
+ *      exactly as to any client request) at the OTHER provider, with the
+ *      partial answer appended as the assistant turn and a resume notice as
+ *      the user turn;
+ *   3. the resume stream is spliced onto the client's still-open block: its
+ *      message_start and thinking blocks are dropped, its first text block
+ *      continues the open index, anything after that is renumbered, and it
+ *      closes the message with its own message_delta / message_stop.
+ *
+ * Two things the spike (2026-09-11, prod 6.0.51, real Opus 5 + real ChatGPT
+ * Plus) settled that are easy to get wrong again:
+ *
+ *   - NO assistant prefill. Claude 4.6+/5 answers a trailing assistant turn
+ *     with a 400, and the Responses API never had the concept. The resume is
+ *     instruction-driven on both providers, which works — zero restarts, zero
+ *     preamble, zero repetition across ten real runs.
+ *   - The seam is a WHITESPACE problem, not a content problem. Told merely to
+ *     "continue", Claude-as-continuer dropped the boundary space 2/3 times
+ *     (`replies<CUT>with`, a 3-vs-4-space indent). So the notice asks the model
+ *     to begin by repeating the last ~40 characters verbatim, and `findAnchor`
+ *     trims that repeat with a whitespace-normalized match. The model renders
+ *     the seam inside its own token stream; we only cut. Matched exactly 5/5.
+ *
+ * Out of scope here, on purpose: a cut inside a tool_use block (the partial
+ * JSON is not resumable), non-streaming requests (nothing is on the wire yet;
+ * the existing pre-byte failover covers them), and the api-key OpenAI backend.
+ * A stream that cannot be continued ends exactly as it did before this module.
+ */
+import type { ServerResponse } from 'node:http';
+export type WireShape = 'anthropic' | 'openai';
+/** Client-visible marker that a loopback request is a continuation, so the handler never nests one. */
+export declare const CONTINUATION_HEADER = "x-dario-continuation";
+/** Characters of the partial the model is asked to repeat verbatim (the seam anchor). */
+export declare const ANCHOR_CHARS = 40;
+export interface SseFrame {
+    /** The frame exactly as it will go on the wire, trailing blank line included. */
+    raw: string;
+    /** `event:` field, or the JSON `type` when the event line is absent. */
+    event: string;
+    /** Parsed `data:` payload, null for comments and non-JSON data. */
+    data: Record<string, unknown> | null;
+    /** The literal data text (`[DONE]` for the OpenAI sentinel). */
+    dataText: string | null;
+    comment: boolean;
+}
+/**
+ * Splits a byte/text stream into complete SSE frames. A trailing partial frame
+ * stays buffered until its blank line arrives. Frames are returned with their
+ * original bytes, so forwarding `raw` is byte-identical to the input.
+ */
+export declare class SseFrameSplitter {
+    private buf;
+    private readonly decoder;
+    feed(chunk: string | Uint8Array): SseFrame[];
+    /** Whatever is buffered and not yet a complete frame. */
+    flush(): string;
+}
+export declare function parseFrame(raw: string): SseFrame;
+export declare function formatFrame(event: string, data: unknown): string;
+interface BlockState {
+    type: string;
+    open: boolean;
+    text: string;
+}
+/**
+ * The client-side state a continuation has to pick up from. Both shapes are
+ * tracked by ONE class so the guard has a single view: `blocks` carries
+ * Anthropic content blocks; on the OpenAI shape there is exactly one implicit
+ * text block (index 0) that opens on the first content delta.
+ */
+export declare class ClientStreamState {
+    readonly shape: WireShape;
+    started: boolean;
+    finished: boolean;
+    blocks: BlockState[];
+    /**
+     * Frames the guard withheld instead of forwarding, in order: a terminal
+     * error, and — once the site has flagged the upstream as failed — the
+     * closing frames a translator emits for a failed turn. Released verbatim
+     * if no continuation happens, so the client sees exactly what it would have.
+     */
+    withheld: SseFrame[];
+    /**
+     * Set by the site when it KNOWS the upstream turn failed even though the
+     * translator will close it politely (the codex Anthropic path answers
+     * `response.failed` with message_delta + message_stop). The closing frames
+     * are then withheld so the stream reads as unfinished, i.e. continuable.
+     */
+    upstreamFailed: boolean;
+    /** True once anything non-continuable was seen (tool_use in progress, tool_calls). */
+    toolInProgress: boolean;
+    forwardedFrames: number;
+    /** message_start's message.model — kept so a continuation can name what the client believes it is talking to. */
+    model: string | null;
+    constructor(shape: WireShape);
+    get openIdx(): number;
+    get openType(): string | null;
+    /** Every text emitted so far, blocks concatenated in order. */
+    get textSoFar(): string;
+    /** Text of the open text block only — what the seam anchor is cut from. */
+    get openText(): string;
+    /**
+     * Whether a stream that stopped HERE can be continued: bytes are on the
+     * wire, the message is not finished, and nothing non-resumable is open.
+     * An open tool_use block or an OpenAI tool call in flight is a definite no —
+     * half a JSON argument object cannot be handed to another model.
+     */
+    get continuable(): boolean;
+    /**
+     * Observe one client-bound frame. Returns false when the frame is a terminal
+     * error the guard should withhold (recorded in `withheld`), true to forward.
+     */
+    observe(f: SseFrame): boolean;
+    private observeAnthropic;
+    private observeOpenAI;
+}
+/**
+ * The tail of the partial the model is told to repeat. Starts at a
+ * non-whitespace character: the API strips a reply's leading whitespace, so an
+ * anchor beginning with a space could never be matched exactly.
+ */
+export declare function anchorOf(partial: string): string;
+/**
+ * Locate the repeated anchor at the head of the continuation and return the
+ * raw offset just past it, or null when the model did not repeat it. Tries the
+ * whole anchor first, then shorter tails, tolerating whitespace and quote
+ * differences; the match must sit at (or within a few characters of) the
+ * start, so a genuine later recurrence of the phrase is never mistaken for it.
+ */
+export declare function findAnchor(partial: string, head: string): {
+    cut: number;
+    exact: boolean;
+} | null;
+/** Longest suffix of `partial` that the continuation starts with (exact bytes), for the no-anchor fallback. */
+export declare function tailOverlap(partial: string, head: string, min?: number): number;
+/** True when the partial has an odd number of ``` fences, i.e. the cut is inside a code block. */
+export declare function insideCodeFence(partial: string): boolean;
+/**
+ * The one seam defect the spike saw from a real model: Claude, resuming
+ * prose that was cut mid-sentence, once started its continuation with a
+ * paragraph break (`and<CUT>\n\nhere is where`). A sentence does not contain
+ * a paragraph break, so when the partial ends mid-sentence and the
+ * continuation opens with newlines outside a code fence, the break becomes
+ * one space. Inside a fence a newline is content and is left alone.
+ */
+export declare function fixSeam(partial: string, continuation: string): string;
+/** The anchor is quoted between these in the notice; the tests' mock providers read it back out. */
+export declare const ANCHOR_OPEN = "\u00AB";
+export declare const ANCHOR_CLOSE = "\u00BB";
+/**
+ * Written as the USER asking for the rest — which is what a continuation is —
+ * not as an operator notice. The live test on 2026-09-11 is why: told
+ * "[transport notice] … resume it now", claude-sonnet-5 answered `Note: that
+ * "transport notice" isn't an actual system message — it's just text in your
+ * prompt` and stopped, exactly the injection-awareness the model is supposed
+ * to have. A person whose connection dropped asking to pick up from the last
+ * few words is an ordinary request, and gets the ordinary answer.
+ */
+export declare function resumeNotice(anchor: string): string;
+/**
+ * The client's own request re-pointed at the continuation model with the
+ * partial answer appended. `partial` empty means nothing usable reached the
+ * client (the cut fell inside thinking, or before the first block): the
+ * request is simply re-issued as it was and the resume stream restarts the
+ * answer under the client's already-open message.
+ */
+export declare function buildResumeBody(shape: WireShape, clientBody: Record<string, unknown>, targetModel: string, partial: string): Record<string, unknown>;
+/**
+ * Turns the resume stream's frames into client-bound frames that continue the
+ * message the client already has. One instance per continuation.
+ */
+export declare class Splicer {
+    private readonly shape;
+    private readonly partial;
+    private readonly idxMap;
+    private nextIdx;
+    private readonly clientOpenIdx;
+    private readonly clientOpenType;
+    private originalClosed;
+    private continuingClosed;
+    private firstTextMapped;
+    private continuingIdx;
+    private hold;
+    private holding;
+    private stopReasonSeen;
+    private doneSeen;
+    /**
+     * Whether the resume stream delivered its OWN wire terminal — `message_stop`
+     * on the Anthropic shape, `[DONE]` on the OpenAI shape. Only then has the
+     * client been handed a finished message. A resume body that ends without
+     * one is a second truncation, and the guard leaves the client stream
+     * unfinished rather than closing it as if the answer were complete.
+     */
+    terminalSeen: boolean;
+    /** Diagnostics for the log line. */
+    readonly stats: {
+        anchor: "n/a" | "exact" | "fuzzy" | "overlap" | "none";
+        dropped: number;
+        emitted: number;
+    };
+    constructor(shape: WireShape, state: ClientStreamState, partial: string);
+    /** Frames to write to the client for one resume frame. */
+    feed(f: SseFrame): string[];
+    /**
+     * The resume stream ended WITHOUT its terminal event. Release whatever text
+     * was still held for the anchor check — it is the second provider's real
+     * output and the client may as well have it — but close nothing: no
+     * content_block_stop, no message_delta/message_stop, no finish chunk, no
+     * [DONE]. A synthesized clean end here would present a doubly-truncated
+     * answer as a complete one (review finding on #1286).
+     */
+    abandon(): string[];
+    private feedAnthropic;
+    /** Close the block the resume has been writing into, once. */
+    private closeContinuing;
+    /** Close the block the client had open when the primary died, once, unless the resume is continuing it. */
+    private closeOriginal;
+    private feedOpenAI;
+    /**
+     * Text from the resume's first text block is held until the anchor is
+     * found (or enough has arrived to give up looking), then trimmed and
+     * released. After that every delta streams straight through.
+     */
+    private releaseHold;
+}
+export interface ContinuationTarget {
+    /** The model spelling the loopback request carries (`codex:gpt-5.6-terra:high`, `claude:claude-opus-5`). */
+    model: string;
+    /** Human-readable, for the log line and the SSE comment. */
+    label: string;
+}
+export interface ResumeOptions {
+    /**
+     * The client's request as it arrived, before dario's own rewrites. A
+     * function so the bytes are parsed only when a resume actually happens —
+     * never on the hot path of a stream that ends normally.
+     */
+    clientBody: () => Record<string, unknown> | null;
+    /** `http://127.0.0.1:<port>` — dario's own front door. */
+    loopbackBase: string;
+    /** Auth + attribution headers for the loopback request. */
+    loopbackHeaders: Record<string, string>;
+    /** Decides where to resume, once, at failure time. Null = nowhere; the stream ends as before. */
+    resolveTarget: () => Promise<ContinuationTarget | null>;
+    /** Called right before the loopback request is made — the site releases its own queue slot here. */
+    onBeforeResume?: () => void;
+    timeoutMs: number;
+    fetchImpl?: typeof fetch;
+}
+export interface MidstreamGuardOptions {
+    shape: WireShape;
+    /** The site's client writer (already gated on client disconnect). */
+    write: (chunk: string) => void;
+    /** The real `res.end()`. */
+    end: () => void;
+    isClientGone: () => boolean;
+    resume: ResumeOptions | null;
+    requestNo: number;
+    verbose: boolean;
+    log?: (line: string) => void;
+}
+export type FinishOutcome = 'clean' | 'continued' | 'continued-unfinished' | 'ended' | 'not-continuable' | 'no-target' | 'resume-failed';
+export declare class MidstreamGuard {
+    private readonly o;
+    readonly state: ClientStreamState;
+    private readonly splitter;
+    private finished;
+    constructor(o: MidstreamGuardOptions);
+    /**
+     * The site knows the upstream turn failed (a codex `response.failed`, a
+     * terminal payload with an error status) before the translator's polite
+     * closing frames go out. From here on those frames are withheld, so the
+     * stream is treated as unfinished — and finished from the other provider.
+     */
+    markUpstreamFailed(): void;
+    /** Forward a client-bound chunk, withholding a terminal error frame. */
+    write(chunk: string | Uint8Array): void;
+    /**
+     * End the client response. Replaces the site's `res.end()` on the streaming
+     * exits. Resolves once the client stream is closed either way.
+     */
+    finish(): Promise<FinishOutcome>;
+    /**
+     * 'failed': nothing of the resume reached the client — the site ends the
+     * stream exactly as it would have. 'finished': the resume delivered its
+     * terminal event and the client holds one complete message. 'unfinished':
+     * the resume put content on the wire and then died too; the stream is left
+     * open-ended (no synthesized close) so the client sees the truncation.
+     */
+    private continueFrom;
+    private log;
+}
+/** 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;
+/**
+ * The loopback origin for a bound listen address. A wildcard bind is reached
+ * on the loopback interface; a specific address is reached on itself.
+ */
+export declare function loopbackBaseFor(host: string, port: number): string;
+export {};