@andorra-labs/code 0.0.0-stage → 0.1.5

package/dist/src/providers.js

@@ -0,0 +1,1230 @@
+import { setTimeout as delay } from 'node:timers/promises';
+import { COMPLETION_TOOL } from './completion.js';
+import { createCodexAdapter } from './codex-provider.js';
+import { createClaudeAdapter } from './claude-provider.js';
+import { createOpenCodeAdapter } from './opencode-provider.js';
+import { providerAuthHeaders } from './anthropic-credentials.js';
+import { generateEngineResponse, isEngineContextOverflow } from './provider-engine.js';
+export const REASONING_EFFORTS = ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+/**
+ * Inactivity bound for inference, and wall-clock bound for other HTTP requests,
+ * in milliseconds, when a provider does not configure its own.
+ *
+ * Its job is to end a request that will never be answered — a wedged server, a black-holed
+ * connection — never to cap a slow model. One inference call is bounded by the tokens it must
+ * decode, and the request asks for thousands of them, so a bound short enough to fire on a
+ * healthy self-hosted endpoint converts completed work into `infrastructure_error`. Inference
+ * refreshes this timer whenever response bytes arrive; active decoding may run longer. A
+ * provider that needs longer silent intervals raises it, and
+ * `0` removes it entirely for a caller that is bounded some other way.
+ */
+export const DEFAULT_REQUEST_TIMEOUT_MS = 10 * 60_000;
+/**
+ * The largest per-request bound a provider may configure: one day.
+ *
+ * Node's timers accept only a signed 32-bit millisecond delay. A larger value is reduced to a
+ * 1 ms timer with a `TimeoutOverflowWarning` — and above `2 ** 32 - 1` `AbortSignal.timeout`
+ * throws — so a bound meant to be generous would instead fail every request almost immediately.
+ * Configuration and the exported adapter constructor enforce this same ceiling: a consumer that
+ * builds an adapter directly must not be able to arm that timer.
+ */
+export const MAX_REQUEST_TIMEOUT_MS = 86_400_000;
+/**
+ * The single validation of a configured request bound, shared by the configuration loader and
+ * {@link createAdapter} so the two can never disagree about what a provider will honour.
+ *
+ * It rejects the whole override, not just an out-of-range value: a Codex provider applies its own
+ * fixed bound, so accepting `requestTimeoutMs` here would silently ignore what the caller asked
+ * for.
+ * @param provider - the provider whose bound is being checked.
+ */
+export function assertRequestTimeout(provider) {
+    const value = provider.requestTimeoutMs;
+    if (value === undefined)
+        return;
+    if (provider.type === 'codex')
+        throw new Error('Codex providers bound each request at ten minutes; requestTimeoutMs is not supported');
+    if (provider.type === 'claude')
+        throw new Error('Claude providers bound each request at ten minutes; requestTimeoutMs is not supported');
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0 || value > MAX_REQUEST_TIMEOUT_MS) {
+        throw new Error(`Provider requestTimeoutMs must be 0 (no timeout) or an integer of milliseconds up to ${MAX_REQUEST_TIMEOUT_MS}`);
+    }
+}
+/**
+ * The single validation of a configured inference inactivity bound, shared by the configuration
+ * loader and {@link createAdapter} so the two can never disagree about what a provider honours.
+ *
+ * `streamIdleTimeoutMs` separates the bound on a silent inference exchange from
+ * `requestTimeoutMs`: a provider that removed the request bound to tolerate a slow prefill can
+ * still end a stream that stopped delivering bytes. Like the request bound it accepts `0` to
+ * remove the bound; Codex owns its fixed bound, so the override is rejected rather than ignored.
+ * @param provider - the provider whose inactivity bound is being checked.
+ */
+export function assertStreamIdleTimeout(provider) {
+    const value = provider.streamIdleTimeoutMs;
+    if (value === undefined)
+        return;
+    if (provider.type === 'codex')
+        throw new Error('Codex providers bound each request at ten minutes; streamIdleTimeoutMs is not supported');
+    if (provider.type === 'claude')
+        throw new Error('Claude providers bound each request at ten minutes; streamIdleTimeoutMs is not supported');
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0 || value > MAX_REQUEST_TIMEOUT_MS) {
+        throw new Error(`Provider streamIdleTimeoutMs must be 0 (no bound) or an integer of milliseconds up to ${MAX_REQUEST_TIMEOUT_MS}`);
+    }
+}
+/**
+ * Bound for model listing, which is a discovery GET rather than inference.
+ *
+ * A listing is never worth the inference bound: an endpoint that accepts the connection and never
+ * answers must not leave the model screen loading for minutes, and a provider that removed its
+ * inference bound with `requestTimeoutMs: 0` must still not make discovery unbounded. A caller
+ * may pass a shorter bound of its own; this is a ceiling, not a floor.
+ *
+ * Callers pass their *cancellation* signal only. A deadline the caller arms here would fire before
+ * this one, and a caller's signal aborting is reported as a cancellation — so wrapping this call
+ * in `AbortSignal.timeout` would report a stalled endpoint as something the user did.
+ */
+export const MODEL_LISTING_TIMEOUT_MS = 30_000;
+/** How a deadline reads in the phrase that reports it hitting: "15 seconds", "1 second", "40 milliseconds". */
+export function deadlinePhrase(ms) {
+    if (ms % 1000 !== 0)
+        return `${ms} milliseconds`;
+    const seconds = ms / 1000;
+    return `${seconds} second${seconds === 1 ? '' : 's'}`;
+}
+/**
+ * The name a person reads for a provider in a list or picker.
+ *
+ * An explicit {@link ProviderConfig.name} wins everywhere: the id is an immutable identity, so the
+ * editable name is the only way a provider can be renamed, and preferring it here is what makes a
+ * rename reach records that still carry the old identity. Codex entries are otherwise the one case
+ * where the id is not the name: several ChatGPT accounts can be configured at once, and the label
+ * carries the account's email localpart so the rows are told apart. A configuration holding a
+ * single Codex provider keeps the plain `codex` name, and a provider whose sign-in never reported
+ * an email falls back to its id. The selection value stays the provider id everywhere; only the
+ * text changes.
+ */
+export function providerLabel(provider, providers) {
+    if (provider.name?.trim())
+        return provider.name.trim();
+    if (provider.type !== 'codex')
+        return provider.id;
+    if (providers.filter(item => item.type === 'codex').length <= 1)
+        return 'codex';
+    const local = provider.codexEmail?.split('@')[0] || provider.id;
+    return `codex - ${local.length > 32 ? `${local.slice(0, 31)}…` : local}`;
+}
+/** The longest account-slot key validation accepts; the key names a directory under the config home. */
+export const MAX_CODEX_ACCOUNT_KEY_LENGTH = 100;
+/** The longest display name validation accepts; the name is text a list row or picker renders. */
+export const MAX_PROVIDER_NAME_LENGTH = 64;
+/**
+ * An account-slot key no configured provider binds yet, based on the entry's identifier.
+ *
+ * The key becomes a directory name, so it is compared case-insensitively, exactly as validation
+ * compares it: `work-fast` may already be bound to the key `work`, and a new provider whose own id
+ * is `work` must not take that account over. The first free `id`, `id-2`, `id-3`… is returned.
+ *
+ * A provider id may be longer than a slot key validation accepts, and appending a collision suffix
+ * to a key already at the limit would overrun it, so the base is trimmed to leave the suffix room:
+ * allocating an account must never produce a key the configuration it is written into rejects.
+ */
+export function freeCodexAccountSlot(base, providers) {
+    const taken = new Set(providers.flatMap(provider => provider.codexAccount === undefined ? [] : [provider.codexAccount.toLowerCase()]));
+    const key = (suffix) => `${base.slice(0, MAX_CODEX_ACCOUNT_KEY_LENGTH - suffix.length)}${suffix}`;
+    let slot = key('');
+    for (let suffix = 2; taken.has(slot.toLowerCase()); suffix++)
+        slot = key(`-${suffix}`);
+    return slot;
+}
+/**
+ * A free slot key for an entry a draft is adding, reserving the saved configuration as well.
+ *
+ * A draft may remove a slot-bearing entry and add a new Codex provider in the same save. The
+ * removed home outlives the draft until its retirement completes, so a key computed against the
+ * draft alone can be handed to the newcomer: that entry would sign in as the removed account, and
+ * the retirement would find the key bound and skip it. Reserving both sets closes that path for
+ * every draft editor, since the engine only allocates for writes that arrive without a key.
+ */
+export function freeDraftCodexAccountSlot(base, draft, saved) {
+    return freeCodexAccountSlot(base, [...draft, ...saved]);
+}
+/**
+ * Give every Codex entry that is a later account binding its own slot key.
+ *
+ * An entry binds an account when it is Codex now but was not Codex before — a new entry, or another
+ * type converted. A configuration that held no Codex provider keeps its inherited sign-in on the
+ * first Codex entry this write leaves; every other new binding gets a free key. An entry that was
+ * already Codex keeps whatever binding (or lack of one) it had: a save is not a migration. Allocation
+ * happens here rather than in each client so no two clients can disagree about which keys are taken,
+ * and a bulk write orders the entries exactly as adding them one at a time would.
+ */
+export function allocateCodexAccountSlots(stored, next) {
+    const storedHadCodex = stored.some(item => item.type === 'codex');
+    const firstCodexId = next.find(item => item.type === 'codex')?.id;
+    const result = [];
+    for (const [index, provider] of next.entries()) {
+        if (provider.type !== 'codex' || provider.codexAccount !== undefined) {
+            result.push(provider);
+            continue;
+        }
+        const previous = stored.find(item => item.id === provider.id);
+        if (previous?.type === 'codex' || (!storedHadCodex && provider.id === firstCodexId)) {
+            result.push(provider);
+            continue;
+        }
+        // The key is chosen against everything this write leaves configured: entries already placed and
+        // entries still to come, and `freeCodexAccountSlot` reads every binding among them. Bindings the
+        // write removes are reserved too, because their homes outlive the write until retirement
+        // completes: reusing a removed key here would hand the new entry an account it never signed in
+        // to, and the retirement would then find the key bound and skip it.
+        result.push({ ...provider, codexAccount: freeCodexAccountSlot(provider.id, [...result, ...next.slice(index + 1), ...stored]) });
+    }
+    return result;
+}
+/** The models a provider is configured to offer: the saved list, or the active model alone. */
+export function providerModels(provider) {
+    if (provider.models !== undefined)
+        return provider.models.filter(model => model.trim());
+    return provider.model.trim() ? [provider.model] : [];
+}
+/**
+ * The context window saved for one model, if the provider has one.
+ *
+ * `Object.hasOwn` rather than a plain lookup: a model id is user input, so `constructor` or
+ * `toString` must read as "no saved window" instead of an inherited member. Values are required to
+ * be positive safe integers because a hand-edited configuration can reach this before validation
+ * runs in an adapter built directly.
+ */
+export function configuredContextWindow(provider, model) {
+    const id = model ?? provider.model;
+    if (!provider.modelContextWindows || !Object.hasOwn(provider.modelContextWindows, id))
+        return undefined;
+    const window = provider.modelContextWindows[id];
+    return Number.isSafeInteger(window) && window > 0 ? window : undefined;
+}
+/**
+ * Point a provider's own window at one model's saved limit.
+ *
+ * A model switch must not keep the previous model's limit, and a model with no saved entry must
+ * not inherit one: the saved window for the target model is applied when the map holds it, and the
+ * provider-level value is dropped when it does not. `/status` and the run budget read
+ * `contextWindow` directly, so a switch that only deleted it would report an unknown limit for a
+ * model whose limit the provider already knows.
+ */
+export function applyModelContextWindow(provider, model) {
+    const saved = configuredContextWindow(provider, model);
+    if (saved !== undefined)
+        provider.contextWindow = saved;
+    else
+        delete provider.contextWindow;
+}
+/**
+ * Raw provider secrets: stored API keys plus the current values of their named environment
+ * variables. The trajectory's own credential-name heuristic cannot know an arbitrary
+ * `apiKeyEnv` name, so every place providers (re)register secrets uses this helper — initial
+ * config load and mid-session provider edits alike.
+ */
+export function providerSecrets(providers, env = process.env) {
+    return providers.flatMap(provider => [provider.apiKey, provider.apiKeyEnv ? env[provider.apiKeyEnv] : undefined].filter((key) => !!key));
+}
+/**
+ * Record one model as configured for the provider, keeping the saved list consistent with it.
+ *
+ * The list is materialized only once it holds more than the active model, or once it exists at all:
+ * a provider edited without ever touching its model list keeps the configuration shape it had.
+ */
+export function recordProviderModel(provider, model) {
+    const list = providerModels(provider);
+    if (!list.includes(model))
+        list.push(model);
+    if (list.length > 1 || provider.models !== undefined)
+        provider.models = list;
+}
+/** Validate credentials without including their contents in errors. */
+export function assertProviderCredentials(provider) {
+    if (provider.anthropicAuth !== undefined && (provider.type !== 'anthropic' || provider.anthropicAuth !== 'console')) {
+        throw new Error('anthropicAuth is an Anthropic-only setting whose only value is console.');
+    }
+    if (provider.anthropicAuth === 'console' && (provider.apiKey !== undefined || provider.apiKeyEnv !== undefined)) {
+        throw new Error('Claude Console sign-in replaces the API key; remove the key or the sign-in.');
+    }
+    if (provider.type === 'codex' && (provider.apiKey !== undefined || provider.apiKeyEnv !== undefined)) {
+        throw new Error('Codex providers use Codex sign-in; API key overrides are not supported.');
+    }
+    if (provider.type === 'claude' && (provider.apiKey !== undefined || provider.apiKeyEnv !== undefined)) {
+        throw new Error('Claude providers use Claude Code sign-in; API key overrides are not supported.');
+    }
+    if (provider.apiKey !== undefined && (typeof provider.apiKey !== 'string' || !/^[\x21-\x7e]+$/.test(provider.apiKey))) {
+        throw new Error('API key must be nonempty and contain no whitespace or control characters.');
+    }
+    if (provider.apiKeyEnv !== undefined && (typeof provider.apiKeyEnv !== 'string' || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(provider.apiKeyEnv))) {
+        throw new Error('Invalid API key environment variable name.');
+    }
+}
+/** Shared credential precedence for inference and model discovery. */
+export function resolveProviderApiKey(provider) {
+    assertProviderCredentials(provider);
+    if (provider.apiKey !== undefined)
+        return provider.apiKey;
+    if (provider.apiKeyEnv === undefined)
+        return undefined;
+    const key = process.env[provider.apiKeyEnv];
+    if (!key)
+        throw new Error(`Set ${provider.apiKeyEnv} or save an API key in /providers before using this provider.`);
+    if (!/^[\x21-\x7e]+$/.test(key))
+        throw new Error('The configured API key environment variable contains an invalid credential.');
+    return key;
+}
+export function defaultProviders() {
+    return [
+        { id: 'openai', type: 'openai-compatible', baseUrl: 'https://api.openai.com/v1', apiKeyEnv: 'OPENAI_API_KEY', model: 'gpt-4.1' },
+        { id: 'anthropic', type: 'anthropic', baseUrl: 'https://api.anthropic.com/v1', apiKeyEnv: 'ANTHROPIC_API_KEY', model: 'claude-opus-5-5' },
+        { id: 'local', type: 'openai-compatible', baseUrl: 'http://127.0.0.1:1234/v1', model: 'local-model' },
+    ];
+}
+const MAX_REQUEST_RETRIES = 3;
+const REQUEST_RETRY_DELAYS_MS = [1_000, 30_000, 120_000];
+const MALFORMED_STREAM_RETRY_DELAYS_MS = [1_000, 3_000, 10_000];
+const MAX_AUTOMATIC_RETRY_AFTER_MS = REQUEST_RETRY_DELAYS_MS.at(-1);
+export class ProviderRequestError extends Error {
+    contextOverflow;
+    /**
+     * Set when this request was classified as exceeding the context window. It travels structured so
+     * telemetry reports a limit without re-deriving one from an error message, and so a provider
+     * failure rate never absorbs an input that was simply too large.
+     */
+    constructor(message, contextOverflow = false) {
+        super(message);
+        this.contextOverflow = contextOverflow;
+        this.name = 'Error';
+    }
+}
+class RetryableProviderError extends ProviderRequestError {
+    retryAfterMs;
+    retryDelaysMs;
+    constructor(message, retryAfterMs = 0, retryDelaysMs = REQUEST_RETRY_DELAYS_MS) {
+        super(message);
+        this.retryAfterMs = retryAfterMs;
+        this.retryDelaysMs = retryDelaysMs;
+        this.name = 'Error';
+    }
+}
+/** A malformed SSE completion is safe to replay because no tool from that response has executed. */
+class MalformedStreamProviderError extends RetryableProviderError {
+    constructor() { super('Provider returned a malformed response.', 0, MALFORMED_STREAM_RETRY_DELAYS_MS); }
+}
+/** A completed HTTP exchange the provider refused outright; `status` drives compatibility fallbacks. */
+class HttpProviderError extends ProviderRequestError {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = 'Error';
+    }
+}
+function retryAfter(value) {
+    if (!value)
+        return 0;
+    const seconds = Number(value);
+    const ms = Number.isFinite(seconds) ? seconds * 1000 : Date.parse(value) - Date.now();
+    return Number.isFinite(ms) ? Math.max(0, ms) : 0;
+}
+function permanentConnectionFailure(error) {
+    if (!error || typeof error !== 'object')
+        return false;
+    const failure = error;
+    return /^(?:ERR_TLS_|CERT_|DEPTH_ZERO_SELF_SIGNED_CERT$|SELF_SIGNED_CERT_IN_CHAIN$|UNABLE_TO_VERIFY_LEAF_SIGNATURE$|UNABLE_TO_GET_ISSUER_CERT|ERR_INVALID_|ENOTFOUND$)/.test(failure.code ?? '')
+        || /^(?:unexpected redirect|redirect count exceeded|bad port|unknown scheme|invalid redirect|URL scheme must be)/i.test(failure.message ?? '')
+        || (failure.cause !== error && permanentConnectionFailure(failure.cause));
+}
+/**
+ * The transport code behind a failed fetch, preferring the cause's over the wrapper's.
+ *
+ * Only the code is surfaced. An exception's message is free text that has been seen to embed
+ * credentials, while the code is the part that tells an operator whether this is DNS, TLS, a
+ * refused port or a bad certificate anyway.
+ */
+function connectionFailureDetail(error) {
+    if (!error || typeof error !== 'object')
+        return undefined;
+    const failure = error;
+    const cause = failure.cause && typeof failure.cause === 'object' ? failure.cause : undefined;
+    const code = typeof cause?.code === 'string' && cause.code ? cause.code : typeof failure.code === 'string' && failure.code ? failure.code : undefined;
+    // Transport codes are errno-style (ENOTFOUND, ECONNRESET, ERR_TLS_...). Anything else is an
+    // arbitrary string some library attached, and echoing it would expose whatever it put there.
+    return code && /^[A-Z][A-Z0-9_]*$/.test(code) ? code : undefined;
+}
+function cancelled() { throw new Error('Provider request cancelled.'); }
+function malformed() { throw new Error('Provider returned a malformed response.'); }
+class ResponseTooLargeError extends Error {
+    constructor() { super('Provider response exceeds the 4 MiB limit.'); }
+}
+async function boundedJson(response) {
+    if (!response.body)
+        return malformed();
+    const reader = response.body.getReader();
+    const buffer = Buffer.allocUnsafe(4 * 1024 * 1024);
+    let bytes = 0;
+    try {
+        while (true) {
+            const chunk = await reader.read().catch(() => { throw new RetryableProviderError('Provider connection failed while reading its response.'); });
+            if (chunk.done)
+                break;
+            if (chunk.value.byteLength > buffer.length - bytes) {
+                await reader.cancel().catch(() => { });
+                throw new ResponseTooLargeError();
+            }
+            buffer.set(chunk.value, bytes);
+            bytes += chunk.value.byteLength;
+        }
+        return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(buffer.subarray(0, bytes)));
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function record(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return malformed();
+    return value;
+}
+/**
+ * The provider's own explanation of a rejected request, from its bounded error body.
+ *
+ * Envelopes differ: OpenAI and DeepSeek nest `{error:{message}}`, Anthropic adds its own
+ * `{type,error}`, and vLLM's proxy puts a JSON string in `detail`. Only message-bearing fields
+ * are read, because the rest of an error body can echo request content or credentials and belongs
+ * in the provider's logs, not in the run record the person keeps.
+ */
+function providerErrorDetail(value, depth = 0) {
+    if (!value || typeof value !== 'object' || Array.isArray(value) || depth > 2)
+        return undefined;
+    const record = value;
+    const error = record.error;
+    const nested = error && typeof error === 'object' && !Array.isArray(error) ? error : undefined;
+    for (const candidate of [nested?.message, nested?.detail, record.message, record.detail, typeof error === 'string' ? error : undefined, nested]) {
+        if (candidate && typeof candidate === 'object') {
+            const detail = providerErrorDetail(candidate, depth + 1);
+            if (detail)
+                return detail;
+            continue;
+        }
+        if (typeof candidate !== 'string' || !candidate.trim())
+            continue;
+        const trimmed = candidate.trim();
+        if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+            const detail = providerErrorDetail(safeJson(trimmed), depth + 1);
+            if (detail)
+                return detail;
+            // A structured payload is subject to the same allowlist as a structured body: without an
+            // approved message field inside it, the serialized text stays in the provider's logs.
+            continue;
+        }
+        return boundedProviderDetail(trimmed);
+    }
+    return undefined;
+}
+function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function boundedProviderDetail(text) {
+    const collapsed = text.replace(/\s+/g, ' ').trim().replace(/[.!?]+$/, '');
+    if (!collapsed)
+        return undefined;
+    return collapsed.length > 400 ? `${collapsed.slice(0, 397)}...` : collapsed;
+}
+/** Masks the configured credential, which providers have been seen to echo back in error bodies. */
+function redactCredential(text, key) {
+    return key ? text.split(key).join('[redacted]') : text;
+}
+function nonempty(value) {
+    if (typeof value !== 'string' || !value.trim())
+        return malformed();
+    return value;
+}
+function tokenCount(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+function usage(value, anthropic) {
+    const data = value && typeof value === 'object' ? value : {};
+    const details = data.prompt_tokens_details && typeof data.prompt_tokens_details === 'object' && !Array.isArray(data.prompt_tokens_details)
+        ? data.prompt_tokens_details : {};
+    const input = tokenCount(anthropic ? data.input_tokens : data.prompt_tokens);
+    // Anthropic omits cache counts when caching is unused. Missing base usage is
+    // unavailable, whereas an explicitly reported zero is a valid measurement.
+    // OpenAI-compatible cache reads follow the vendored parser's precedence:
+    // prompt_tokens_details.cached_tokens (OpenAI/vLLM), prompt_cache_hit_tokens
+    // (DeepSeek) or top-level cached_tokens (Kimi). prompt_tokens is already
+    // inclusive of cache traffic, so inputTokens needs no adjustment.
+    // Reported means the field was there: an explicit zero is a measurement, and dropping it would make
+    // "we measured nothing cached" indistinguishable from "caching was never mentioned". Surfaces that
+    // show cache figures key on that presence, so it has to survive this mapping.
+    const created = anthropic ? tokenCount(data.cache_creation_input_tokens) : tokenCount(details.cache_write_tokens);
+    const read = anthropic ? tokenCount(data.cache_read_input_tokens) : tokenCount(details.cached_tokens ?? data.prompt_cache_hit_tokens ?? data.cached_tokens);
+    const inputTokens = anthropic
+        ? input === undefined ? undefined : input + (created ?? 0) + (read ?? 0)
+        : input;
+    const outputTokens = tokenCount(anthropic ? data.output_tokens : data.completion_tokens);
+    return {
+        ...(inputTokens === undefined ? {} : { inputTokens }),
+        ...(outputTokens === undefined ? {} : { outputTokens }),
+        ...(read === undefined ? {} : { cacheRead: read }),
+        ...(created === undefined ? {} : { cacheWrite: created }), requests: 1,
+    };
+}
+function argumentsObject(value) {
+    if (typeof value !== 'string')
+        return malformed();
+    try {
+        return record(JSON.parse(value));
+    }
+    catch {
+        return malformed();
+    }
+}
+function checkCalls(calls, completionAdvertised) {
+    // Names are authorized by the executor so unadvertised calls become repairable observations.
+    const ids = new Set();
+    for (const call of calls) {
+        if (ids.has(call.id))
+            malformed();
+        ids.add(call.id);
+        // Completion is control data validated by the bounded runtime repair loop.
+        // Executable tools retain strict adapter validation before any side effects.
+        if (call.name !== COMPLETION_TOOL || !completionAdvertised)
+            argumentsObject(call.arguments);
+    }
+    return calls;
+}
+/**
+ * Validate one whole-body chat completion into a {@link ModelResponse}.
+ *
+ * Shared by the unstreamed request path and by the streaming path's whole-body fallback,
+ * so a server that answers `stream: true` with plain JSON is held to exactly the checks a
+ * server that never streamed must pass.
+ */
+function wholeBodyCompletion(data, requests, completionAdvertised) {
+    if (!Array.isArray(data.choices) || data.choices.length !== 1)
+        return malformed();
+    const choice = record(data.choices[0]), message = record(choice.message);
+    if (message.content != null && typeof message.content !== 'string')
+        return malformed();
+    if (message.refusal != null && typeof message.refusal !== 'string')
+        return malformed();
+    for (const key of ['reasoning_content', 'reasoning', 'reasoning_text']) {
+        if (message[key] != null && typeof message[key] !== 'string')
+            return malformed();
+    }
+    const reasoningText = [message.reasoning_content, message.reasoning, message.reasoning_text]
+        .find((value) => typeof value === 'string' && value.length > 0)
+        ?? (typeof message.reasoning_content === 'string' ? message.reasoning_content : undefined);
+    const reasoning = reasoningText !== undefined ? { reasoningContent: reasoningText } : {};
+    // Refusals are valid model output, even when content is null. Preserve the
+    // text for normal bounded completion handling instead of a transport error.
+    const text = [message.content, message.refusal].filter((value) => typeof value === 'string' && value.length > 0).join('\n');
+    if (message.tool_calls != null && !Array.isArray(message.tool_calls))
+        return malformed();
+    // Truncated function arguments may not be JSON (or even contain a name yet).
+    // Discard the entire batch and let the runtime apply its bounded repair policy.
+    if (choice.finish_reason === 'length' || choice.finish_reason === 'content_filter') {
+        return { text, toolCalls: [], usage: { ...usage(data.usage, false), requests }, stopReason: choice.finish_reason };
+    }
+    const calls = (message.tool_calls ?? []).map(raw => {
+        const call = record(raw), fn = record(call.function);
+        if (call.type !== 'function')
+            return malformed();
+        const name = nonempty(fn.name);
+        const repairableCompletion = name === COMPLETION_TOOL && completionAdvertised;
+        if (repairableCompletion && typeof fn.arguments !== 'string')
+            return malformed();
+        return { id: nonempty(call.id), name, arguments: repairableCompletion ? fn.arguments : nonempty(fn.arguments) };
+    });
+    if ((choice.finish_reason === 'tool_calls' && !calls.length) || (message.content == null && message.refusal == null && !calls.length))
+        return malformed();
+    return { text, toolCalls: checkCalls(calls, completionAdvertised), usage: { ...usage(data.usage, false), requests }, stopReason: nonempty(choice.finish_reason), ...reasoning };
+}
+/**
+ * Assemble a streamed chat completion, validating it to the same rules as the whole-body path.
+ *
+ * Every streamed fragment type is checked as it arrives, so a malformed stream fails at the
+ * offending chunk rather than after silently accumulating garbage. Tool-call fragments are
+ * keyed by their `index` and concatenated in arrival order, which is how every
+ * OpenAI-compatible server splits them.
+ */
+function createStreamAccumulator(onReasoning, now = Date.now) {
+    let content = '', refusal, reasoning = '', finishReason, chunkUsage;
+    let sawChoice = false, sawText = false;
+    let firstOutputAt, lastOutputAt;
+    const fragments = [];
+    const text = (value) => {
+        if (value == null)
+            return null;
+        if (typeof value !== 'string')
+            return malformed();
+        return value;
+    };
+    // The decode window opens at the first generated fragment and closes at the last: prompt
+    // processing ends where the first stamp falls, and everything between requests (tool runs,
+    // retries, the usage tail) is outside the pair. A stream that answers in a single fragment
+    // leaves the pair collapsed, and no window is claimed.
+    const stampOutput = () => {
+        const at = now();
+        if (firstOutputAt === undefined)
+            firstOutputAt = at;
+        lastOutputAt = at;
+    };
+    const decodeWindow = () => firstOutputAt !== undefined && lastOutputAt !== undefined && lastOutputAt > firstOutputAt ? lastOutputAt - firstOutputAt : undefined;
+    return {
+        /** Whether the stream delivered a choice with a finish reason, i.e. truly completed. */
+        get completed() { return sawChoice && finishReason !== undefined; },
+        /** The measured decode window, or undefined when the stream never gave one. */
+        get decodeMs() { return decodeWindow(); },
+        event(data) {
+            if (data === '[DONE]')
+                return;
+            let parsed;
+            try {
+                parsed = JSON.parse(data);
+            }
+            catch {
+                return malformed();
+            }
+            const chunk = record(parsed);
+            if (chunk.usage != null) {
+                if (typeof chunk.usage !== 'object' || Array.isArray(chunk.usage))
+                    return malformed();
+                chunkUsage = chunk.usage;
+            }
+            const choices = chunk.choices;
+            if (choices === undefined) {
+                // The usage-only final chunk carries no choices; a chunk without either is malformed.
+                if (chunkUsage === undefined)
+                    return malformed();
+                return;
+            }
+            if (!Array.isArray(choices) || choices.length > 1)
+                return malformed();
+            if (!choices.length)
+                return;
+            sawChoice = true;
+            const choice = record(choices[0]);
+            if (choice.finish_reason != null && typeof choice.finish_reason !== 'string')
+                return malformed();
+            if (typeof choice.finish_reason === 'string' && choice.finish_reason)
+                finishReason = choice.finish_reason;
+            const delta = record(choice.delta ?? {});
+            const reasoningDelta = text(delta.reasoning_content);
+            if (reasoningDelta) {
+                reasoning += reasoningDelta;
+                onReasoning(reasoningDelta);
+            }
+            // The decode window counts every representation the production parser streams as thinking:
+            // openai-completions.ts takes the first non-empty of reasoning_content, reasoning, and
+            // reasoning_text, so a model that answers its reasoning through the other fields is still
+            // generating, and its window must open at that first fragment rather than at the answer.
+            if (reasoningDelta || text(delta.reasoning) || text(delta.reasoning_text))
+                stampOutput();
+            const contentDelta = text(delta.content);
+            // An empty content string still records the field's presence: the whole-body path
+            // distinguishes `content: ""` from `null`, and the streamed answer must keep that
+            // distinction so an empty completion reaches the runtime's bounded repair loop
+            // instead of failing as a malformed response.
+            if (contentDelta !== null) {
+                sawText = true;
+                if (contentDelta) {
+                    content += contentDelta;
+                    stampOutput();
+                }
+            }
+            const refusalDelta = text(delta.refusal);
+            if (refusalDelta !== null) {
+                refusal = (refusal ?? '') + refusalDelta;
+                if (refusalDelta)
+                    stampOutput();
+            }
+            if (delta.tool_calls === undefined)
+                return;
+            if (!Array.isArray(delta.tool_calls))
+                return malformed();
+            if (delta.tool_calls.length > 0)
+                stampOutput();
+            for (const raw of delta.tool_calls) {
+                const fragment = record(raw);
+                if (typeof fragment.index !== 'number' || !Number.isSafeInteger(fragment.index) || fragment.index < 0)
+                    return malformed();
+                if (fragment.type !== undefined && fragment.type !== 'function')
+                    return malformed();
+                if (fragment.id !== undefined && typeof fragment.id !== 'string')
+                    return malformed();
+                const fn = fragment.function === undefined ? {} : record(fragment.function);
+                if (fn.name !== undefined && typeof fn.name !== 'string')
+                    return malformed();
+                if (fn.arguments !== undefined && typeof fn.arguments !== 'string')
+                    return malformed();
+                let call = fragments.find(existing => existing.index === fragment.index);
+                if (!call) {
+                    call = { index: fragment.index, id: '', name: '', arguments: '' };
+                    fragments.push(call);
+                }
+                if (typeof fragment.id === 'string')
+                    call.id += fragment.id;
+                if (typeof fn.name === 'string')
+                    call.name += fn.name;
+                if (typeof fn.arguments === 'string')
+                    call.arguments += fn.arguments;
+            }
+        },
+        finish(requests, completionAdvertised) {
+            if (!sawChoice)
+                return malformed();
+            // Refusals are valid model output, even when content is null. Preserve the
+            // text for normal bounded completion handling instead of a transport error.
+            const body = [content, refusal].filter((value) => typeof value === 'string' && value.length > 0).join('\n');
+            const measured = decodeWindow();
+            // Truncated function arguments may not be JSON (or even contain a name yet).
+            // Discard the entire batch and let the runtime apply its bounded repair policy.
+            if (finishReason === 'length' || finishReason === 'content_filter') {
+                return { text: body, toolCalls: [], usage: { ...usage(chunkUsage, false), requests, ...(measured === undefined ? {} : { decodeMs: measured }) }, stopReason: finishReason };
+            }
+            const calls = [...fragments].sort((a, b) => a.index - b.index).map(fragment => {
+                const name = nonempty(fragment.name);
+                const repairableCompletion = name === COMPLETION_TOOL && completionAdvertised;
+                return { id: nonempty(fragment.id), name, arguments: repairableCompletion ? fragment.arguments : nonempty(fragment.arguments) };
+            });
+            if ((finishReason === 'tool_calls' && !calls.length) || (!sawText && refusal === undefined && !calls.length))
+                return malformed();
+            return { text: body, toolCalls: checkCalls(calls, completionAdvertised), usage: { ...usage(chunkUsage, false), requests, ...(measured === undefined ? {} : { decodeMs: measured }) }, stopReason: nonempty(finishReason), ...(reasoning ? { reasoningContent: reasoning } : {}) };
+        },
+    };
+}
+/** Validate original Anthropic JSON fragments before upstream's display-oriented JSON salvage. */
+function createAnthropicStreamAccumulator(now = Date.now) {
+    const blocks = new Map();
+    let started = false, stopped = false, finishReason;
+    let firstOutputAt, lastOutputAt;
+    const blockAt = (index) => {
+        if (!Number.isSafeInteger(index) || index < 0)
+            return malformed();
+        const block = blocks.get(index);
+        if (!block || block.stopped)
+            return malformed();
+        return block;
+    };
+    // Same decode-window rule as the OpenAI-compatible accumulator: the first generated fragment
+    // opens the window and the last closes it, so prompt processing and inter-request time stay out.
+    const stampOutput = () => {
+        const at = now();
+        if (firstOutputAt === undefined)
+            firstOutputAt = at;
+        lastOutputAt = at;
+    };
+    const decodeWindow = () => firstOutputAt !== undefined && lastOutputAt !== undefined && lastOutputAt > firstOutputAt ? lastOutputAt - firstOutputAt : undefined;
+    return {
+        /** The measured decode window, or undefined when the stream never gave one. */
+        get decodeMs() { return decodeWindow(); },
+        event(data) {
+            let parsed;
+            try {
+                parsed = JSON.parse(data);
+            }
+            catch {
+                return malformed();
+            }
+            const event = record(parsed);
+            if (event.type === 'ping')
+                return;
+            if (stopped)
+                return malformed();
+            if (event.type === 'message_start') {
+                if (started)
+                    return malformed();
+                started = true;
+                return;
+            }
+            if (!started)
+                return malformed();
+            if (event.type === 'content_block_start') {
+                if (!Number.isSafeInteger(event.index) || event.index < 0 || blocks.has(event.index))
+                    return malformed();
+                const input = record(event.content_block);
+                const type = nonempty(input.type);
+                if (!['text', 'tool_use', 'thinking', 'redacted_thinking'].includes(type))
+                    return malformed();
+                if (type === 'text' && typeof input.text !== 'string')
+                    return malformed();
+                blocks.set(event.index, { type, stopped: false, text: type === 'text' ? input.text : '', fragments: '', sawInputDelta: false,
+                    ...(type === 'tool_use' ? { id: nonempty(input.id), name: nonempty(input.name), input: record(input.input) } : {}) });
+                return;
+            }
+            if (event.type === 'content_block_delta') {
+                const block = blockAt(event.index), delta = record(event.delta);
+                if (block.type === 'tool_use' && delta.type === 'input_json_delta') {
+                    if (typeof delta.partial_json !== 'string')
+                        return malformed();
+                    block.fragments += delta.partial_json;
+                    block.sawInputDelta = true;
+                    if (delta.partial_json)
+                        stampOutput();
+                }
+                else if (block.type === 'text' && delta.type === 'text_delta') {
+                    if (typeof delta.text !== 'string')
+                        return malformed();
+                    block.text += delta.text;
+                    if (delta.text)
+                        stampOutput();
+                }
+                else if (block.type === 'thinking' && ['thinking_delta', 'signature_delta'].includes(String(delta.type))) {
+                    const piece = delta[delta.type === 'thinking_delta' ? 'thinking' : 'signature'];
+                    if (typeof piece !== 'string')
+                        return malformed();
+                    if (piece)
+                        stampOutput();
+                }
+                else
+                    return malformed();
+                return;
+            }
+            if (event.type === 'content_block_stop') {
+                blockAt(event.index).stopped = true;
+                return;
+            }
+            if (event.type === 'message_delta') {
+                const delta = record(event.delta);
+                if (delta.stop_reason != null)
+                    finishReason = nonempty(delta.stop_reason);
+                return;
+            }
+            if (event.type === 'message_stop') {
+                stopped = true;
+                return;
+            }
+            return malformed();
+        },
+        finish(requests, completionAdvertised) {
+            if (!started || !stopped || !finishReason)
+                throw new RetryableProviderError('Provider closed the stream before the response completed.');
+            const ordered = [...blocks.entries()].sort(([a], [b]) => a - b).map(([, block]) => block);
+            const text = ordered.filter(block => block.type === 'text').map(block => block.text).join('\n');
+            const measured = decodeWindow();
+            const measuredUsage = { requests, ...(measured === undefined ? {} : { decodeMs: measured }) };
+            // An explicit output limit discards the entire tool batch, including unfinished fragments.
+            if (finishReason === 'max_tokens')
+                return { text, toolCalls: [], stopReason: 'length', usage: { ...measuredUsage } };
+            if (ordered.some(block => !block.stopped))
+                return malformed();
+            const calls = ordered.filter(block => block.type === 'tool_use').map(block => ({ id: block.id, name: block.name,
+                arguments: block.sawInputDelta ? block.fragments : JSON.stringify(block.input) }));
+            if (finishReason === 'tool_use' && !calls.length)
+                return malformed();
+            return { text, toolCalls: checkCalls(calls, completionAdvertised), stopReason: finishReason, usage: { ...measuredUsage } };
+        },
+    };
+}
+export function createAdapter(config) {
+    if (config.reasoningEffort !== undefined && (!['openai-compatible', 'opencode-go'].includes(config.type) || !REASONING_EFFORTS.includes(config.reasoningEffort)))
+        throw new Error('Reasoning effort overrides require an OpenAI-compatible or OpenCode Go provider and a supported effort value.');
+    assertRequestTimeout(config);
+    assertStreamIdleTimeout(config);
+    assertProviderCredentials(config);
+    if (config.type === 'codex')
+        return createCodexAdapter(config);
+    if (config.type === 'claude')
+        return createClaudeAdapter(config);
+    if (config.type === 'opencode-go')
+        return createOpenCodeAdapter(config);
+    let base;
+    try {
+        base = new URL(config.baseUrl);
+    }
+    catch {
+        throw new Error('Provider base URL is invalid.');
+    }
+    if (!['https:', 'http:'].includes(base.protocol) || base.username || base.password || base.search || base.hash) {
+        throw new Error('Provider base URL must be HTTP(S) without credentials, query, or fragment.');
+    }
+    if (config.type !== 'openai-compatible' && config.type !== 'anthropic')
+        throw new Error('Unsupported provider type.');
+    const anthropic = config.type === 'anthropic';
+    // Resolved once per adapter: `0` is the explicit "no bound" spelling, so the caller's signal
+    // stays the only abort source and a slow-but-working request is never cut short.
+    const requestTimeoutMs = config.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    // Discovery keeps its own bound even when inference has none, but a provider that asked for
+    // something shorter than that still gets it.
+    const listingTimeoutMs = requestTimeoutMs > 0 ? Math.min(requestTimeoutMs, MODEL_LISTING_TIMEOUT_MS) : MODEL_LISTING_TIMEOUT_MS;
+    // A configured stream inactivity bound owns inference idleness on its own, so a provider that
+    // removed `requestTimeoutMs` for a slow prefill still ends a stream that stops delivering bytes.
+    const inferenceTimeoutMs = config.streamIdleTimeoutMs ?? requestTimeoutMs;
+    /**
+     * One HTTP exchange under the caller's signal plus this call's own deadline.
+     *
+     * The deadline is kept separate from the caller's signal rather than pre-combined, because the
+     * two failures must not be confused: a caller that cancelled is a cancellation, while a deadline
+     * this adapter armed is a timeout. Collapsing them reported a stalled endpoint as a user
+     * cancellation. The deadline is returned so a failure while reading the body afterwards can
+     * still be told apart the same way.
+     */
+    async function send(path, signal, body, timeoutMs, inference = false, forceRefresh = false) {
+        if (signal.aborted)
+            cancelled();
+        // Credentials can need a token refresh, which is bounded by this request's own deadline too.
+        const authDeadline = timeoutMs > 0 ? AbortSignal.timeout(timeoutMs) : undefined;
+        let credential;
+        try {
+            credential = await providerAuthHeaders(config, { forceRefresh, signal: authDeadline ? AbortSignal.any([signal, authDeadline]) : signal });
+        }
+        catch (error) {
+            if (signal.aborted)
+                cancelled();
+            if (authDeadline?.aborted)
+                throw new RetryableProviderError('Provider request timed out.');
+            throw error;
+        }
+        const headers = { 'content-type': 'application/json', ...credential };
+        // The credential this request carries, whichever header holds it, so a rejection that echoes it is redacted.
+        const key = headers['x-api-key'] ?? headers.authorization?.replace(/^Bearer /, '');
+        const idle = inference && timeoutMs > 0 ? new AbortController() : undefined;
+        let timer;
+        const refresh = () => {
+            if (!idle || idle.signal.aborted)
+                return;
+            clearTimeout(timer);
+            timer = setTimeout(() => idle.abort(new DOMException('Provider request timed out.', 'TimeoutError')), timeoutMs);
+        };
+        let dispose = () => { clearTimeout(timer); };
+        const deadline = idle?.signal ?? (timeoutMs > 0 ? AbortSignal.timeout(timeoutMs) : undefined);
+        const combined = deadline ? AbortSignal.any([signal, deadline]) : signal;
+        const serializedBody = body === undefined ? undefined : JSON.stringify(body);
+        refresh();
+        let response;
+        try {
+            response = await fetch(`${base.href.replace(/\/$/, '')}/${path}`, {
+                method: body === undefined ? 'GET' : 'POST', headers, redirect: 'error', signal: combined,
+                ...(serializedBody === undefined ? {} : { body: serializedBody }),
+            });
+        }
+        catch (error) {
+            dispose();
+            if (signal.aborted)
+                throw new Error('Provider request cancelled.');
+            if (deadline?.aborted)
+                throw new RetryableProviderError('Provider request timed out.');
+            // The transport's own code is what tells an operator whether this is DNS, TLS, a refused
+            // port or a bad certificate; without it the sentence repeats the base URL they already know.
+            const cause = connectionFailureDetail(error);
+            const message = `Provider connection failed${cause ? ` (${cause})` : ''}. Check its URL and network connection.`;
+            if (permanentConnectionFailure(error))
+                throw new ProviderRequestError(message);
+            throw new RetryableProviderError(message);
+        }
+        // A Console token can be revoked before its recorded expiry; one refresh tells that apart from a
+        // login that is really gone, which then fails below like any other rejected credential.
+        if (response.status === 401 && config.anthropicAuth === 'console' && !forceRefresh) {
+            dispose();
+            await response.body?.cancel().catch(() => { });
+            return send(path, signal, body, timeoutMs, inference, true);
+        }
+        if (!response.ok) {
+            try {
+                // HTTP 413 is sufficient evidence that this payload exceeds the gateway's
+                // allowance. Do not depend on error-body format or read an unbounded body.
+                if (response.status === 413) {
+                    await response.body?.cancel().catch(() => { });
+                    throw new ProviderRequestError('Provider input exceeds the context window.', true);
+                }
+                const errorData = await boundedJson(response).catch(() => undefined);
+                // Context overflow is a classification, not a provider message: reporting it the same
+                // way every time keeps retry policy and the run record stable across providers.
+                if ([400, 422].includes(response.status) && errorData !== undefined && isEngineContextOverflow(JSON.stringify(errorData))) {
+                    throw new ProviderRequestError('Provider input exceeds the context window.', true);
+                }
+                await response.body?.cancel().catch(() => { });
+                // A provider that echoes the submitted key back in its rejection message must not have it
+                // copied into the thrown error, which lands in the run record outside the trajectory
+                // sanitizer's reach.
+                const detail = providerErrorDetail(errorData);
+                const shown = detail === undefined ? undefined : redactCredential(detail, key);
+                const message = `Provider request failed (HTTP ${response.status})${shown ? `: ${shown}` : ''}. Check credentials, model, and provider availability.`;
+                if ([408, 409, 429, 500, 502, 503, 504, 529].includes(response.status)) {
+                    throw new RetryableProviderError(message, retryAfter(response.headers.get('retry-after')));
+                }
+                throw new HttpProviderError(message, response.status);
+            }
+            finally {
+                dispose();
+            }
+        }
+        if (inference && response.body) {
+            refresh();
+            const reader = response.body.getReader();
+            let ended = false;
+            const cleanup = () => {
+                clearTimeout(timer);
+                combined.removeEventListener('abort', abort);
+            };
+            const cancelReader = () => { void reader.cancel().catch(() => { }).finally(() => reader.releaseLock()); };
+            let streamController;
+            const abort = () => {
+                if (ended)
+                    return;
+                ended = true;
+                cleanup();
+                streamController.error(combined.reason);
+                cancelReader();
+            };
+            const stream = new ReadableStream({
+                start(controller) {
+                    streamController = controller;
+                    combined.addEventListener('abort', abort, { once: true });
+                    if (combined.aborted)
+                        abort();
+                },
+                async pull(controller) {
+                    try {
+                        const chunk = await reader.read();
+                        if (ended)
+                            return;
+                        if (chunk.done) {
+                            ended = true;
+                            cleanup();
+                            reader.releaseLock();
+                            controller.close();
+                        }
+                        else {
+                            if (chunk.value.byteLength)
+                                refresh();
+                            controller.enqueue(chunk.value);
+                        }
+                    }
+                    catch (error) {
+                        if (ended)
+                            return;
+                        ended = true;
+                        cleanup();
+                        controller.error(error);
+                        cancelReader();
+                    }
+                },
+                cancel() {
+                    if (ended)
+                        return;
+                    ended = true;
+                    cleanup();
+                    return reader.cancel().catch(() => { }).finally(() => reader.releaseLock());
+                },
+            }, { highWaterMark: 0 });
+            dispose = () => {
+                if (ended)
+                    return;
+                ended = true;
+                cleanup();
+                cancelReader();
+            };
+            response = new Response(stream, { status: response.status, statusText: response.statusText, headers: response.headers });
+        }
+        return { response, deadline, dispose };
+    }
+    async function request(path, signal, body, timeoutMs = requestTimeoutMs, onRequest) {
+        onRequest?.();
+        const { response, deadline } = await send(path, signal, body, timeoutMs);
+        try {
+            return record(await boundedJson(response));
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw new Error('Provider request cancelled.');
+            if (deadline?.aborted)
+                throw new RetryableProviderError('Provider request timed out.');
+            if (error instanceof ResponseTooLargeError || error instanceof RetryableProviderError)
+                throw error;
+            return malformed();
+        }
+    }
+    /**
+     * Run one serialized inference attempt under the shared retry policy; never re-enter the
+     * agent/tool loop. Both the whole-body and the streaming request use it, so a connection
+     * that drops mid-stream restarts the same request exactly like a failed handshake.
+     */
+    async function withRetries(attempt, signal, onRetry, prepareRetry) {
+        for (let retry = 0;; retry++) {
+            if (signal.aborted)
+                cancelled();
+            try {
+                return await attempt();
+            }
+            catch (error) {
+                if (signal.aborted)
+                    cancelled();
+                if (!(error instanceof RetryableProviderError))
+                    throw error;
+                // Record request-local recovery state even when this was the final allowed attempt.
+                // In particular, a malformed fourth response must still trip the adapter's sticky
+                // whole-body circuit breaker for the next independent generation.
+                prepareRetry?.(error);
+                if (retry >= MAX_REQUEST_RETRIES)
+                    throw error;
+                // Never retry earlier than the server requests. The staged schedule gives transient
+                // local/network failures time to recover without hammering the endpoint.
+                if (error.retryAfterMs > MAX_AUTOMATIC_RETRY_AFTER_MS)
+                    throw new ProviderRequestError(`${error.message} Retry-After exceeds the 120-second automatic retry limit.`);
+                const delayMs = Math.max(error.retryDelaysMs[retry] ?? error.retryDelaysMs.at(-1) ?? 0, error.retryAfterMs);
+                const reason = error instanceof MalformedStreamProviderError
+                    ? 'Provider returned a malformed streamed response; retrying without streaming.'
+                    : error.message;
+                await onRetry?.({ retry: retry + 1, maxRetries: MAX_REQUEST_RETRIES, delayMs, reason });
+                try {
+                    await delay(delayMs, undefined, { signal });
+                }
+                catch {
+                    cancelled();
+                }
+            }
+        }
+    }
+    // A provider that emits malformed SSE is kept on whole-body responses for this adapter's
+    // lifetime. Recreating/switching the provider probes streaming again without repeatedly
+    // sacrificing long generations to a known-bad stream path.
+    let preferNonStreaming = false;
+    return {
+        async generate(input) {
+            const { model, tools, signal, onRetry, onRequest } = input;
+            let requests = 0;
+            let deadline;
+            let dispose;
+            let forceNonStreaming = preferNonStreaming;
+            let currentRequestNonStreaming = false;
+            const advertised = tools.some(tool => tool.name === COMPLETION_TOOL);
+            try {
+                const result = await withRetries(() => generateEngineResponse(input, {
+                    providerId: config.id, baseUrl: base.href.replace(/\/$/, ''), anthropic,
+                    contextWindow: model === config.model ? config.contextWindow ?? 128_000 : 128_000,
+                    reasoningEffort: model === config.model ? config.reasoningEffort : undefined,
+                    async send(body) {
+                        // A failed send must not inherit an expired deadline from an earlier response.
+                        deadline = undefined;
+                        dispose?.();
+                        dispose = undefined;
+                        requests++;
+                        onRequest?.();
+                        // Re-read the adapter-wide breaker for every attempt: another concurrent
+                        // invocation may have discovered a broken stream while this one was backing off.
+                        currentRequestNonStreaming = forceNonStreaming || preferNonStreaming;
+                        const requestBody = currentRequestNonStreaming
+                            ? (() => { const plain = { ...body }; delete plain.stream_options; plain.stream = false; return plain; })()
+                            : body;
+                        const sent = await send(anthropic ? 'messages' : 'chat/completions', signal, requestBody, inferenceTimeoutMs, true);
+                        deadline = sent.deadline;
+                        dispose = sent.dispose;
+                        return sent.response;
+                    },
+                    async parseWhole(response) {
+                        let data;
+                        try {
+                            data = record(await boundedJson(response));
+                        }
+                        catch (error) {
+                            if (signal.aborted)
+                                cancelled();
+                            if (deadline?.aborted)
+                                throw new RetryableProviderError('Provider request timed out.');
+                            if (error instanceof ResponseTooLargeError || error instanceof RetryableProviderError)
+                                throw error;
+                            return malformed();
+                        }
+                        if (!anthropic)
+                            return wholeBodyCompletion(data, requests, advertised);
+                        if (!Array.isArray(data.content) || !data.content.length)
+                            return malformed();
+                        const text = [], calls = [];
+                        const thinking = [];
+                        for (const raw of data.content) {
+                            const block = record(raw);
+                            if (block.type === 'text') {
+                                if (typeof block.text !== 'string')
+                                    return malformed();
+                                text.push(block.text);
+                            }
+                            else if (block.type === 'tool_use') {
+                                calls.push({ id: nonempty(block.id), name: nonempty(block.name), arguments: JSON.stringify(record(block.input)) });
+                            }
+                            else if (block.type === 'thinking') {
+                                if (typeof block.thinking !== 'string' || typeof block.signature !== 'string')
+                                    return malformed();
+                                thinking.push({ type: 'thinking', thinking: block.thinking, thinkingSignature: block.signature });
+                            }
+                            else if (block.type === 'redacted_thinking') {
+                                if (typeof block.data !== 'string')
+                                    return malformed();
+                                thinking.push({ type: 'thinking', thinking: '[Reasoning redacted]', thinkingSignature: block.data, redacted: true });
+                            }
+                            else
+                                return malformed();
+                        }
+                        const stopReason = nonempty(data.stop_reason);
+                        if (stopReason === 'tool_use' && !calls.length)
+                            return malformed();
+                        return { text: text.join('\n'), toolCalls: stopReason === 'max_tokens' ? [] : checkCalls(calls, advertised),
+                            usage: { ...usage(data.usage, true), requests }, stopReason: stopReason === 'max_tokens' ? 'length' : stopReason,
+                            ...(thinking.length ? { providerContinuation: { api: 'anthropic-messages', provider: config.id, model, thinking } } : {}) };
+                    },
+                    checkCalls: calls => checkCalls(calls, advertised),
+                    streamReadError: () => new RetryableProviderError('Provider connection failed while reading its response.'),
+                    streamMalformedError: () => new MalformedStreamProviderError(),
+                    streamingDisabled: () => currentRequestNonStreaming,
+                    ...(anthropic ? { streamValidator() {
+                            const validator = createAnthropicStreamAccumulator();
+                            return { event: validator.event, finish: () => validator.finish(requests, advertised) };
+                        } } : { streamValidator() {
+                            const validator = createStreamAccumulator(() => { });
+                            return { event: validator.event, finish() {
+                                    if (!validator.completed)
+                                        throw new RetryableProviderError('Provider closed the stream before the response completed.');
+                                    return validator.finish(requests, advertised);
+                                } };
+                        } }),
+                }).catch(error => {
+                    if (signal.aborted)
+                        cancelled();
+                    if (deadline?.aborted)
+                        throw new RetryableProviderError('Provider request timed out.');
+                    throw error;
+                }).finally(() => { dispose?.(); dispose = undefined; }), signal, onRetry, error => {
+                    if (error instanceof MalformedStreamProviderError) {
+                        forceNonStreaming = true;
+                        preferNonStreaming = true;
+                    }
+                });
+                return { ...result, usage: { ...result.usage, requests } };
+            }
+            catch (error) {
+                if (error instanceof ProviderRequestError)
+                    throw error;
+                throw new ProviderRequestError(error instanceof Error ? error.message : 'Provider request failed.');
+            }
+        },
+        async listModels(signal) {
+            const ids = [];
+            let path = 'models';
+            const seen = new Set();
+            for (let page = 0; page < 100; page++) {
+                const data = await request(path, signal, undefined, listingTimeoutMs);
+                if (!Array.isArray(data.data))
+                    return malformed();
+                ids.push(...data.data.map(item => nonempty(record(item).id)));
+                if (!anthropic || !data.has_more)
+                    return [...new Set(ids)].sort();
+                const cursor = nonempty(data.last_id);
+                if (seen.has(cursor))
+                    return malformed();
+                seen.add(cursor);
+                path = `models?after_id=${encodeURIComponent(cursor)}`;
+            }
+            throw new Error('Provider model listing exceeded the pagination limit.');
+        },
+    };
+}