@pentoshi/clai 4.11.5 → 4.11.8

package/dist/llm/http.js

@@ -1,21 +1,21 @@
-import { cacheAffinityKey } from "./cache-affinity.js";
-import { modelAcceptsImages, modelSupportsThinking, isReasoningUnsupported, modelReasoningEfforts, learnModelEmitsReasoning, registerModelCatalog, } from "./capabilities.js";
-import { catalogEffortList, catalogEntriesFromPayload, parseCatalogFacts, } from "./catalog-facts.js";
-import { resolveSampling } from "./sampling.js";
-import { accumulateOpenAiToolCallDelta, finalizeOpenAiToolCalls, fromWireName, parseOpenAiMessageToolCalls, } from "./tool-protocol.js";
-import { openAiToolBodyFields, toOpenAiToolMessages, } from "./adapters/openai-tools.js";
-import { parseFireworksUsage, parseOpenAiUsage, withReasoningObservation, } from "./token-usage.js";
-import { generationFetch } from "./operation-usage.js";
-import { isOperationPolicyError } from "./operation-ledger.js";
-import { emitStreamReasoningArtifacts, emitStreamReasoningDelta, } from "./stream-events.js";
-import { CHAT_COMPLETIONS_STREAM_TERMINAL, requireTerminalProof, } from "./stream-terminal.js";
-import { modelMaxOutputTokens } from "./context-windows.js";
-import { inBandBadRequestStatus, isMissingReasoningContentError, } from "./reasoning-errors.js";
-import { emitReasoningControls, } from "./reasoning-controls.js";
-import { createReasoningArtifact, createReasoningArtifactProvenance, reasoningArtifactsObserved, visibleReasoningDetailText, } from "./reasoning-artifacts.js";
-import { classifyBynaraModel, classifyNvidiaModel, } from "./model-families.js";
-import { compileRequestPlan, } from "./request-plan.js";
-import { singleLeadingSystemMessages } from "./system-messages.js";
+import { readJson } from "./wire/response-errors.js";
+import { DEFAULT_STREAM_IDLE_TIMEOUT_MS, STREAM_STALL_MARKER, THINKING_STREAM_IDLE_TIMEOUT_MS, THINKING_STREAM_INITIAL_IDLE_TIMEOUT_MS, createSseFrameAssembler, } from "./wire/stream-framing.js";
+import { buildReasoningPayload, } from "./wire/reasoning-payload.js";
+import { chatCompletionsBodyFromPlan } from "./wire/chat-body.js";
+import { compatibleArtifactPolicyFor, } from "./wire/reasoning-artifacts.js";
+export { openAiCompatibleStream } from "./wire/openai-stream.js";
+export { openAiCompatibleComplete, openAiCompatiblePing, } from "./wire/openai-complete.js";
+export { catalogEntryVision, ingestModelCatalogEntries, ingestOpenAiModelCatalog, } from "./wire/model-catalog.js";
+export { toCompletionResult } from "./wire/reasoning-artifacts.js";
+export { compatibleArtifactPolicyFor };
+export { buildChatBody, isOpenAiReasoningModel, toOpenAiMessages, } from "./wire/chat-body.js";
+export { chatCompletionsBodyFromPlan };
+export { imageCapableMessages, isImageInputUnsupportedError, isReasoningUnsupportedError, isStreamOptionsUnsupportedError, reasoningRejectionAdvice, stripImagesFromMessages, } from "./wire/capability-errors.js";
+export { buildReasoningPayload };
+export { readStreamLines, streamIdleBudgets } from "./wire/stream-framing.js";
+export { DEFAULT_STREAM_IDLE_TIMEOUT_MS, STREAM_STALL_MARKER, THINKING_STREAM_IDLE_TIMEOUT_MS, THINKING_STREAM_INITIAL_IDLE_TIMEOUT_MS, createSseFrameAssembler, };
+export { MAX_ERROR_BODY_CHARS, MAX_ERROR_BODY_IN_MESSAGE_CHARS, bodyAddsInformation, collapseWhitespace, } from "./wire/response-errors.js";
+export { readJson };
 export class ProviderError extends Error {
     status;
     body;
@@ -28,2007 +28,5 @@ export class ProviderError extends Error {
         this.name = "ProviderError";
     }
 }
-const USAGE_INPUT_KEYS = [
-    "prompt_tokens",
-    "promptTokens",
-    "input_tokens",
-    "inputTokens",
-];
-const USAGE_OUTPUT_KEYS = [
-    "completion_tokens",
-    "completionTokens",
-    "output_tokens",
-    "outputTokens",
-];
-function isFinalUsageFrame(parsed) {
-    if (Array.isArray(parsed.choices) && parsed.choices.length > 0)
-        return false;
-    const usage = parsed.usage;
-    if (!usage || typeof usage !== "object" || Array.isArray(usage))
-        return false;
-    const raw = usage;
-    const reported = (keys) => keys.some((key) => {
-        const value = raw[key];
-        return typeof value === "number" && Number.isFinite(value);
-    });
-    return reported(USAGE_INPUT_KEYS) && reported(USAGE_OUTPUT_KEYS);
-}
-function parseRetryAfterHeader(value) {
-    if (!value)
-        return undefined;
-    const seconds = Number.parseFloat(value);
-    if (Number.isFinite(seconds) && seconds >= 0)
-        return seconds;
-    // HTTP-date form: "Wed, 21 Oct 2015 07:28:00 GMT"
-    const date = Date.parse(value);
-    if (Number.isFinite(date)) {
-        const diff = (date - Date.now()) / 1000;
-        if (diff > 0)
-            return diff;
-    }
-    return undefined;
-}
-function parseRetryHintFromBody(text) {
-    const match = text.match(/try again in\s+([0-9.]+)\s*s/i);
-    if (match) {
-        const seconds = Number.parseFloat(match[1]);
-        if (Number.isFinite(seconds) && seconds >= 0)
-            return seconds;
-    }
-    return undefined;
-}
-function statusCodeHint(status) {
-    if (status === 401) {
-        return " — check that the API key is valid (run `clai providers` to inspect)";
-    }
-    if (status === 403) {
-        return " — the key was rejected (insufficient permissions, billing, or region restriction)";
-    }
-    if (status === 404) {
-        return " — endpoint or model not found (try `/model list` to see supported names)";
-    }
-    if (status === 422) {
-        return " — the provider rejected the request body (model name or parameter mismatch)";
-    }
-    if (status === 413) {
-        return " — request exceeded the provider input limit; retry with a compact prompt or pick another model";
-    }
-    if (status >= 500 && status < 600) {
-        return " — upstream provider error; try again or switch with `/provider`";
-    }
-    return "";
-}
-export function catalogEntryVision(entry) {
-    return parseCatalogFacts(entry)?.vision;
-}
-export function ingestModelCatalogEntries(provider, entries) {
-    const models = [];
-    const seen = new Set();
-    for (const entry of entries) {
-        const facts = parseCatalogFacts(entry);
-        if (!facts)
-            continue;
-        const id = facts.id;
-        if (seen.has(id))
-            continue;
-        seen.add(id);
-        const reasoning = facts.reasoning?.supported;
-        const reasoningEfforts = catalogEffortList(facts.reasoning?.supportedEfforts);
-        models.push({
-            id,
-            facts,
-            ...(facts.vision === undefined ? {} : { vision: facts.vision }),
-            ...(reasoning === undefined ? {} : { reasoning }),
-            ...(reasoningEfforts === undefined ? {} : { reasoningEfforts }),
-        });
-    }
-    if (models.length > 0)
-        registerModelCatalog(provider, models);
-    return models.map((model) => model.id).sort();
-}
-export function ingestOpenAiModelCatalog(provider, payload) {
-    return ingestModelCatalogEntries(provider, catalogEntriesFromPayload(payload));
-}
-export async function readJson(response, signal) {
-    const text = await readBodyCapped(response, MAX_JSON_RESPONSE_BYTES, signal);
-    if (!response.ok) {
-        let detail = "";
-        let extractedMessage = "";
-        try {
-            const body = JSON.parse(text);
-            const error = body.error;
-            let msg = "";
-            if (typeof error === "string") {
-                msg = error;
-            }
-            else if (error && typeof error === "object") {
-                const errObj = error;
-                msg = errObj.message ?? "";
-                if (!msg && (errObj.type || errObj.code)) {
-                    msg = errObj.type ?? errObj.code ?? "";
-                }
-            }
-            if (!msg) {
-                msg =
-                    body.message ??
-                        body.detail ??
-                        "";
-            }
-            if (msg) {
-                // Detect NVIDIA DEGRADED function errors and enrich the message.
-                if (/DEGRADED/i.test(msg)) {
-                    detail = ` — ${msg} (model is temporarily unavailable on this provider; try a different model with \`/model\`)`;
-                }
-                else {
-                    detail = ` — ${msg}`;
-                }
-            }
-            extractedMessage = msg;
-        }
-        catch {
-            // Non-JSON body — the raw text is surfaced via the full-response rule
-            // below, so nothing is lost here.
-        }
-        // Show the full error received from the request: the extracted
-        // `error.message` alone routinely hides the actionable part of a gateway
-        // error (upstream detail, codes, validation fields). Append the complete
-        // body whenever it carries anything beyond that extracted message.
-        const bodyText = text.slice(0, MAX_ERROR_BODY_CHARS);
-        if (bodyAddsInformation(bodyText, extractedMessage)) {
-            const shown = collapseWhitespace(bodyText);
-            const capped = shown.length > MAX_ERROR_BODY_IN_MESSAGE_CHARS
-                ? `${shown.slice(0, MAX_ERROR_BODY_IN_MESSAGE_CHARS)}…`
-                : shown;
-            detail = `${detail} — full response: ${capped}`;
-        }
-        const retryAfterSeconds = parseRetryAfterHeader(response.headers.get("retry-after")) ??
-            parseRetryHintFromBody(text);
-        const retryHint = retryAfterSeconds !== undefined
-            ? ` (retry after ${Math.ceil(retryAfterSeconds)}s)`
-            : "";
-        const codeHint = statusCodeHint(response.status);
-        throw new ProviderError(`Provider request failed with HTTP ${response.status}${retryHint}${detail}${codeHint}`, response.status, bodyText, retryAfterSeconds);
-    }
-    return JSON.parse(text);
-}
-/** Hard cap on a JSON response body so a misbehaving provider can't OOM us. */
-const MAX_JSON_RESPONSE_BYTES = 4 * 1024 * 1024;
-/** How much of a provider error body we retain on the ProviderError. */
-export const MAX_ERROR_BODY_CHARS = 8_000;
-/** How much of that body is embedded in the user-visible error message. */
-export const MAX_ERROR_BODY_IN_MESSAGE_CHARS = 2_000;
-export function collapseWhitespace(text) {
-    return text.replace(/\s+/g, " ").trim();
-}
-/**
- * True when the raw response body carries information beyond the message we
- * already extracted from it (extra JSON fields, non-JSON payloads, …). Pure
- * `{"error":{"message": …}}` envelopes are redundant and stay compact.
- */
-export function bodyAddsInformation(bodyText, extracted) {
-    const collapsed = collapseWhitespace(bodyText);
-    if (!collapsed)
-        return false;
-    if (!extracted)
-        return true;
-    const normalizedExtracted = collapseWhitespace(extracted);
-    // The user-facing text already carries the entire body verbatim.
-    if (normalizedExtracted.includes(collapsed))
-        return false;
-    if (!collapsed.includes(normalizedExtracted))
-        return true;
-    const rest = collapsed
-        .replace(normalizedExtracted, " ")
-        .replace(/\b(errors?|message|msg|detail|details|type|code|status)\b/gi, " ")
-        .replace(/[{}\[\]":,]/g, " ")
-        .trim();
-    return rest.length > 0;
-}
-async function readBodyCapped(response, maxBytes, signal) {
-    const reader = response.body?.getReader();
-    if (!reader) {
-        if (signal?.aborted) {
-            throw signal.reason ?? new Error("Response body read aborted");
-        }
-        const text = await response.text();
-        return text.length > maxBytes ? text.slice(0, maxBytes) : text;
-    }
-    const decoder = new TextDecoder("utf-8", { fatal: false });
-    let collected = "";
-    let bytesRead = 0;
-    const cancelOnAbort = () => {
-        void reader.cancel(signal?.reason).catch(() => undefined);
-    };
-    signal?.addEventListener("abort", cancelOnAbort, { once: true });
-    try {
-        while (bytesRead < maxBytes) {
-            const { done, value } = signal
-                ? await readWithAbort(reader, signal)
-                : await reader.read();
-            if (signal?.aborted) {
-                throw signal.reason ?? new Error("Response body read aborted");
-            }
-            if (done)
-                break;
-            if (!value)
-                continue;
-            const remaining = maxBytes - bytesRead;
-            if (value.byteLength > remaining) {
-                collected += decoder.decode(value.subarray(0, remaining), {
-                    stream: true,
-                });
-                bytesRead += remaining;
-                try {
-                    await reader.cancel();
-                }
-                catch {
-                    // ignore — we're abandoning the body deliberately
-                }
-                break;
-            }
-            collected += decoder.decode(value, { stream: true });
-            bytesRead += value.byteLength;
-        }
-        collected += decoder.decode();
-    }
-    finally {
-        signal?.removeEventListener("abort", cancelOnAbort);
-        try {
-            reader.releaseLock();
-        }
-        catch {
-            // already released
-        }
-    }
-    return collected;
-}
-/**
- * Mid-stream silence budget.
- *
- * This is deliberately generous because "no bytes" does **not** mean "dead
- * socket" on an OpenAI-compatible endpoint. Most self-hosted runtimes (vLLM /
- * SGLang and the tool-call parsers layered on top of them) buffer an entire
- * `tool_calls` delta before emitting it, so a model writing a large file goes
- * completely silent on the wire for as long as the generation takes. A 90s
- * budget aborted those healthy streams at `firstToken + 90s`, reported the
- * abort as a network failure, and burned three identical retries that each
- * re-generated the same prefix before one happened to finish inside the window.
- */
-export const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 240_000;
-export const THINKING_STREAM_IDLE_TIMEOUT_MS = 900_000;
-export const THINKING_STREAM_INITIAL_IDLE_TIMEOUT_MS = 900_000;
-export function streamIdleBudgets(reasoningEnabled) {
-    const idleTimeoutMs = reasoningEnabled
-        ? THINKING_STREAM_IDLE_TIMEOUT_MS
-        : DEFAULT_STREAM_IDLE_TIMEOUT_MS;
-    return {
-        idleTimeoutMs,
-        outputIdleTimeoutMs: Math.round(idleTimeoutMs * 1.5),
-    };
-}
-/**
- * Marker appended to the message of a stall that happened on a **live**
- * connection (bytes/keepalives were still arriving, or output had already
- * started and simply stopped). Such a stall is not a transport failure, so the
- * recovery layer must not classify it as `network` and retry the identical
- * request against the identical route.
- */
-export const STREAM_STALL_MARKER = "no model output";
-function readWithAbort(reader, signal) {
-    if (signal.aborted) {
-        return Promise.reject(signal.reason ?? new Error("Stream aborted"));
-    }
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        const cleanup = () => signal.removeEventListener("abort", abort);
-        const succeed = (value) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            resolve(value);
-        };
-        const fail = (error) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            reject(error);
-        };
-        const abort = () => {
-            fail(signal.reason ?? new Error("Stream aborted"));
-        };
-        signal.addEventListener("abort", abort, { once: true });
-        try {
-            void reader.read().then(succeed, fail);
-        }
-        catch (error) {
-            fail(error);
-        }
-    });
-}
-export async function* readStreamLines(response, options = {}) {
-    if (!response.body)
-        return;
-    const idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_STREAM_IDLE_TIMEOUT_MS;
-    const outputIdleTimeoutMs = options.outputIdleTimeoutMs ?? Math.round(idleTimeoutMs * 1.5);
-    const trackOutput = typeof options.outputProgress === "function";
-    const maxBytes = options.maxBytes ?? 16 * 1024 * 1024;
-    const idleController = new AbortController();
-    let idleTimer;
-    let outputTimer;
-    let idleFired = false;
-    let firedWatchdog = "transport";
-    let lastOutputProgress = trackOutput ? options.outputProgress() : 0;
-    const fireStall = (watchdog) => {
-        if (idleFired)
-            return;
-        idleFired = true;
-        firedWatchdog = watchdog;
-        idleController.abort();
-    };
-    const clearIdleTimers = () => {
-        if (idleTimer)
-            clearTimeout(idleTimer);
-        if (outputTimer)
-            clearTimeout(outputTimer);
-        idleTimer = undefined;
-        outputTimer = undefined;
-    };
-    const armOutputTimer = () => {
-        if (!trackOutput)
-            return;
-        if (outputTimer)
-            clearTimeout(outputTimer);
-        outputTimer = setTimeout(() => fireStall("output"), outputIdleTimeoutMs);
-    };
-    const resetIdleTimer = () => {
-        if (idleTimer)
-            clearTimeout(idleTimer);
-        idleTimer = setTimeout(() => fireStall("transport"), idleTimeoutMs);
-    };
-    const noteOutputProgress = () => {
-        if (!trackOutput)
-            return;
-        const current = options.outputProgress();
-        if (current <= lastOutputProgress)
-            return;
-        lastOutputProgress = current;
-        armOutputTimer();
-    };
-    const stallError = () => firedWatchdog === "output"
-        ? new ProviderError(`Provider stream stalled — ${STREAM_STALL_MARKER} for ${Math.round(outputIdleTimeoutMs / 1000)}s.`)
-        : new ProviderError(`Provider stream stalled — no data for ${Math.round(idleTimeoutMs / 1000)}s.`);
-    resetIdleTimer();
-    armOutputTimer();
-    const onCallerAbort = () => idleController.abort(options.signal?.reason);
-    options.signal?.addEventListener("abort", onCallerAbort, { once: true });
-    // A caller abort must surface as an abort error, not as a clean
-    // end-of-stream — otherwise the partial text is returned as a successful
-    // completion and enters history as the model's final answer.
-    const callerAbortError = () => options.signal?.reason ??
-        new DOMException("The operation was aborted.", "AbortError");
-    if (options.signal?.aborted) {
-        clearIdleTimers();
-        throw callerAbortError();
-    }
-    // If the idle watchdog already fired, bail before starting the loop.
-    if (idleController.signal.aborted) {
-        clearIdleTimers();
-        return;
-    }
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    let bytesRead = 0;
-    const cancelReaderOnAbort = () => {
-        reader.cancel().catch(() => undefined);
-    };
-    idleController.signal.addEventListener("abort", cancelReaderOnAbort, {
-        once: true,
-    });
-    try {
-        while (true) {
-            noteOutputProgress();
-            if (idleController.signal.aborted) {
-                if (idleFired)
-                    throw stallError();
-                throw callerAbortError();
-            }
-            let readResult;
-            try {
-                readResult = await readWithAbort(reader, idleController.signal);
-            }
-            catch (error) {
-                if (idleFired)
-                    throw stallError();
-                throw error;
-            }
-            const { done, value } = readResult;
-            if (done) {
-                if (idleFired)
-                    throw stallError();
-                break;
-            }
-            if (value) {
-                bytesRead += value.byteLength;
-                if (bytesRead > maxBytes) {
-                    throw new ProviderError(`Provider stream exceeded ${maxBytes.toLocaleString()} bytes — aborting.`);
-                }
-            }
-            resetIdleTimer();
-            options.onActivity?.();
-            buffer += decoder.decode(value, { stream: true });
-            const lines = buffer.split("\n");
-            buffer = lines.pop() ?? "";
-            for (const line of lines)
-                yield line;
-        }
-        if (buffer.length > 0)
-            yield buffer;
-    }
-    finally {
-        clearIdleTimers();
-        options.signal?.removeEventListener("abort", onCallerAbort);
-        idleController.signal.removeEventListener("abort", cancelReaderOnAbort);
-        void reader.cancel().catch(() => undefined);
-        try {
-            reader.releaseLock();
-        }
-        catch {
-            // already released
-        }
-    }
-}
-const DEFAULT_COMPATIBLE_REASONING_ARTIFACT_POLICY = {
-    scope: "all-history",
-    persistence: "tool-turn",
-};
-const PRESERVED_FINAL_TURN_ARTIFACT_POLICY = {
-    scope: "all-history",
-    persistence: "all-turns",
-};
-export function compatibleArtifactPolicyFor(preservation) {
-    return preservation === "required"
-        ? PRESERVED_FINAL_TURN_ARTIFACT_POLICY
-        : DEFAULT_COMPATIBLE_REASONING_ARTIFACT_POLICY;
-}
-function artifactRaw(value) {
-    if (typeof value === "string")
-        return value;
-    if (Array.isArray(value))
-        return value;
-    if (value && typeof value === "object") {
-        return value;
-    }
-    return undefined;
-}
-/**
- * Reads the reasoning text off an OpenAI-compatible `message`/`delta`.
- *
- * Most routes use `reasoning_content` (DeepSeek/vLLM style) or `reasoning`
- * (OpenRouter style). Merge Gateway normalizes every upstream vendor onto a
- * third field, `thinking` (+ `thinking_signature`), on both its
- * chat.completion messages and its chat.completion.chunk deltas — verified live
- * against api-gateway.merge.dev/v1/openai for qwen/qwen3.8-max,
- * zai/glm-5.3-flash and deepseek/deepseek-v4-flash-0731. Without this branch the
- * chain of thought arrives on the wire and is silently dropped, which looks
- * exactly like a model that never reasoned.
- *
- * Only strings are accepted: Anthropic-shaped `thinking` request/response
- * objects (`{type:"disabled"}`, content blocks) must not be treated as text.
- */
-function openAiReasoningText(channel) {
-    const primary = channel?.reasoning_content ?? channel?.reasoning;
-    if (typeof primary === "string" && primary)
-        return primary;
-    const thinking = channel?.thinking;
-    return typeof thinking === "string" && thinking ? thinking : undefined;
-}
-function compatibleReasoningArtifacts(input) {
-    const policy = input.policy ?? DEFAULT_COMPATIBLE_REASONING_ARTIFACT_POLICY;
-    const provenance = createReasoningArtifactProvenance({
-        provider: input.providerId,
-        model: input.model,
-        dialect: "openai-compatible",
-        endpoint: input.baseUrl,
-    });
-    const artifacts = [];
-    const primaryToolPosition = input.toolCalls.length > 0 ? 0 : undefined;
-    if (input.reasoning?.text) {
-        artifacts.push(createReasoningArtifact({
-            kind: "plaintext",
-            raw: input.reasoning.text,
-            displaySummary: input.reasoning.text,
-            provenance,
-            replay: policy,
-            position: {
-                sequence: input.reasoning.sequence,
-                placement: primaryToolPosition === undefined ? "assistant" : "before-tool-call",
-                ...(primaryToolPosition === undefined
-                    ? {}
-                    : { toolCallIndex: primaryToolPosition }),
-            },
-        }));
-    }
-    for (const detail of input.details ?? []) {
-        const visible = visibleReasoningDetailText(detail.raw);
-        artifacts.push(createReasoningArtifact({
-            kind: "structured-details",
-            raw: detail.raw,
-            ...(visible ? { displaySummary: visible } : {}),
-            provenance,
-            replay: policy,
-            position: {
-                sequence: detail.sequence,
-                placement: primaryToolPosition === undefined ? "assistant" : "before-tool-call",
-                ...(primaryToolPosition === undefined
-                    ? {}
-                    : { toolCallIndex: primaryToolPosition }),
-            },
-        }));
-    }
-    for (const signature of input.thoughtSignatures ?? []) {
-        const toolCallIndex = signature.toolCallIndex;
-        artifacts.push(createReasoningArtifact({
-            kind: "thought-signature",
-            raw: signature.raw,
-            provenance,
-            replay: toolCallIndex === undefined
-                ? { scope: "none", persistence: "never" }
-                : { scope: "tool-turn", persistence: "tool-turn" },
-            position: {
-                sequence: signature.sequence,
-                placement: toolCallIndex === undefined ? "assistant" : "on-tool-call",
-                ...(toolCallIndex === undefined ? {} : { toolCallIndex }),
-            },
-        }));
-    }
-    return artifacts.length ? artifacts : undefined;
-}
-/** Map shared OpenAI-compatible payload → CompletionResult (includes usage). */
-export function toCompletionResult(provider, model, payload) {
-    const usage = withReasoningObservation(payload.usage, Boolean(payload.reasoningBlock?.text.trim()) ||
-        reasoningArtifactsObserved(payload.reasoningArtifacts));
-    return {
-        text: payload.text,
-        provider,
-        model,
-        ...(payload.toolCalls?.length ? { toolCalls: payload.toolCalls } : {}),
-        ...(payload.finishReason ? { finishReason: payload.finishReason } : {}),
-        ...(usage ? { usage } : {}),
-        ...(payload.reasoningBlock ? { reasoningBlock: payload.reasoningBlock } : {}),
-        ...(payload.reasoningArtifacts
-            ? { reasoningArtifacts: payload.reasoningArtifacts }
-            : {}),
-    };
-}
-/**
- * Reassembles SSE `data:` frames.
- *
- * Per the SSE spec a single event's payload may be split across several `data:`
- * lines that the client must concatenate before parsing; each fragment was
- * previously parsed on its own, failed `JSON.parse`, and was dropped as a
- * malformed keepalive — losing content without a trace.
- *
- * A payload is released as soon as it is syntactically complete, so
- * single-line frames behave exactly as before. A blank line (frame terminator)
- * discards an incomplete remainder, and a runaway fragment is dropped rather
- * than corrupting later frames.
- */
-export function createSseFrameAssembler(options) {
-    const maxBufferedBytes = options?.maxBufferedBytes ?? 1_000_000;
-    let buffered = "";
-    const complete = (payload) => {
-        if (payload === "[DONE]")
-            return true;
-        try {
-            JSON.parse(payload);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    };
-    return {
-        pushLine(line) {
-            const trimmed = line.trim();
-            if (trimmed === "") {
-                // End of event: an incomplete remainder was malformed.
-                buffered = "";
-                return undefined;
-            }
-            if (!trimmed.startsWith("data:"))
-                return undefined;
-            const chunk = trimmed.slice(5).trim();
-            buffered = buffered ? `${buffered}\n${chunk}` : chunk;
-            if (complete(buffered)) {
-                const payload = buffered;
-                buffered = "";
-                return payload;
-            }
-            if (buffered.length > maxBufferedBytes)
-                buffered = "";
-            return undefined;
-        },
-    };
-}
-export function toOpenAiMessages(messages, supportsVision = true, replay) {
-    return toOpenAiToolMessages(messages, (message) => {
-        if (supportsVision &&
-            message.images &&
-            message.images.length > 0) {
-            const parts = [];
-            if (message.content)
-                parts.push({ type: "text", text: message.content });
-            for (const img of message.images) {
-                parts.push({
-                    type: "image_url",
-                    image_url: {
-                        url: `data:${img.mediaType};base64,${img.dataBase64}`,
-                        detail: "high",
-                    },
-                });
-            }
-            return parts;
-        }
-        return message.content;
-    }, replay);
-}
-export { classifyBynaraModel, classifyNvidiaModel, } from "./model-families.js";
-function supportsOpenRouterReasoning(model) {
-    return /:thinking|deepseek-r1|qwen3|kimi-k2|claude-(?:opus|sonnet|haiku)-4|gpt-5|(?:^|\/)o[134]|grok.*reasoner/i.test(model);
-}
-const MODAL_DEFAULT_EFFORTS = ["low", "high", "max"];
-const MODAL_EFFORT_PREFERENCE = {
-    minimal: ["minimal", "low", "medium", "high", "max"],
-    low: ["low", "minimal", "medium", "high", "max"],
-    medium: ["medium", "high", "low", "max"],
-    high: ["high", "max", "medium", "low"],
-    xhigh: ["xhigh", "max", "high", "medium", "low"],
-    max: ["max", "xhigh", "high", "medium", "low"],
-};
-function pickAdvertisedEffort(effort, advertised) {
-    const order = MODAL_EFFORT_PREFERENCE[effort] ?? MODAL_EFFORT_PREFERENCE.medium;
-    return (order.find((candidate) => advertised.includes(candidate)) ??
-        advertised[advertised.length - 1]);
-}
-export function buildReasoningPayload(reasoning, style, model, providerId, control) {
-    if (control) {
-        return {
-            ...emitReasoningControls({
-                profile: control.profile,
-                preference: reasoning,
-                willReplayReasoning: control.willReplayReasoning,
-            }),
-        };
-    }
-    if (style === "none")
-        return {};
-    const enabled = Boolean(reasoning?.enabled);
-    const effort = reasoning?.effort ?? "medium";
-    // Map expanded effort levels to the classic low/medium/high subset for
-    // providers that only understand the smaller set.
-    const clampEffort = (e) => {
-        if (e === "none" || e === "minimal" || e === "low")
-            return "low";
-        if (e === "max" || e === "xhigh" || e === "high")
-            return "high";
-        return "medium";
-    };
-    switch (style) {
-        case "meta": {
-            const metaEffort = (e) => {
-                if (e === "none" || e === "minimal")
-                    return "minimal";
-                if (e === "max" || e === "xhigh")
-                    return "xhigh";
-                return e;
-            };
-            if (!enabled)
-                return { reasoning_effort: "minimal" };
-            return { reasoning_effort: metaEffort(effort) };
-        }
-        case "openai": {
-            if (!enabled) {
-                return effort === "none" ? { reasoning_effort: "none" } : {};
-            }
-            // `reasoning_effort` is the Chat Completions knob. The nested
-            // `reasoning` object belongs to the Responses API; strict gateways reject
-            // unknown top-level fields with a hard 400.
-            return { reasoning_effort: clampEffort(effort) };
-        }
-        case "bynara": {
-            const kind = classifyBynaraModel(model ?? "");
-            const noThinking = !enabled || effort === "none" || effort === "minimal";
-            switch (kind) {
-                case "kimi":
-                    if (noThinking)
-                        return { chat_template_kwargs: { thinking: false } };
-                    if (effort === "high" || effort === "xhigh" || effort === "max") {
-                        return {
-                            chat_template_kwargs: { thinking: true },
-                            reasoning_effort: "high",
-                        };
-                    }
-                    if (effort === "low") {
-                        return {
-                            chat_template_kwargs: { thinking: true },
-                            reasoning_effort: "low",
-                        };
-                    }
-                    return { chat_template_kwargs: { thinking: true } };
-                case "deepseek":
-                case "agnes":
-                    if (noThinking)
-                        return { reasoning_effort: "none" };
-                    return { reasoning_effort: clampEffort(effort) };
-                case "stepfun":
-                    if (noThinking)
-                        return {};
-                    return { reasoning_effort: clampEffort(effort) };
-                case "none":
-                    return {};
-            }
-            return {};
-        }
-        case "agentrouter": {
-            // AgentRouter proxies three families, each with a *different* reasoning
-            // contract (verified live against agentrouter.org/v1, 2026-07). We send
-            // only the standard top-level knob each one honours — no redundant
-            // `reasoning` object (none of the routed models read it).
-            const m = (model ?? "").toLowerCase();
-            const clamped = clampEffort(effort);
-            // OpenAI gpt-5.x / o-series: top-level `reasoning_effort`, and it uniquely
-            // supports "minimal". These models can't be fully disabled, so "off"
-            // degrades to the cheapest "minimal" rather than the medium default.
-            if (/(?:^|\/)gpt-5|(?:^|\/)o[134](?:\b|-)/.test(m)) {
-                if (!enabled)
-                    return { reasoning_effort: "minimal" };
-                const gptEffort = effort === "none"
-                    ? "minimal"
-                    : effort === "xhigh" || effort === "max"
-                        ? "high"
-                        : effort; // minimal | low | medium | high
-                return { reasoning_effort: gptEffort };
-            }
-            // Zhipu GLM thinks by DEFAULT; `reasoning_effort` only modulates depth and
-            // cannot turn it off. The one knob that actually disables it on this
-            // gateway is `thinking.type=disabled` — so "off" must send that.
-            if (/glm/.test(m)) {
-                if (!enabled)
-                    return { thinking: { type: "disabled" } };
-                return { reasoning_effort: clamped };
-            }
-            // Anthropic Claude: `reasoning_effort` enables extended thinking (the
-            // gateway maps it to a thinking budget). Thinking is OFF by default, so
-            // "off" simply omits the knob. `buildChatBody` floors max_tokens above the
-            // budget so enabling it never trips the gateway's budget precondition.
-            if (/claude/.test(m)) {
-                if (!enabled)
-                    return {};
-                return { reasoning_effort: clamped };
-            }
-            // Unknown model routed by AgentRouter → plain OpenAI-compatible behavior.
-            if (!enabled)
-                return {};
-            return { reasoning_effort: clamped };
-        }
-        case "openrouter":
-            if (!enabled)
-                return {};
-            if (!supportsOpenRouterReasoning(model ?? ""))
-                return {};
-            return { reasoning: { enabled: true, effort: clampEffort(effort) } };
-        case "modal": {
-            const advertised = providerId !== undefined && model
-                ? modelReasoningEfforts(providerId, model)
-                : undefined;
-            if (!advertised &&
-                providerId !== undefined &&
-                model &&
-                !modelSupportsThinking(providerId, model)) {
-                return {};
-            }
-            if (!enabled || effort === "none")
-                return { reasoning_effort: "none" };
-            return {
-                reasoning_effort: pickAdvertisedEffort(effort, advertised ?? MODAL_DEFAULT_EFFORTS),
-            };
-        }
-        case "stepfun":
-            // Step 3.5/3.7 Flash enables a <think> block by default on compatible
-            // hosts. Omitting an OpenAI reasoning field does not turn that default
-            // off, so compaction would still buy hidden reasoning tokens. vLLM's
-            // StepFun template honours this explicit per-request switch.
-            return { chat_template_kwargs: { enable_thinking: enabled } };
-        case "nvidia": {
-            const kind = classifyNvidiaModel(model ?? "");
-            switch (kind) {
-                case "kimi-thinking":
-                    return {
-                        chat_template_kwargs: {
-                            thinking: enabled,
-                        },
-                    };
-                case "deepseek-v4":
-                    // NVIDIA's DeepSeek V4 API accepts none/high/max. Map expanded
-                    // effort levels: none/minimal/low → none; medium/high/xhigh → high.
-                    return {
-                        chat_template_kwargs: {
-                            thinking: enabled,
-                            reasoning_effort: enabled
-                                ? clampEffort(effort) === "low"
-                                    ? "none"
-                                    : "high"
-                                : "none",
-                        },
-                    };
-                case "thinking":
-                    return {
-                        chat_template_kwargs: {
-                            thinking: enabled,
-                        },
-                    };
-                case "nemotron-3": {
-                    // Nemotron-3 supports both `enable_thinking` and an optional
-                    // `reasoning_budget` cap. Map expanded effort to budget values.
-                    if (!enabled) {
-                        return {
-                            chat_template_kwargs: { enable_thinking: false },
-                        };
-                    }
-                    const clamped = clampEffort(effort);
-                    const budget = clamped === "low" ? 4_096 : clamped === "high" ? 16_384 : 8_192;
-                    return {
-                        reasoning_budget: budget,
-                        chat_template_kwargs: { enable_thinking: true },
-                    };
-                }
-                case "glm-thinking":
-                    // GLM-5 / 4.5 expects `clear_thinking:false` alongside
-                    // `enable_thinking:true` per the NIM docs example.
-                    return {
-                        chat_template_kwargs: enabled
-                            ? { enable_thinking: true, clear_thinking: false }
-                            : { enable_thinking: false },
-                    };
-                case "enable-thinking":
-                    // Gemma 3/4 only documents `enable_thinking`; do not add
-                    // `clear_thinking` here since the chat template doesn't accept it.
-                    return {
-                        chat_template_kwargs: { enable_thinking: enabled },
-                    };
-                case "effort-only":
-                    // NVIDIA GPT-OSS accepts only low/medium/high, so a retry cannot
-                    // fully disable it. Keep it at the lowest supported effort instead
-                    // of omitting the field and reverting to NVIDIA's medium default.
-                    if (!enabled && /gpt-oss/i.test(model ?? "")) {
-                        return { reasoning_effort: "low" };
-                    }
-                    if (!enabled && /qwen3|mistral-/i.test(model ?? "")) {
-                        return { reasoning_effort: "none" };
-                    }
-                    return { reasoning_effort: clampEffort(effort) };
-                case "none":
-                default:
-                    return {};
-            }
-        }
-        default:
-            return {};
-    }
-}
-/**
- * Detects provider errors that mean the model rejected one of our
- * reasoning/thinking knobs (chat_template_kwargs, enable_thinking,
- * clear_thinking, reasoning_effort, reasoning_budget, thinking). NVIDIA NIM and
- * other OpenAI-compatible gateways return a 400/422 for chat templates that do
- * not accept these fields. When this matches, the router strips the reasoning
- * payload and retries so an unsupported option never fails the whole request.
- */
-export function isReasoningUnsupportedError(error) {
-    if (isMissingReasoningContentError(error))
-        return false;
-    const status = error && typeof error === "object" && "status" in error
-        ? Number(error.status)
-        : undefined;
-    const body = error && typeof error === "object" && "body" in error
-        ? String(error.body ?? "")
-        : "";
-    const message = error instanceof Error ? error.message : String(error);
-    const hay = `${message}\n${body}`.toLowerCase();
-    const mentionsReasoningKnob = 
-    // `\breasoning\b` catches bodies like "Unrecognized request argument
-    // supplied: reasoning" so a bare reasoning-field rejection also degrades.
-    /chat_template_kwargs|enable_thinking|clear_thinking|reasoning_effort|reasoning_budget|reasoning_content|\breasoning\b|\bthinking\b/.test(hay);
-    if (!mentionsReasoningKnob)
-        return false;
-    // A 4xx that names a reasoning field is a parameter rejection — strip it.
-    if (status === 400 || status === 422)
-        return true;
-    // Any status: explicit "not supported / unknown / invalid parameter" wording.
-    return /not support|unsupported|unknown|unrecognized|not a valid|not allowed|unexpected keyword|does not accept|extra fields not permitted|additional propert|invalid[_ ]?(?:request[_ ]?)?(?:argument|parameter|field)/.test(hay);
-}
-const EFFORT_VOCABULARY = [
-    "none",
-    "minimal",
-    "low",
-    "medium",
-    "high",
-    "xhigh",
-    "max",
-];
-export function reasoningRejectionAdvice(error) {
-    const body = error && typeof error === "object" && "body" in error
-        ? String(error.body ?? "")
-        : "";
-    const message = error instanceof Error ? error.message : String(error);
-    const hay = `${message}\n${body}`.toLowerCase();
-    const mandatory = /always\s+(?:engages?\s+in|uses?|performs?)\s+(?:thinking|reasoning)|(?:thinking|reasoning)\s+cannot\s+be\s+disabled|cannot\s+be\s+disabled|can(?:no|')t\s+be\s+(?:disabled|turned\s+off)/.test(hay);
-    const clause = /(?:please\s+use|must\s+be\s+one\s+of|must\s+be|one\s+of|supported\s+values?(?:\s+are)?|valid\s+values?(?:\s+are)?|allowed\s+values?(?:\s+are)?|use)\s*:?\s*([^.;\n}"]{0,120})/.exec(hay);
-    const acceptedEfforts = clause
-        ? EFFORT_VOCABULARY.filter((effort) => new RegExp(`\\b${effort}\\b`).test(clause[1] ?? ""))
-        : [];
-    if (!mandatory && acceptedEfforts.length === 0)
-        return undefined;
-    return { mandatory, acceptedEfforts };
-}
-export function isStreamOptionsUnsupportedError(error) {
-    const status = error && typeof error === "object" && "status" in error
-        ? Number(error.status)
-        : undefined;
-    if (status !== 400 && status !== 422)
-        return false;
-    const body = error && typeof error === "object" && "body" in error
-        ? String(error.body ?? "")
-        : "";
-    const message = error instanceof Error ? error.message : String(error);
-    const hay = `${message}\n${body}`.toLowerCase();
-    return (/stream_options|stream options/.test(hay) &&
-        /not support|unsupported|unknown|unrecognized|not a valid|not allowed|unexpected keyword|does not accept|extra fields not permitted|additional propert|invalid[_ ]?(?:request[_ ]?)?(?:argument|parameter|field)/.test(hay));
-}
-export function isImageInputUnsupportedError(error) {
-    const status = error && typeof error === "object" && "status" in error
-        ? Number(error.status)
-        : undefined;
-    const body = error && typeof error === "object" && "body" in error
-        ? String(error.body ?? "")
-        : "";
-    const message = error instanceof Error ? error.message : String(error);
-    const hay = `${message}\n${body}`.toLowerCase();
-    const mentionsImageInput = /image_url|image url|inlinedata|inline_data|\bimages?\b|multimodal|\bvision\b|media_type|image content|content\[\d+\]|content\.\d+|parts\[\d+\]/.test(hay);
-    if (!mentionsImageInput)
-        return false;
-    if (status !== undefined && status !== 400 && status !== 415 && status !== 422) {
-        return false;
-    }
-    return /not support|unsupported|does not accept|cannot process|invalid[_ ]?(?:request[_ ]?)?(?:argument|parameter|field|type|value)?|unknown|unrecognized|not a valid|not allowed|only text|text[- ]only|expected a string|must be a string|additional propert/.test(hay);
-}
-export function stripImagesFromMessages(messages) {
-    return messages.map((message) => {
-        if (!message.images?.length)
-            return message;
-        const { images: _images, ...rest } = message;
-        return rest;
-    });
-}
-export function imageCapableMessages(provider, model, messages) {
-    if (modelAcceptsImages(provider, model))
-        return messages;
-    return stripImagesFromMessages(messages);
-}
-/**
- * legacy Chat Completions sampling knobs: `max_tokens` must be
- * `max_completion_tokens`, and `temperature`/`top_p` must be omitted or left
- * at their default (non-default values return HTTP 400 "Unsupported
- * parameter"). Matched by model name (not provider) since OpenAI-compatible
- * gateways that pass these model IDs through to the real OpenAI API hit the
- * same restriction.
- * https://help.openai.com/en/articles/5072518 (Chat Completions section).
- */
-export function isOpenAiReasoningModel(model) {
-    const m = model.toLowerCase();
-    return (/(?:^|\/)gpt-5(?:\.|-|$)/.test(m) ||
-        /(?:^|\/)o[134](?:\.|-|$)/.test(m) ||
-        /muse-spark/.test(m));
-}
-const DEFAULT_REASONING_OUTPUT_FLOOR = 16_384;
-function outputBudgetWithReasoning(requested, options) {
-    const floor = options.control?.profile.reasoning.minOutputTokens ??
-        DEFAULT_REASONING_OUTPUT_FLOOR;
-    const ceiling = modelMaxOutputTokens(options.providerId, options.model, options.outputTokenLimit);
-    const floored = Math.max(requested, floor);
-    return ceiling !== undefined ? Math.min(floored, ceiling) : floored;
-}
-function emitChatCompletionsBody(options) {
-    // Skip reasoning knobs entirely for models observed to reject them this
-    // session (see isReasoningUnsupportedError). This is how thinking degrades
-    // gracefully: the request still runs, just without the unsupported option.
-    const capabilityDeniesThinking = options.control === undefined &&
-        options.providerId !== undefined &&
-        Boolean(options.reasoning?.enabled) &&
-        !modelSupportsThinking(options.providerId, options.model);
-    const legacyControlDenied = options.control === undefined &&
-        options.providerId !== undefined &&
-        isReasoningUnsupported(options.providerId, options.model);
-    const reasoning = legacyControlDenied ||
-        capabilityDeniesThinking ||
-        options.control?.suppressed === true
-        ? {}
-        : buildReasoningPayload(options.reasoning, options.reasoningStyle ?? "none", options.model, options.providerId, options.control);
-    const reasoningOn = Boolean(options.reasoning?.enabled);
-    // Kimchi exposes this model as `minimax-m3`; NVIDIA uses the longer
-    // `minimaxai/minimax-m3` ID. Both need the larger default output budget.
-    const isMinimaxM3 = /minimax-m3/i.test(options.model);
-    const defaultMaxTokens = isMinimaxM3 ? 8_192 : reasoningOn ? 8_192 : 4_096;
-    // One declarative sampling policy; explicit caller value wins.
-    const sampling = options.resolvedSampling ?? {
-        ...resolveSampling({
-            model: options.model,
-            reasoningEnabled: reasoningOn,
-            requestedTemperature: options.temperature,
-        }),
-    };
-    const reasoningModel = isOpenAiReasoningModel(options.model);
-    const emitTemperature = sampling.temperature !== undefined &&
-        (options.resolvedSampling !== undefined || !reasoningModel);
-    // Claude extended thinking via AgentRouter maps reasoning_effort to an
-    // Anthropic `thinking.budget_tokens`, and the gateway (Bedrock) rejects the
-    // request with HTTP 400 unless `max_tokens > budget_tokens`. Some upstream
-    // nodes enforce this intermittently, so whenever Claude reasoning is enabled
-    // we guarantee a ceiling that clears the largest effort budget (32000 was
-    // verified live to succeed while staying within Opus's output cap). This is a
-    // ceiling, not a forced length — Claude still stops at its natural stop.
-    const claudeThinking = reasoningOn &&
-        options.reasoningStyle === "agentrouter" &&
-        /claude/i.test(options.model);
-    const requestedMaxTokens = options.maxTokens ?? defaultMaxTokens;
-    const claudeFloored = claudeThinking
-        ? Math.max(requestedMaxTokens, 32_000)
-        : requestedMaxTokens;
-    const effectiveMaxTokens = reasoningOn
-        ? outputBudgetWithReasoning(claudeFloored, options)
-        : claudeFloored;
-    const affinityKey = options.providerId === "openrouter" || options.providerId === "fireworks"
-        ? cacheAffinityKey(options.providerId, options.model, options.messages)
-        : undefined;
-    const body = {
-        model: options.model,
-        messages: toOpenAiMessages(singleLeadingSystemMessages(options.messages), options.supportsVision, options.replayTarget
-            ? {
-                target: options.replayTarget,
-                observe: options.reasoningArtifactReplayObserver,
-                ...(options.forceReasoningReplay ? { forceScope: true } : {}),
-            }
-            : undefined),
-        stream: options.stream,
-        ...(options.providerId === "openrouter" && affinityKey
-            ? { session_id: affinityKey }
-            : {}),
-        ...(options.providerId === "fireworks"
-            ? {
-                perf_metrics_in_response: true,
-                ...(affinityKey
-                    ? {
-                        prompt_cache_key: affinityKey,
-                        prompt_cache_isolation_key: affinityKey,
-                    }
-                    : {}),
-            }
-            : {}),
-        ...(reasoningModel
-            ? { max_completion_tokens: effectiveMaxTokens }
-            : { max_tokens: effectiveMaxTokens }),
-        // gpt-5.x / o1 / o3 / o4 only accept the default temperature (1) and
-        // reject any explicit value — omit the field entirely rather than send
-        // our 0.2 default and get a 400.
-        ...(emitTemperature ? { temperature: sampling.temperature } : {}),
-        ...reasoning,
-        ...openAiToolBodyFields({
-            tools: options.tools,
-            toolChoice: options.toolChoice,
-            parallelToolCalls: options.parallelToolCalls,
-        }),
-    };
-    if (emitTemperature && sampling.topP !== undefined) {
-        body.top_p = sampling.topP;
-    }
-    // OpenAI + many OpenAI-compatible gateways attach usage on the final SSE
-    // chunk when this is set (non-stream responses always include usage).
-    if (options.stream && options.includeStreamUsage !== false) {
-        body.stream_options = { include_usage: true };
-    }
-    return JSON.stringify(body);
-}
-export function buildChatBody(options) {
-    return emitChatCompletionsBody(options);
-}
-/**
- * Serializes a compiled canonical plan onto the Chat Completions wire. Wire
- * dialect knobs that the plan intentionally does not model (gateway reasoning
- * style, stream-usage flag, replay observer) stay serializer-side extras.
- */
-export function chatCompletionsBodyFromPlan(plan, extras = {}) {
-    return emitChatCompletionsBody({
-        model: plan.route.model,
-        providerId: plan.route.provider,
-        messages: [...plan.timeline.messages],
-        maxTokens: plan.controls.requestedMaxTokens,
-        temperature: plan.controls.temperature,
-        stream: plan.controls.stream,
-        includeStreamUsage: extras.includeStreamUsage,
-        reasoning: plan.controls.reasoning,
-        reasoningStyle: extras.reasoningStyle,
-        supportsVision: plan.images.visionAccepted,
-        control: {
-            profile: {
-                reasoning: plan.policy.reasoning,
-                capabilities: { acceptedParameters: plan.policy.acceptedParameters },
-            },
-            willReplayReasoning: plan.replay.decisions.some((entry) => entry.decision.action === "replayed"),
-            suppressed: plan.controls.controlSuppression !== undefined,
-        },
-        resolvedSampling: {
-            temperature: plan.controls.temperature,
-            topP: plan.controls.topP,
-        },
-        ...(plan.policy.limits.outputTokens !== undefined
-            ? { outputTokenLimit: plan.policy.limits.outputTokens }
-            : {}),
-        tools: plan.tools.definitions.length
-            ? [...plan.tools.definitions]
-            : undefined,
-        toolChoice: plan.tools.choice,
-        parallelToolCalls: plan.tools.parallelToolCalls,
-        replayTarget: plan.replay.target,
-        reasoningArtifactReplayObserver: extras.reasoningArtifactReplayObserver,
-        ...(extras.forceReasoningReplay ? { forceReasoningReplay: true } : {}),
-    });
-}
-function sentReasoningEffort(requestBody) {
-    try {
-        const body = JSON.parse(requestBody);
-        if (typeof body.reasoning_effort === "string" && body.reasoning_effort) {
-            return body.reasoning_effort;
-        }
-        const nested = body.reasoning;
-        if (nested && typeof nested === "object" && !Array.isArray(nested)) {
-            const effort = nested.effort;
-            if (typeof effort === "string" && effort)
-                return effort;
-        }
-    }
-    catch {
-        return undefined;
-    }
-    return undefined;
-}
-function privateReasoningNote(provider, requestBody, reasoningTokens) {
-    const effort = sentReasoningEffort(requestBody);
-    const effortText = effort ? ` at ${effort} effort` : "";
-    return `Reasoning is private on ${provider}: the model reasoned${effortText} and used ${reasoningTokens.toLocaleString("en-US")} reasoning tokens, but the API returns no reasoning text to display.`;
-}
-export async function openAiCompatibleComplete(options) {
-    const plan = compileRequestPlan({
-        provider: options.providerId,
-        model: options.model,
-        messages: options.messages,
-        stream: false,
-        endpoint: options.baseUrl,
-        reasoning: options.reasoning,
-        tools: options.tools,
-        toolChoice: options.toolChoice,
-        parallelToolCalls: options.parallelToolCalls,
-        temperature: options.temperature,
-        maxTokens: options.maxTokens,
-    });
-    const requestBody = chatCompletionsBodyFromPlan(plan, {
-        reasoningStyle: options.reasoningStyle,
-        reasoningArtifactReplayObserver: options.reasoningArtifactReplayObserver,
-        ...(options.forceReasoningReplay ? { forceReasoningReplay: true } : {}),
-    });
-    let response;
-    try {
-        response = await generationFetch(`${options.baseUrl}/chat/completions`, {
-            method: "POST",
-            signal: options.signal ?? null,
-            headers: {
-                "content-type": "application/json",
-                accept: "application/json",
-                ...(options.apiKey
-                    ? { authorization: `Bearer ${options.apiKey}` }
-                    : {}),
-                ...options.headers,
-            },
-            body: requestBody,
-            verbose: process.env.CLAI_VERBOSE === "true",
-        });
-    }
-    catch (error) {
-        if (error instanceof Error && error.name === "AbortError")
-            throw error;
-        if (isOperationPolicyError(error))
-            throw error;
-        const msg = error instanceof Error ? error.message : String(error);
-        throw new ProviderError(`${options.provider} request could not be sent (${msg}). Check connectivity to ${options.baseUrl}.`);
-    }
-    let data;
-    try {
-        data = await readJson(response);
-    }
-    catch (error) {
-        if (error instanceof ProviderError) {
-            throw new ProviderError(`${options.provider} (model=${options.model}): ${error.message}`, error.status, error.body, error.retryAfterSeconds);
-        }
-        throw error;
-    }
-    const choice = data.choices?.[0];
-    const message = choice?.message;
-    const toolCalls = parseOpenAiMessageToolCalls(message?.tool_calls);
-    const text = message?.content ?? "";
-    if (!text && toolCalls.length === 0) {
-        throw new ProviderError(`${options.provider} returned no completion text (model=${options.model}). The response was empty — try /effort off, raise max_tokens, or pick another model with /model.`);
-    }
-    // If the API returns reasoning separately, prepend it inside <think>
-    // tags so the existing thinking parser can pick it up uniformly.
-    // Fireworks exposes cache metrics in headers for complete calls and can also
-    // include them in perf_metrics. Other compatible routes use their standard
-    // usage object plus any explicitly configured aliases.
-    const usage = options.providerId === "fireworks"
-        ? parseFireworksUsage(data.usage, data.perf_metrics, response.headers)
-        : parseOpenAiUsage(data.usage, options.usageAliases);
-    const reasoning = openAiReasoningText(message);
-    const detailsRaw = artifactRaw(message?.reasoning_details);
-    const thoughtSignature = message?.extra_content?.google?.thought_signature;
-    const reasoningArtifacts = compatibleReasoningArtifacts({
-        providerId: options.providerId,
-        model: options.model,
-        baseUrl: options.baseUrl,
-        toolCalls,
-        policy: options.reasoningArtifactPolicy ??
-            compatibleArtifactPolicyFor(plan.policy.reasoning.finalTurnPreservation),
-        ...(typeof reasoning === "string" && reasoning
-            ? { reasoning: { text: reasoning, sequence: 0 } }
-            : {}),
-        ...(detailsRaw ? { details: [{ raw: detailsRaw, sequence: 1 }] } : {}),
-        ...(thoughtSignature
-            ? {
-                thoughtSignatures: [
-                    {
-                        raw: thoughtSignature,
-                        sequence: 2,
-                        ...(toolCalls.length ? { toolCallIndex: 0 } : {}),
-                    },
-                ],
-            }
-            : {}),
-    });
-    if (typeof reasoning === "string" && reasoning.trim()) {
-        learnModelEmitsReasoning(options.providerId, options.model);
-    }
-    const displayReasoning = typeof reasoning === "string" && reasoning
-        ? reasoning
-        : (visibleReasoningDetailText(detailsRaw) ?? "");
-    return {
-        text,
-        ...(toolCalls.length ? { toolCalls } : {}),
-        ...(choice?.finish_reason
-            ? { finishReason: choice.finish_reason }
-            : toolCalls.length
-                ? { finishReason: "tool_calls" }
-                : {}),
-        ...(usage ? { usage } : {}),
-        ...(displayReasoning ? { reasoningBlock: { text: displayReasoning } } : {}),
-        ...(reasoningArtifacts ? { reasoningArtifacts } : {}),
-    };
-}
-export async function openAiCompatibleStream(options) {
-    // Combine the caller's abort signal with an idle watchdog so a stuck
-    // connection can't wedge the REPL forever. Thinking models get a much
-    // longer first-byte budget and a longer mid-stream silence budget —
-    // the old 30s default aborted healthy Bynara/OpenRouter streams that
-    // were still "thinking" without tokens.
-    const reasoningOn = Boolean(options.reasoning?.enabled);
-    const idleTimeoutMs = options.idleTimeoutMs ??
-        (reasoningOn
-            ? THINKING_STREAM_IDLE_TIMEOUT_MS
-            : DEFAULT_STREAM_IDLE_TIMEOUT_MS);
-    const initialIdleTimeoutMs = options.initialIdleTimeoutMs ??
-        (reasoningOn
-            ? THINKING_STREAM_INITIAL_IDLE_TIMEOUT_MS
-            : idleTimeoutMs);
-    // "No bytes" and "no output" are different failures and need separate
-    // budgets. The transport watchdog is re-armed by every read, so an SSE
-    // keepalive comment, a `delta:{}` heartbeat, a role-only opening delta, or a
-    // multi-line frame still being assembled all count as proof that the
-    // connection is healthy. The output watchdog is re-armed only by real model
-    // progress, so a stream that keepalives forever without ever producing
-    // anything still fails instead of hanging.
-    const outputIdleTimeoutMs = options.outputIdleTimeoutMs ??
-        Math.round(Math.max(idleTimeoutMs, initialIdleTimeoutMs) * 1.5);
-    const idleController = new AbortController();
-    let transportTimer;
-    let outputTimer;
-    let idleFired = false;
-    let firedWatchdog;
-    /** Budget of whichever watchdog fired, for the error message. */
-    let firedBudgetMs = initialIdleTimeoutMs;
-    /**
-     * Any bytes at all read off the socket, whether or not the frame carried
-     * model output. Separates "the route never answered" (retry the request) from
-     * "the model was working and went quiet" (a retry replays all of that work).
-     */
-    let sawTransportActivity = false;
-    /** Model-visible progress: content, reasoning, tool-call delta, or usage. */
-    let sawStreamProgress = false;
-    const fireStall = (watchdog, budgetMs) => {
-        // The two timers can expire in the same event-loop turn. Preserve the first
-        // cause so a transport outage is never relabeled by the output watchdog.
-        if (idleFired)
-            return;
-        idleFired = true;
-        firedWatchdog = watchdog;
-        firedBudgetMs = budgetMs;
-        idleController.abort();
-    };
-    const armTransportTimer = (budgetMs) => {
-        if (transportTimer)
-            clearTimeout(transportTimer);
-        transportTimer = setTimeout(() => fireStall("transport", budgetMs), budgetMs);
-    };
-    /** Bytes arrived — the connection is alive; re-arm the mid-stream budget. */
-    const noteTransportActivity = () => {
-        sawTransportActivity = true;
-        armTransportTimer(idleTimeoutMs);
-    };
-    const resetIdleTimer = () => {
-        sawStreamProgress = true;
-        noteTransportActivity();
-        if (outputTimer)
-            clearTimeout(outputTimer);
-        outputTimer = setTimeout(() => fireStall("output", outputIdleTimeoutMs), outputIdleTimeoutMs);
-    };
-    armTransportTimer(initialIdleTimeoutMs);
-    outputTimer = setTimeout(() => fireStall("output", outputIdleTimeoutMs), outputIdleTimeoutMs);
-    const clearIdleTimers = () => {
-        if (transportTimer)
-            clearTimeout(transportTimer);
-        if (outputTimer)
-            clearTimeout(outputTimer);
-        transportTimer = undefined;
-        outputTimer = undefined;
-    };
-    const onCallerAbort = () => idleController.abort(options.signal?.reason);
-    options.signal?.addEventListener("abort", onCallerAbort, { once: true });
-    const plan = compileRequestPlan({
-        provider: options.providerId,
-        model: options.model,
-        messages: options.messages,
-        stream: true,
-        endpoint: options.baseUrl,
-        reasoning: options.reasoning,
-        tools: options.tools,
-        toolChoice: options.toolChoice,
-        parallelToolCalls: options.parallelToolCalls,
-        temperature: options.temperature,
-        maxTokens: options.maxTokens,
-    });
-    const requestBody = chatCompletionsBodyFromPlan(plan, {
-        reasoningStyle: options.reasoningStyle,
-        includeStreamUsage: options.includeStreamUsage,
-        reasoningArtifactReplayObserver: options.reasoningArtifactReplayObserver,
-        ...(options.forceReasoningReplay ? { forceReasoningReplay: true } : {}),
-    });
-    let response;
-    try {
-        response = await generationFetch(`${options.baseUrl}/chat/completions`, {
-            method: "POST",
-            signal: idleController.signal,
-            headers: {
-                "content-type": "application/json",
-                accept: "text/event-stream",
-                ...(options.apiKey
-                    ? { authorization: `Bearer ${options.apiKey}` }
-                    : {}),
-                ...options.headers,
-            },
-            body: requestBody,
-            verbose: process.env.CLAI_VERBOSE === "true",
-        });
-    }
-    catch (error) {
-        clearIdleTimers();
-        options.signal?.removeEventListener("abort", onCallerAbort);
-        if (idleFired) {
-            throw new ProviderError(`${options.provider} request timed out before any response (${Math.round(firedBudgetMs / 1000)}s)`);
-        }
-        throw error;
-    }
-    if (!response.ok) {
-        clearIdleTimers();
-        options.signal?.removeEventListener("abort", onCallerAbort);
-        try {
-            await readJson(response);
-        }
-        catch (error) {
-            if (error instanceof ProviderError) {
-                throw new ProviderError(`${options.provider} (model=${options.model}): ${error.message}`, error.status, error.body, error.retryAfterSeconds);
-            }
-            throw error;
-        }
-    }
-    if (!response.body) {
-        clearIdleTimers();
-        options.signal?.removeEventListener("abort", onCallerAbort);
-        throw new ProviderError(`${options.provider} returned no stream body`);
-    }
-    const contentType = response.headers.get("content-type") ?? "";
-    if (response.status === 202 || /\bapplication\/json\b/i.test(contentType)) {
-        try {
-            const data = await readJson(response, idleController.signal);
-            if (response.status === 202) {
-                const requestId = data.requestId ?? data.id;
-                throw new ProviderError(`${options.provider} returned a pending async response${requestId ? ` (${requestId})` : ""}; streaming did not start.`, response.status, JSON.stringify(data).slice(0, 1_000));
-            }
-            const choice = data.choices?.[0];
-            const message = choice?.message;
-            const toolCalls = parseOpenAiMessageToolCalls(message?.tool_calls);
-            const text = message?.content ?? "";
-            const jsonUsage = options.providerId === "fireworks"
-                ? parseFireworksUsage(data.usage, data.perf_metrics, response.headers)
-                : parseOpenAiUsage(data.usage, options.usageAliases);
-            const reasoning = openAiReasoningText(message);
-            const detailsRaw = artifactRaw(message?.reasoning_details);
-            const thoughtSignature = message?.extra_content?.google?.thought_signature;
-            const reasoningArtifacts = compatibleReasoningArtifacts({
-                providerId: options.providerId,
-                model: options.model,
-                baseUrl: options.baseUrl,
-                toolCalls,
-                policy: options.reasoningArtifactPolicy ??
-                    compatibleArtifactPolicyFor(plan.policy.reasoning.finalTurnPreservation),
-                ...(typeof reasoning === "string" && reasoning
-                    ? { reasoning: { text: reasoning, sequence: 0 } }
-                    : {}),
-                ...(detailsRaw ? { details: [{ raw: detailsRaw, sequence: 1 }] } : {}),
-                ...(thoughtSignature
-                    ? {
-                        thoughtSignatures: [
-                            {
-                                raw: thoughtSignature,
-                                sequence: 2,
-                                ...(toolCalls.length ? { toolCallIndex: 0 } : {}),
-                            },
-                        ],
-                    }
-                    : {}),
-            });
-            if (text.trim() ||
-                toolCalls.length > 0 ||
-                (typeof reasoning === "string" && reasoning.trim())) {
-                emitStreamReasoningArtifacts(options.onStreamEvent, reasoningArtifacts);
-                if (text)
-                    options.onToken(text);
-                return {
-                    text,
-                    ...(toolCalls.length ? { toolCalls } : {}),
-                    ...(choice?.finish_reason
-                        ? { finishReason: choice.finish_reason }
-                        : toolCalls.length
-                            ? { finishReason: "tool_calls" }
-                            : {}),
-                    ...(jsonUsage ? { usage: jsonUsage } : {}),
-                    ...(typeof reasoning === "string" && reasoning
-                        ? { reasoningBlock: { text: reasoning } }
-                        : visibleReasoningDetailText(detailsRaw)
-                            ? {
-                                reasoningBlock: {
-                                    text: visibleReasoningDetailText(detailsRaw),
-                                },
-                            }
-                            : {}),
-                    ...(reasoningArtifacts ? { reasoningArtifacts } : {}),
-                };
-            }
-            throw new ProviderError(`${options.provider} returned JSON instead of an SSE stream, but no completion text was present.`, response.status, JSON.stringify(data).slice(0, 1_000));
-        }
-        catch (error) {
-            if (idleFired) {
-                const seconds = Math.round(firedBudgetMs / 1000);
-                if (firedWatchdog === "transport" || !sawTransportActivity) {
-                    if (!sawTransportActivity) {
-                        throw new ProviderError(`${options.provider} request timed out before any response (${seconds}s) — no data arrived on the connection.`);
-                    }
-                    throw new ProviderError(`${options.provider} stream transport timeout (${seconds}s) — no data arrived on the connection after it had started.`);
-                }
-                throw new ProviderError(`${options.provider} stream stalled — ${STREAM_STALL_MARKER} for ${seconds}s`);
-            }
-            throw error;
-        }
-        finally {
-            clearIdleTimers();
-            options.signal?.removeEventListener("abort", onCallerAbort);
-        }
-    }
-    const decoder = new TextDecoder();
-    const reader = response.body.getReader();
-    let buffer = "";
-    let full = "";
-    let visible = "";
-    let reasoningSeen = "";
-    let contentWireSeen = "";
-    let reasoningWireSeen = "";
-    let finishReason;
-    let terminalSignal;
-    const terminalPolicy = options.streamTerminal ??
-        (plan.policy.terminal.proofs.length > 0
-            ? plan.policy.terminal
-            : CHAT_COMPLETIONS_STREAM_TERMINAL);
-    const emittedByteCounts = () => {
-        let toolArgumentBytes = 0;
-        for (const state of toolCallState.values()) {
-            toolArgumentBytes += state.arguments.length;
-        }
-        return {
-            answerBytes: visible.length,
-            reasoningBytes: reasoningSeen.length,
-            toolArgumentBytes,
-        };
-    };
-    let streamUsage = options.providerId === "fireworks"
-        ? parseFireworksUsage(undefined, undefined, response.headers)
-        : undefined;
-    const toolCallState = new Map();
-    let reasoningArtifactSequence;
-    let nextArtifactSequence = 0;
-    let lastToolCallIndex;
-    const structuredDetails = [];
-    const thoughtSignatures = [];
-    const pendingThoughtSignatures = [];
-    const finalReasoningArtifacts = (toolCalls) => {
-        if (pendingThoughtSignatures.length) {
-            const toolCallIndex = toolCalls.length ? 0 : undefined;
-            for (const capture of pendingThoughtSignatures.splice(0)) {
-                thoughtSignatures.push(toolCallIndex === undefined
-                    ? capture
-                    : { ...capture, toolCallIndex });
-            }
-        }
-        return compatibleReasoningArtifacts({
-            providerId: options.providerId,
-            model: options.model,
-            baseUrl: options.baseUrl,
-            toolCalls,
-            policy: options.reasoningArtifactPolicy ??
-                compatibleArtifactPolicyFor(plan.policy.reasoning.finalTurnPreservation),
-            ...(reasoningSeen
-                ? {
-                    reasoning: {
-                        text: reasoningSeen,
-                        sequence: reasoningArtifactSequence ?? 0,
-                    },
-                }
-                : {}),
-            ...(structuredDetails.length ? { details: structuredDetails } : {}),
-            ...(thoughtSignatures.length ? { thoughtSignatures } : {}),
-        });
-    };
-    const displayReasoningText = () => {
-        if (reasoningSeen)
-            return reasoningSeen;
-        return structuredDetails
-            .map((detail) => visibleReasoningDetailText(detail.raw) ?? "")
-            .join("");
-    };
-    const normalizeChannelDelta = (token, seen, snapshotThreshold = 64) => {
-        const extendsSnapshot = token.length > seen.length && token.startsWith(seen);
-        const repeatsEstablishedSnapshot = seen.length >= 64 && token.length === seen.length && token === seen;
-        if (seen.length >= snapshotThreshold &&
-            (extendsSnapshot || repeatsEstablishedSnapshot)) {
-            return { delta: token.slice(seen.length), seen: token };
-        }
-        return { delta: token, seen: seen + token };
-    };
-    const emitPrivateReasoningNote = (hasToolCalls) => {
-        if (reasoningSeen.trim())
-            return;
-        if (!visible.trim() && !hasToolCalls)
-            return;
-        const tokens = streamUsage?.reasoningTokens ?? 0;
-        if (tokens <= 0)
-            return;
-        const note = privateReasoningNote(options.provider, requestBody, tokens);
-        emitStreamReasoningDelta(options.onStreamEvent, note);
-    };
-    /**
-     * Reasoning-echo suppression.
-     *
-     * Some gateways/models stream the chain of thought on `reasoning_content` and
-     * then replay it verbatim at the start of `content` before the real answer
-     * (observed with MiniMax M3 and GLM). Untagged, that replay is
-     * indistinguishable from an answer, so it was rendered as the response — the
-     * user saw the model's reasoning as its reply even with thinking off.
-     *
-     * While the leading `content` still matches reasoning we already received, it
-     * is kept inside the `<think>` region: never a visible answer, still visible
-     * under Ctrl+T, and stripped from history. Only the first
-     * ECHO_CONFIRM_CHARS are held back before deciding, so a normal answer is
-     * emitted with no perceptible delay.
-     */
-    const ECHO_CONFIRM_CHARS = 64;
-    let echoState = "idle";
-    let echoBuffer = "";
-    let echoPos = 0;
-    const emitVisible = (text) => {
-        if (!text)
-            return;
-        visible += text;
-        full += text;
-        options.onToken(text);
-    };
-    /**
-     * Route replayed text back into the reasoning region. Deliberately does NOT
-     * extend `reasoningSeen`: that string is the comparison baseline, and growing
-     * it with the replay would let the echo match itself past the real reasoning.
-     */
-    const emitReasoningEcho = (text) => {
-        if (!text)
-            return;
-        emitStreamReasoningDelta(options.onStreamEvent, text);
-    };
-    /** Release a still-undecided hold-back as the answer (stream ended early). */
-    const flushEchoBuffer = () => {
-        if (!echoBuffer)
-            return;
-        const held = echoBuffer;
-        echoBuffer = "";
-        echoState = "done";
-        emitVisible(held);
-    };
-    const handleContentToken = (token) => {
-        if (echoState === "done") {
-            emitVisible(token);
-            return;
-        }
-        if (echoState === "idle") {
-            // A replay is only plausible once a meaningful amount of reasoning came
-            // through the separate channel.
-            if (reasoningSeen.length < ECHO_CONFIRM_CHARS) {
-                echoState = "done";
-                emitVisible(token);
-                return;
-            }
-            echoState = "buffering";
-        }
-        if (echoState === "buffering") {
-            echoBuffer += token;
-            if (reasoningSeen.startsWith(echoBuffer)) {
-                if (echoBuffer.length >= ECHO_CONFIRM_CHARS) {
-                    const confirmed = echoBuffer;
-                    echoBuffer = "";
-                    echoPos = confirmed.length;
-                    echoState = "echoing";
-                    emitReasoningEcho(confirmed);
-                }
-                return;
-            }
-            flushEchoBuffer();
-            return;
-        }
-        // Confirmed replay: consume the matching run, then hand over the answer.
-        let matched = 0;
-        while (matched < token.length &&
-            reasoningSeen[echoPos + matched] === token[matched]) {
-            matched += 1;
-        }
-        if (matched > 0) {
-            emitReasoningEcho(token.slice(0, matched));
-            echoPos += matched;
-        }
-        if (matched < token.length) {
-            echoState = "done";
-            emitVisible(token.slice(matched));
-        }
-    };
-    const cleanup = () => {
-        clearIdleTimers();
-        options.signal?.removeEventListener("abort", onCallerAbort);
-        idleController.signal.removeEventListener("abort", cancelReaderOnAbort);
-    };
-    const cancelReaderOnAbort = () => {
-        reader.cancel().catch(() => undefined);
-    };
-    idleController.signal.addEventListener("abort", cancelReaderOnAbort, {
-        once: true,
-    });
-    const sseFrames = createSseFrameAssembler();
-    try {
-        while (true) {
-            options.signal?.throwIfAborted();
-            if (idleController.signal.aborted) {
-                throw new Error("Stream aborted");
-            }
-            const { done, value } = await readWithAbort(reader, idleController.signal);
-            options.signal?.throwIfAborted();
-            if (idleController.signal.aborted) {
-                throw new Error("Stream aborted");
-            }
-            if (done)
-                break;
-            // Bytes off the wire re-arm the watchdog before anything is parsed.
-            // Keepalives and empty deltas are proof of a live connection, so they
-            // must not be allowed to age out a stream that is merely quiet.
-            if (value && value.byteLength > 0)
-                noteTransportActivity();
-            buffer += decoder.decode(value, { stream: true });
-            const lines = buffer.split("\n");
-            buffer = lines.pop() ?? "";
-            for (const line of lines) {
-                const payload = sseFrames.pushLine(line);
-                if (payload === undefined)
-                    continue;
-                if (payload === "[DONE]") {
-                    terminalSignal = "done-sentinel";
-                    requireTerminalProof({
-                        provider: options.provider,
-                        policy: terminalPolicy,
-                        signal: terminalSignal,
-                        ...emittedByteCounts(),
-                    });
-                    flushEchoBuffer();
-                    cleanup();
-                    const toolCalls = finalizeOpenAiToolCalls(toolCallState);
-                    emitPrivateReasoningNote(toolCalls.length > 0);
-                    const reasoningArtifacts = finalReasoningArtifacts(toolCalls);
-                    emitStreamReasoningArtifacts(options.onStreamEvent, reasoningArtifacts);
-                    if (!visible.trim() && toolCalls.length === 0) {
-                        // Thinking models (Kimi/Moonshot via Mantle, etc.) often emit only
-                        // reasoning, sometimes with tool sentinels inside <think>. Returning
-                        // the full text lets the agent runner recover tool calls from
-                        // thinkContent instead of failing the whole stream as an error.
-                        if (reasoningSeen.trim()) {
-                            return {
-                                text: full,
-                                ...(finishReason ? { finishReason } : { finishReason: "stop" }),
-                                ...(streamUsage ? { usage: streamUsage } : {}),
-                                ...(displayReasoningText() ? { reasoningBlock: { text: displayReasoningText() } } : {}),
-                                ...(reasoningArtifacts ? { reasoningArtifacts } : {}),
-                            };
-                        }
-                        throw new ProviderError(`${options.provider} completed without a visible answer.`);
-                    }
-                    return {
-                        text: full,
-                        ...(toolCalls.length ? { toolCalls } : {}),
-                        ...(finishReason
-                            ? { finishReason }
-                            : toolCalls.length
-                                ? { finishReason: "tool_calls" }
-                                : {}),
-                        ...(streamUsage ? { usage: streamUsage } : {}),
-                        ...(displayReasoningText() ? { reasoningBlock: { text: displayReasoningText() } } : {}),
-                        ...(reasoningArtifacts ? { reasoningArtifacts } : {}),
-                    };
-                }
-                let parsed;
-                try {
-                    // Only JSON.parse is allowed to fail silently here. The
-                    // delta handlers below (tool-arg size guard, UI callbacks) used to be
-                    // inside this try and had their errors swallowed as "keepalives".
-                    parsed = JSON.parse(payload);
-                }
-                catch {
-                    // Malformed keepalive / comment line.
-                    continue;
-                }
-                // Gateways report mid-stream failures as an error frame; that
-                // used to be dropped, so an upstream overload looked like a complete
-                // (but truncated) answer.
-                if (parsed.error) {
-                    const detail = typeof parsed.error === "string"
-                        ? parsed.error
-                        : (parsed.error.message ?? parsed.error.type ?? "unknown error");
-                    throw new ProviderError(`${options.provider} stream error: ${detail}`, inBandBadRequestStatus(parsed.error), payload.slice(0, 500));
-                }
-                {
-                    const chunkUsage = options.providerId === "fireworks"
-                        ? parseFireworksUsage(parsed.usage, parsed.perf_metrics, response.headers)
-                        : parseOpenAiUsage(parsed.usage, options.usageAliases);
-                    if (chunkUsage)
-                        streamUsage = chunkUsage;
-                    const finalUsageFrame = isFinalUsageFrame(parsed);
-                    const choice = parsed.choices?.[0];
-                    const delta = choice?.delta;
-                    const reasoningToken = openAiReasoningText(delta);
-                    const token = delta?.content;
-                    const detailRaw = artifactRaw(delta?.reasoning_details);
-                    const thoughtSignature = delta?.extra_content?.google?.thought_signature;
-                    const artifactSequence = nextArtifactSequence++;
-                    const toolProgress = delta?.tool_calls?.some((toolCall) => Boolean(toolCall.id ||
-                        toolCall.function?.name ||
-                        toolCall.function?.arguments));
-                    if (choice?.finish_reason ||
-                        chunkUsage ||
-                        reasoningToken ||
-                        token ||
-                        detailRaw ||
-                        thoughtSignature ||
-                        toolProgress) {
-                        resetIdleTimer();
-                    }
-                    if (terminalSignal === "usage-chunk" &&
-                        (token || reasoningToken || toolProgress)) {
-                        terminalSignal = undefined;
-                    }
-                    if (choice?.finish_reason) {
-                        finishReason = choice.finish_reason;
-                        terminalSignal = "finish-reason";
-                    }
-                    else if (finalUsageFrame && terminalSignal === undefined) {
-                        terminalSignal = "usage-chunk";
-                    }
-                    if (reasoningToken) {
-                        const normalized = normalizeChannelDelta(reasoningToken, reasoningWireSeen, options.providerId === "bynara" ? 1 : 64);
-                        reasoningWireSeen = normalized.seen;
-                        if (normalized.delta) {
-                            reasoningArtifactSequence ??= artifactSequence;
-                            if (!reasoningSeen) {
-                                learnModelEmitsReasoning(options.providerId, options.model);
-                            }
-                            reasoningSeen += normalized.delta;
-                            emitStreamReasoningDelta(options.onStreamEvent, normalized.delta);
-                        }
-                    }
-                    if (detailRaw) {
-                        structuredDetails.push({ raw: detailRaw, sequence: artifactSequence });
-                    }
-                    if (token) {
-                        const normalized = normalizeChannelDelta(token, contentWireSeen);
-                        contentWireSeen = normalized.seen;
-                        if (normalized.delta)
-                            handleContentToken(normalized.delta);
-                    }
-                    const deltaToolCallIndices = [];
-                    if (delta?.tool_calls?.length) {
-                        for (const tc of delta.tool_calls) {
-                            const accInfo = accumulateOpenAiToolCallDelta(toolCallState, tc);
-                            deltaToolCallIndices.push(accInfo.index);
-                            lastToolCallIndex = accInfo.index;
-                            if (options.onToolCallDelta) {
-                                const wire = accInfo.name;
-                                const canonical = wire
-                                    ? (fromWireName(wire) ?? wire)
-                                    : undefined;
-                                const largeArgTick = !accInfo.nameBecameKnown &&
-                                    accInfo.argumentsBytes > 0 &&
-                                    accInfo.argumentsBytes % 4096 <
-                                        (typeof tc.function?.arguments === "string"
-                                            ? tc.function.arguments.length
-                                            : 0);
-                                if (accInfo.nameBecameKnown || largeArgTick) {
-                                    options.onToolCallDelta({
-                                        index: accInfo.index,
-                                        ...(accInfo.id !== undefined ? { id: accInfo.id } : {}),
-                                        ...(canonical !== undefined ? { name: canonical } : {}),
-                                        argumentsBytes: accInfo.argumentsBytes,
-                                    });
-                                }
-                            }
-                        }
-                    }
-                    const signatureToolCallIndex = deltaToolCallIndices[0] ?? lastToolCallIndex;
-                    if (thoughtSignature) {
-                        const capture = {
-                            raw: thoughtSignature,
-                            sequence: artifactSequence,
-                            ...(signatureToolCallIndex === undefined
-                                ? {}
-                                : { toolCallIndex: signatureToolCallIndex }),
-                        };
-                        if (signatureToolCallIndex === undefined) {
-                            pendingThoughtSignatures.push(capture);
-                        }
-                        else {
-                            thoughtSignatures.push(capture);
-                        }
-                    }
-                    if (deltaToolCallIndices.length && pendingThoughtSignatures.length) {
-                        const toolCallIndex = deltaToolCallIndices[0];
-                        for (const capture of pendingThoughtSignatures.splice(0)) {
-                            thoughtSignatures.push({ ...capture, toolCallIndex });
-                        }
-                    }
-                }
-            }
-        }
-        flushEchoBuffer();
-        cleanup();
-        requireTerminalProof({
-            provider: options.provider,
-            policy: terminalPolicy,
-            signal: terminalSignal,
-            ...emittedByteCounts(),
-        });
-        const toolCalls = finalizeOpenAiToolCalls(toolCallState);
-        emitPrivateReasoningNote(toolCalls.length > 0);
-        const reasoningArtifacts = finalReasoningArtifacts(toolCalls);
-        emitStreamReasoningArtifacts(options.onStreamEvent, reasoningArtifacts);
-        if (!visible.trim() && toolCalls.length === 0) {
-            // See [DONE] branch — hand thinking-only streams to the runner so it can
-            // salvage sentinel tool blocks (or nudge) instead of hard-failing.
-            if (reasoningSeen.trim()) {
-                return {
-                    text: full,
-                    ...(finishReason ? { finishReason } : { finishReason: "stop" }),
-                    ...(streamUsage ? { usage: streamUsage } : {}),
-                    ...(displayReasoningText() ? { reasoningBlock: { text: displayReasoningText() } } : {}),
-                    ...(reasoningArtifacts ? { reasoningArtifacts } : {}),
-                };
-            }
-            throw new ProviderError(`${options.provider} completed without a visible answer.`);
-        }
-        return {
-            text: full,
-            ...(toolCalls.length ? { toolCalls } : {}),
-            ...(finishReason
-                ? { finishReason }
-                : toolCalls.length
-                    ? { finishReason: "tool_calls" }
-                    : {}),
-            ...(streamUsage ? { usage: streamUsage } : {}),
-            ...(displayReasoningText() ? { reasoningBlock: { text: displayReasoningText() } } : {}),
-            ...(reasoningArtifacts ? { reasoningArtifacts } : {}),
-        };
-    }
-    catch (error) {
-        if (idleFired) {
-            const seconds = Math.round(firedBudgetMs / 1000);
-            // Preserve the actual watchdog source. Any byte proves the route admitted
-            // the request, but a later byte-silence timeout is still a transport
-            // failure; only the output watchdog denotes a live keepalive-only/model
-            // stall and receives STREAM_STALL_MARKER.
-            if (firedWatchdog === "transport" || !sawTransportActivity) {
-                if (!sawTransportActivity) {
-                    // Keep the established wording: both the router's transparent-retry
-                    // check and classifyStreamFailure key off this phrase to treat a route
-                    // that never answered as a retriable transport failure.
-                    throw new ProviderError(`${options.provider} request timed out before any response (${seconds}s) — no data arrived on the connection.`);
-                }
-                throw new ProviderError(`${options.provider} stream transport timeout (${seconds}s) — no data arrived on the connection after it had started.`);
-            }
-            throw new ProviderError(`${options.provider} stream stalled — ${STREAM_STALL_MARKER} for ${seconds}s` +
-                (sawStreamProgress
-                    ? " after it had already started producing output. " +
-                        "The connection stayed open, so the model was most likely buffering one very large tool call. " +
-                        "Split large writes into smaller sequential calls, or try a smaller model / disable thinking with /effort off."
-                    : " — the connection stayed open but the model never produced anything. " +
-                        "Try another model, or disable thinking with /effort off."));
-        }
-        throw error;
-    }
-    finally {
-        // The success paths used to return without releasing the body, so
-        // the socket stayed locked until GC — dozens of leaked connections per
-        // long agent turn.
-        cleanup();
-        void reader.cancel().catch(() => undefined);
-        try {
-            reader.releaseLock();
-        }
-        catch {
-            // already released
-        }
-    }
-}
-export async function openAiCompatiblePing(baseUrl, apiKey, headers) {
-    const response = await fetch(`${baseUrl}/models`, {
-        headers: {
-            ...(apiKey ? { authorization: `Bearer ${apiKey}` } : {}),
-            ...headers,
-        },
-        verbose: process.env.CLAI_VERBOSE === "true",
-    });
-    await readJson(response);
-}
+export { classifyBynaraModel, classifyNvidiaModel } from "./model-families.js";
 //# sourceMappingURL=http.js.map