@atomic-chat/core 0.5.1

package/dist/server/public/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../src/server/public/errors.ts"],"names":[],"mappings":"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"}

package/dist/server/public/exchange.d.ts

@@ -0,0 +1,42 @@
+/**
+ * One request as the route handlers see it: where it is going, who sent it, and how to answer with
+ * the proxy's CORS headers attached.
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { HeaderPairs } from './wire.js';
+import type { PublicServerConfig, PublicServerDeps } from './types.js';
+import type { RequestTrace } from './trace.js';
+export interface Exchange {
+    req: IncomingMessage;
+    res: ServerResponse;
+    method: string;
+    /** The path after prefix removal. */
+    path: string;
+    /** The raw query string, without `?`; `undefined` when the URL had none. */
+    query: string | undefined;
+    cors: HeaderPairs;
+    config: PublicServerConfig;
+    deps: PublicServerDeps;
+    /** The request body, when a route already had to read it to decide where the request goes. */
+    body?: Buffer;
+    trace: RequestTrace;
+}
+export declare function newExchange(req: IncomingMessage, res: ServerResponse, path: string, config: PublicServerConfig, deps: PublicServerDeps, trace: RequestTrace): Exchange;
+/** A plain-text (or pre-serialised) answer carrying the CORS headers, and `extra` before them. */
+export declare function answer(ex: Exchange, status: number, body: string | Buffer, extra?: HeaderPairs): void;
+export declare function header(req: IncomingMessage, name: string): string | undefined;
+/** Upstream connect timeout: the configured proxy timeout, which bounds connecting only. */
+export declare function connectTimeoutMs(ex: Exchange): number;
+/** How often a request still waiting for its answer is checked for a client that already left. */
+export declare const CLIENT_GONE_POLL_MS = 500;
+/** Whether the client of this request has already gone away, on either runtime. */
+export declare function requestAborted(req: IncomingMessage, res: ServerResponse): boolean;
+/**
+ * An `AbortSignal` that fires when the client disconnects before the answer is complete. Node says
+ * so with `close` on the response; under Bun that event never comes for a request whose answer has
+ * not started, so the request is also polled while it waits (ADR
+ * 2026-09-22-detect-a-client-that-hangs-up-before-the-answer-under-bun).
+ */
+export declare function clientGone(ex: Exchange, pollMs?: number): AbortSignal;
+/** `serde_json` would reject this body; the proxy answers with its own wording. */
+export declare function invalidJsonMessage(e: unknown): string;

package/dist/server/public/exchange.js

@@ -0,0 +1,85 @@
+/**
+ * One request as the route handlers see it: where it is going, who sent it, and how to answer with
+ * the proxy's CORS headers attached.
+ */
+import { corsHeaders } from './gates.js';
+import { sendWhole } from './wire.js';
+export function newExchange(req, res, path, config, deps, trace) {
+    const url = req.url ?? '/';
+    const q = url.indexOf('?');
+    const origin = typeof req.headers.origin === 'string' ? req.headers.origin : '';
+    return {
+        req,
+        res,
+        method: req.method ?? 'GET',
+        path,
+        query: q >= 0 ? url.slice(q + 1) : undefined,
+        cors: corsHeaders(origin, config.trustedHosts),
+        config,
+        deps,
+        trace,
+    };
+}
+/** A plain-text (or pre-serialised) answer carrying the CORS headers, and `extra` before them. */
+export function answer(ex, status, body, extra = []) {
+    sendWhole(ex.res, status, [...extra, ...ex.cors], body);
+}
+export function header(req, name) {
+    const value = req.headers[name.toLowerCase()];
+    return typeof value === 'string' ? value : Array.isArray(value) ? value[0] : undefined;
+}
+/** Upstream connect timeout: the configured proxy timeout, which bounds connecting only. */
+export function connectTimeoutMs(ex) {
+    return Math.max(1, ex.config.proxyTimeoutSecs) * 1000;
+}
+/** How often a request still waiting for its answer is checked for a client that already left. */
+export const CLIENT_GONE_POLL_MS = 500;
+/**
+ * Bun's `node:http` (1.3.10) tells nobody when the client hangs up before the response has started:
+ * no `close` on the response or the socket, `socket.readyState` stays `open`. The native handle
+ * behind the pair does flip an `aborted` flag, which is the only trace left. It hangs off the
+ * response (the request drops it once its body is consumed) under a symbol described `handle`,
+ * looked up once per process; absent under Node, whose `close` event is enough.
+ */
+let handleSymbol;
+function bunHandleAborted(res) {
+    if (handleSymbol === undefined)
+        handleSymbol = Object.getOwnPropertySymbols(res).find((s) => s.description === 'handle') ?? null;
+    if (handleSymbol === null)
+        return false;
+    const handle = res[handleSymbol];
+    return typeof handle === 'object' && handle !== null && handle.aborted === true;
+}
+/** Whether the client of this request has already gone away, on either runtime. */
+export function requestAborted(req, res) {
+    return req.socket?.destroyed === true || bunHandleAborted(res);
+}
+/**
+ * An `AbortSignal` that fires when the client disconnects before the answer is complete. Node says
+ * so with `close` on the response; under Bun that event never comes for a request whose answer has
+ * not started, so the request is also polled while it waits (ADR
+ * 2026-09-22-detect-a-client-that-hangs-up-before-the-answer-under-bun).
+ */
+export function clientGone(ex, pollMs = CLIENT_GONE_POLL_MS) {
+    const controller = new AbortController();
+    const timer = setInterval(() => {
+        if (!requestAborted(ex.req, ex.res))
+            return;
+        clearInterval(timer);
+        if (!ex.res.writableFinished)
+            controller.abort();
+    }, pollMs);
+    timer.unref();
+    ex.res.once('finish', () => clearInterval(timer));
+    ex.res.once('close', () => {
+        clearInterval(timer);
+        if (!ex.res.writableFinished)
+            controller.abort();
+    });
+    return controller.signal;
+}
+/** `serde_json` would reject this body; the proxy answers with its own wording. */
+export function invalidJsonMessage(e) {
+    return `Invalid JSON body: ${e.message}`;
+}
+//# sourceMappingURL=exchange.js.map

package/dist/server/public/exchange.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exchange.js","sourceRoot":"","sources":["../../../src/server/public/exchange.ts"],"names":[],"mappings":"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"}

package/dist/server/public/forward.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The model-bearing POST routes: `/chat/completions`, `/completions`, `/embeddings`,
+ * `/messages/count_tokens` and Anthropic `/messages`. Picks the backend from the body's `model`,
+ * forwards the request, and handles what can go wrong on the way back.
+ *
+ * Ported from: src-tauri/src/core/server/proxy.rs (`inner_proxy_request` from the model lookup to
+ * the end, `retry_local_upstream`, `transform_and_forward_stream`, `forward_non_streaming`).
+ *
+ * The recovery paths, in the order they are tried:
+ * - `/messages` that the engine rejects is retried as `/chat/completions` and the answer translated
+ *   back, because most local engines do not speak the Anthropic API;
+ * - a local context overflow asks the runtime for a larger context and replays the request once;
+ * - a poisoned compute backend (a Metal OOM) gets a same-context reload and a clear, non-retryable
+ *   400 — replaying the request would only poison the fresh backend again;
+ * - a non-streamed 200 cut off by the context window (`finish_reason: length` with no client cap)
+ *   is grown and replayed like an overflow;
+ * - a local engine's unstructured error is wrapped in an OpenAI error envelope.
+ *
+ * One deliberate difference from the Rust: a remote provider's configured custom headers are sent.
+ * The app stored them but the proxy never applied them (recorded as `known_divergence` in the
+ * proxy-http fixtures).
+ */
+import type { JsonValue } from '../shims/index.js';
+import type { RemoteProvider } from '../../router/index.js';
+import type { Exchange } from './exchange.js';
+import type { LocalTarget } from './types.js';
+import type { HeaderPairs } from './wire.js';
+export type Backend = {
+    kind: 'remote';
+    provider: RemoteProvider;
+} | {
+    kind: 'local';
+    session: LocalTarget;
+};
+/** The first local session serving `modelId`, in the proxy's provider order. */
+export declare function findLocalSession(ex: Exchange, modelId: string): LocalTarget | undefined;
+/** The request body parsed, with the `model` it names; `undefined` once an error has been answered. */
+export declare function readModelRequest(ex: Exchange): Promise<{
+    raw: Buffer;
+    json: JsonValue;
+    modelId: string;
+    stream: boolean;
+} | undefined>;
+/**
+ * Headers for a request to a remote provider or a local engine: the client's own minus `exclude`,
+ * then the provider's custom headers (replacing a client header of the same name), then the bearer.
+ * `key === undefined` sends no `Authorization` at all; a local session always has a key, even an
+ * empty one, and the proxy sends it as-is.
+ */
+export declare function outboundHeaders(ex: Exchange, exclude: readonly string[], backend: Backend, key: string | undefined, leading?: HeaderPairs): HeaderPairs;
+/** One SSE frame named after the event's `type`, as the proxy writes Anthropic events. */
+export declare function sseEvent(event: JsonValue): string;
+export declare function serveForward(ex: Exchange): Promise<void>;

package/dist/server/public/forward.js

@@ -0,0 +1,448 @@
+/**
+ * The model-bearing POST routes: `/chat/completions`, `/completions`, `/embeddings`,
+ * `/messages/count_tokens` and Anthropic `/messages`. Picks the backend from the body's `model`,
+ * forwards the request, and handles what can go wrong on the way back.
+ *
+ * Ported from: src-tauri/src/core/server/proxy.rs (`inner_proxy_request` from the model lookup to
+ * the end, `retry_local_upstream`, `transform_and_forward_stream`, `forward_non_streaming`).
+ *
+ * The recovery paths, in the order they are tried:
+ * - `/messages` that the engine rejects is retried as `/chat/completions` and the answer translated
+ *   back, because most local engines do not speak the Anthropic API;
+ * - a local context overflow asks the runtime for a larger context and replays the request once;
+ * - a poisoned compute backend (a Metal OOM) gets a same-context reload and a clear, non-retryable
+ *   400 — replaying the request would only poison the fresh backend again;
+ * - a non-streamed 200 cut off by the context window (`finish_reason: length` with no client cap)
+ *   is grown and replayed like an overflow;
+ * - a local engine's unstructured error is wrapped in an OpenAI error envelope.
+ *
+ * One deliberate difference from the Rust: a remote provider's configured custom headers are sent.
+ * The app stored them but the proxy never applied them (recorded as `known_divergence` in the
+ * proxy-http fixtures).
+ */
+import { AnthropicStreamConverter, anthropicRequestToChat, chatResponseToAnthropic, isJsonObject, serdeToString, } from '../shims/index.js';
+import { LOCAL_SEARCH_ORDER, resolveRemoteProvider } from '../../router/index.js';
+import { captureReport, inferenceFailureReport } from '../../telemetry/index.js';
+import { autoIncreaseCtx } from './ctx.js';
+import { SseLineReader } from './sse.js';
+import { StreamTelemetry, isUsageOnlyChunk, maybeInjectStreamUsage } from './telemetry.js';
+import { endpointFromPath } from './trace.js';
+import { bodyIndicatesOom, computeErrorEnvelope, isComputeBackendError, isContextLimitError, isContextOverflowFinishLength, structureBackendErrorBody, structuredErrorJson, } from './errors.js';
+import { answer, clientGone, connectTimeoutMs, invalidJsonMessage } from './exchange.js';
+import { forwardableHeaders, pipeBody, readBody, readUpstreamText, relay, relayedHeaders, sendUpstream, } from './wire.js';
+/** The first local session serving `modelId`, in the proxy's provider order. */
+export function findLocalSession(ex, modelId) {
+    for (const provider of LOCAL_SEARCH_ORDER) {
+        const session = ex.deps.findLocal(provider, modelId);
+        if (session)
+            return session;
+    }
+    return undefined;
+}
+/** The request body parsed, with the `model` it names; `undefined` once an error has been answered. */
+export async function readModelRequest(ex) {
+    const trace = ex.trace;
+    trace.endpoint = endpointFromPath(ex.path);
+    let raw;
+    try {
+        raw = ex.body ?? (await readBody(ex.req));
+    }
+    catch {
+        trace.errorKind = 'bad_request';
+        answer(ex, 500, 'Failed to read request body');
+        return undefined;
+    }
+    let json;
+    try {
+        json = JSON.parse(raw.toString('utf8'));
+    }
+    catch (e) {
+        trace.errorKind = 'bad_request';
+        answer(ex, 400, invalidJsonMessage(e));
+        return undefined;
+    }
+    const model = isJsonObject(json) ? json['model'] : undefined;
+    const stream = isJsonObject(json) && json['stream'] === true;
+    trace.stream = stream;
+    trace.modelId = typeof model === 'string' ? model : null;
+    trace.announce(json, raw);
+    if (typeof model !== 'string') {
+        trace.errorKind = 'bad_request';
+        answer(ex, 400, "Request body must contain a 'model' field");
+        return undefined;
+    }
+    return { raw, json, modelId: model, stream };
+}
+/**
+ * Headers for a request to a remote provider or a local engine: the client's own minus `exclude`,
+ * then the provider's custom headers (replacing a client header of the same name), then the bearer.
+ * `key === undefined` sends no `Authorization` at all; a local session always has a key, even an
+ * empty one, and the proxy sends it as-is.
+ */
+export function outboundHeaders(ex, exclude, backend, key, leading = []) {
+    let headers = [...leading, ...forwardableHeaders(ex.req, exclude)];
+    if (backend.kind === 'remote') {
+        for (const { header, value } of backend.provider.customHeaders) {
+            const lower = header.toLowerCase();
+            headers = headers.filter(([name]) => name.toLowerCase() !== lower);
+            headers.push([header, value]);
+        }
+    }
+    if (key !== undefined) {
+        headers = headers.filter(([name]) => name.toLowerCase() !== 'authorization');
+        headers.push(['Authorization', `Bearer ${key}`]);
+    }
+    return headers;
+}
+function isSuccess(status) {
+    return status >= 200 && status < 300;
+}
+/** One SSE frame named after the event's `type`, as the proxy writes Anthropic events. */
+export function sseEvent(event) {
+    const type = isJsonObject(event) && typeof event['type'] === 'string' ? event['type'] : 'message';
+    return `event: ${type}\ndata: ${serdeToString(event)}\n\n`;
+}
+export async function serveForward(ex) {
+    const isMessages = ex.path === '/messages';
+    const parsed = await readModelRequest(ex);
+    if (!parsed)
+        return;
+    const { raw, json, modelId, stream } = parsed;
+    let backend;
+    let url;
+    let key;
+    const remote = resolveRemoteProvider(modelId, ex.deps.providers());
+    const trace = ex.trace;
+    if (remote) {
+        backend = { kind: 'remote', provider: remote };
+        trace.backend = 'remote';
+        trace.provider = remote.provider;
+        key = remote.apiKey ?? undefined;
+        if (remote.baseUrl) {
+            url = isMessages ? `${remote.baseUrl.replace(/\/+$/, '')}/messages` : `${remote.baseUrl}${ex.path}`;
+        }
+    }
+    else {
+        // "Nothing is loaded" (503) and "that model is not loaded" (404) are told apart so a client can
+        // tell a cold server from a typo. `/messages` has always answered 404 for both.
+        if (!isMessages && ex.deps.listLocal().length === 0) {
+            trace.errorKind = 'not_found';
+            answer(ex, 503, 'No models are available');
+            return;
+        }
+        const session = findLocalSession(ex, modelId);
+        if (!session) {
+            trace.errorKind = 'not_found';
+            answer(ex, 404, `No running session found for model '${modelId}'`);
+            return;
+        }
+        backend = { kind: 'local', session };
+        trace.backend = session.provider;
+        key = session.apiKey;
+        url = `http://127.0.0.1:${session.port}/v1${ex.path}`;
+    }
+    if (url === undefined) {
+        trace.errorKind = 'proxy_internal';
+        answer(ex, 500, 'Internal routing error');
+        return;
+    }
+    // While the inspector watches, a local streaming chat is asked for real token counts. Only local
+    // backends: a remote provider that rejects unknown fields would turn diagnostics into an outage.
+    const injected = trace.inspecting && stream && ex.path === '/chat/completions' && backend.kind === 'local'
+        ? maybeInjectStreamUsage(raw)
+        : undefined;
+    const signal = clientGone(ex);
+    let response;
+    try {
+        response = await sendUpstream(url, {
+            method: ex.method,
+            headers: outboundHeaders(ex, ['host', 'authorization'], backend, key),
+            body: injected ?? raw,
+            connectTimeoutMs: connectTimeoutMs(ex),
+            signal,
+        });
+    }
+    catch (e) {
+        if (signal.aborted)
+            return;
+        answerUnreachable(ex, backend, e);
+        return;
+    }
+    if (!isSuccess(response.status)) {
+        if (isMessages)
+            await messagesFallback(ex, backend, url, key, json, response);
+        else
+            await upstreamError(ex, backend, modelId, raw, response);
+        return;
+    }
+    if (!stream && backend.kind === 'local') {
+        await inspectFinish(ex, backend.session, modelId, raw, response);
+        return;
+    }
+    await relayObserved(ex, response, injected !== undefined);
+}
+/** The largest non-SSE body kept for telemetry: a chat completion envelope, not an arbitrary file. */
+const NON_SSE_CAPTURE_LIMIT = 256 * 1024;
+/**
+ * Relay the upstream answer; while the inspector watches, fold what streams past into telemetry and
+ * drop the usage-only trailer this proxy asked for itself — the client never opted into an extra chunk
+ * with empty `choices`, and some clients throw on one. The bytes otherwise pass unchanged.
+ */
+async function relayObserved(ex, upstream, stripUsageTrailer) {
+    const telemetry = ex.trace.startTelemetry();
+    if (!telemetry)
+        return relay(ex.res, upstream, ex.cors);
+    const trace = ex.trace;
+    const sse = (upstream.contentType ?? '').startsWith('text/event-stream');
+    ex.res.writeHead(upstream.status, relayedHeaders(upstream, ex.cors).flat());
+    async function* observed() {
+        const reader = new SseLineReader();
+        let captured = 0;
+        let droppingTrailer = false;
+        for await (const chunk of upstream.body) {
+            if (!sse) {
+                if (captured < NON_SSE_CAPTURE_LIMIT) {
+                    const take = chunk.subarray(0, NON_SSE_CAPTURE_LIMIT - captured);
+                    reader.push(take);
+                    captured += take.length;
+                }
+                yield chunk;
+                continue;
+            }
+            reader.push(chunk);
+            const forward = [];
+            for (let line = reader.nextLine(); line; line = reader.nextLine()) {
+                if (line.kind === 'data' && line.payload.kind === 'json') {
+                    telemetry?.onJson(line.payload.json, performance.now());
+                    if (stripUsageTrailer && isUsageOnlyChunk(line.payload.json)) {
+                        droppingTrailer = true;
+                        continue;
+                    }
+                }
+                if (droppingTrailer) {
+                    droppingTrailer = false;
+                    // Also swallow the blank line that ended the dropped event.
+                    if (line.kind === 'other' && line.raw.toString('utf8').trim() === '')
+                        continue;
+                }
+                forward.push(line.raw);
+            }
+            if (forward.length > 0)
+                yield Buffer.concat(forward);
+            trace.progress();
+        }
+        const tail = reader.takeTail();
+        if (tail.length === 0)
+            return;
+        if (sse) {
+            yield tail;
+        }
+        else {
+            try {
+                // Non-SSE: the buffer holds the whole document, which has no time to first token.
+                telemetry?.onJson(JSON.parse(tail.toString('utf8')), performance.now());
+                if (telemetry)
+                    telemetry.firstContentAt = undefined;
+            }
+            catch {
+                // not a JSON document
+            }
+        }
+    }
+    await pipeBody(ex.res, observed(), () => upstream.body.destroy());
+}
+/**
+ * A local engine that cannot be reached is down, crashed or still starting: 503 with `Retry-After`,
+ * which clients treat as transient. A remote one that cannot be reached is a real gateway failure.
+ */
+function answerUnreachable(ex, backend, e) {
+    const local = backend.kind === 'local';
+    ex.trace.errorKind = local ? 'local_model_unreachable' : 'remote_provider_error';
+    const body = structuredErrorJson(`The model backend is not reachable: ${e.message}`, 'server_error', local ? 'backend_unavailable' : 'upstream_unreachable');
+    const extra = [['Content-Type', 'application/json']];
+    if (local)
+        extra.push(['Retry-After', '1']);
+    answer(ex, local ? 503 : 502, body, extra);
+}
+/** Replay a request against a reloaded local session; the bearer is omitted when the key is empty. */
+async function retryLocal(ex, port, apiKey, raw) {
+    const headers = forwardableHeaders(ex.req, ['host', 'authorization']);
+    if (apiKey)
+        headers.push(['Authorization', `Bearer ${apiKey}`]);
+    try {
+        const retry = await sendUpstream(`http://127.0.0.1:${port}/v1${ex.path}`, {
+            method: ex.method,
+            headers,
+            body: raw,
+            connectTimeoutMs: connectTimeoutMs(ex),
+            signal: clientGone(ex),
+        });
+        if (isSuccess(retry.status))
+            return retry;
+        retry.body.resume();
+    }
+    catch {
+        // The original error is what the client gets.
+    }
+    return undefined;
+}
+async function growAndRetry(ex, provider, modelId, raw, trigger) {
+    const reloaded = await autoIncreaseCtx(ex.deps, provider, modelId, trigger);
+    if (!reloaded)
+        return false;
+    const retry = await retryLocal(ex, reloaded.port, reloaded.apiKey, raw);
+    if (!retry)
+        return false;
+    await relay(ex.res, retry, ex.cors);
+    return true;
+}
+async function upstreamError(ex, backend, modelId, raw, response) {
+    const errorBody = await readUpstreamText(response);
+    const status = response.status;
+    const trace = ex.trace;
+    const recordFailure = () => {
+        trace.errorKind = backend.kind === 'local' ? 'local_model_error' : 'remote_provider_error';
+        trace.upstreamStatus = status;
+        trace.oomDetected = bodyIndicatesOom(errorBody);
+        trace.ctxOverflowDetected = isContextLimitError(status, errorBody);
+    };
+    if (backend.kind === 'local') {
+        const provider = backend.session.provider;
+        if (isContextLimitError(status, errorBody) && (await growAndRetry(ex, provider, modelId, raw, 'error')))
+            return;
+        if (isComputeBackendError(status, errorBody)) {
+            // Only the llama.cpp upstream runtime understands a same-context reload; the others would
+            // read the request as "grow the context". The outcome does not change this answer.
+            if (provider === 'llamacpp-upstream') {
+                await autoIncreaseCtx(ex.deps, provider, modelId, 'compute_error_recovery');
+            }
+            recordFailure();
+            trace.oomDetected = true;
+            trace.ctxOverflowDetected = false;
+            const oom = bodyIndicatesOom(errorBody);
+            captureReport(ex.deps.errors, inferenceFailureReport({ provider, modelId, status, body: errorBody, compute: true, oom }));
+            answer(ex, 400, computeErrorEnvelope(oom));
+            return;
+        }
+        recordFailure();
+        captureReport(ex.deps.errors, inferenceFailureReport({
+            provider,
+            modelId,
+            status,
+            body: errorBody,
+            compute: false,
+            oom: trace.oomDetected,
+        }));
+        answer(ex, status, structureBackendErrorBody(errorBody, trace.oomDetected, trace.ctxOverflowDetected));
+        return;
+    }
+    // Remote providers already answer with their own structured errors.
+    recordFailure();
+    answer(ex, status, errorBody);
+}
+/**
+ * A non-streamed local answer is read whole so a context-window cut-off can be caught and replayed.
+ * The upstream's headers are consumed with it; the client gets the minimal set for a JSON reply.
+ */
+async function inspectFinish(ex, session, modelId, raw, response) {
+    const bytes = await readBody(response.body).catch(() => Buffer.alloc(0));
+    let parsed;
+    try {
+        parsed = JSON.parse(bytes.toString('utf8'));
+    }
+    catch {
+        parsed = undefined;
+    }
+    if (parsed !== undefined && ex.trace.inspecting) {
+        const telemetry = new StreamTelemetry();
+        telemetry.onJson(parsed, performance.now());
+        ex.trace.stash(telemetry.finishFields(0));
+    }
+    if (parsed !== undefined &&
+        isContextOverflowFinishLength(parsed, raw) &&
+        (await growAndRetry(ex, session.provider, modelId, raw, 'finish_length'))) {
+        return;
+    }
+    answer(ex, response.status, bytes, [['Content-Type', 'application/json']]);
+}
+/**
+ * `/messages` was rejected: retry it as Chat Completions at the same base and translate the answer
+ * back into Anthropic's shape. If the fallback cannot be attempted or cannot be reached, the client
+ * gets the original error; if it answers with an error, the client gets that one.
+ */
+async function messagesFallback(ex, backend, url, key, json, response) {
+    const errorBody = await readUpstreamText(response);
+    const trace = ex.trace;
+    trace.anthropicFallback = true;
+    const errorKind = backend.kind === 'local' ? 'local_model_error' : 'remote_provider_error';
+    const chat = anthropicRequestToChat(json);
+    if (chat !== null) {
+        let base = url;
+        while (base.endsWith('/messages'))
+            base = base.slice(0, -'/messages'.length);
+        base = base.replace(/\/+$/, '');
+        const signal = clientGone(ex);
+        try {
+            const fallback = await sendUpstream(`${base}/chat/completions`, {
+                method: 'POST',
+                headers: outboundHeaders(ex, ['host', 'authorization', 'content-type', 'content-length', 'accept-encoding'], backend, key, [
+                    ['Content-Type', 'application/json'],
+                    ['Accept-Encoding', 'identity'],
+                ]),
+                body: serdeToString(chat),
+                connectTimeoutMs: connectTimeoutMs(ex),
+                signal,
+            });
+            if (!isSuccess(fallback.status)) {
+                const fallbackError = await readUpstreamText(fallback);
+                trace.errorKind = errorKind;
+                trace.upstreamStatus = fallback.status;
+                trace.oomDetected = bodyIndicatesOom(fallbackError);
+                trace.ctxOverflowDetected = isContextLimitError(fallback.status, fallbackError);
+                answer(ex, fallback.status, fallbackError);
+                return;
+            }
+            ex.res.writeHead(fallback.status, relayedHeaders(fallback, ex.cors).flat());
+            const streaming = isJsonObject(chat) && chat['stream'] === true;
+            await pipeBody(ex.res, streaming ? anthropicStream(fallback) : anthropicWhole(fallback), () => fallback.body.destroy());
+            return;
+        }
+        catch {
+            if (signal.aborted)
+                return;
+        }
+    }
+    trace.errorKind = errorKind;
+    trace.upstreamStatus = response.status;
+    trace.oomDetected = bodyIndicatesOom(errorBody);
+    trace.ctxOverflowDetected = isContextLimitError(response.status, errorBody);
+    answer(ex, response.status, errorBody);
+}
+async function* anthropicStream(upstream) {
+    const conv = new AnthropicStreamConverter();
+    const decoder = new TextDecoder();
+    for await (const chunk of upstream.body) {
+        for (const event of conv.onNetworkChunk(decoder.decode(chunk, { stream: true })))
+            yield sseEvent(event);
+        if (conv.done) {
+            upstream.body.destroy();
+            return;
+        }
+    }
+    const tail = decoder.decode();
+    for (const event of [...conv.onNetworkChunk(tail), ...conv.finish()])
+        yield sseEvent(event);
+}
+async function* anthropicWhole(upstream) {
+    const bytes = await readBody(upstream.body);
+    let parsed;
+    try {
+        parsed = JSON.parse(bytes.toString('utf8'));
+    }
+    catch {
+        yield bytes;
+        return;
+    }
+    yield serdeToString(chatResponseToAnthropic(parsed));
+}
+//# sourceMappingURL=forward.js.map