@otto-code/brain 0.7.5

package/dist/service/router.js

@@ -0,0 +1,746 @@
+import http from "node:http";
+import { Scheduler } from "./scheduler.js";
+import { makeVramFitPredicate, selectCodingModel } from "./model-selector.js";
+import { query as queryGpu } from "../gpu.js";
+import { rankModels } from "../ops/results.js";
+/**
+ * Fronts the supervised llama-server on a stable port.
+ *
+ * Three jobs beyond plain proxying:
+ *  1. While a model is loading or swapping, answer with a clear 503 instead of
+ *     a connection refused, so clients can retry rather than error out.
+ *  2. Watch completions for the failure this whole project exists to prevent:
+ *     a response whose tokens went entirely into reasoning, leaving no content.
+ *  3. Serve `/v1/models` (and LM Studio's `/api/v0/models`) ourselves instead of
+ *     passing it through. Raw llama-server reports only the loaded model, with
+ *     its *full file path* as the id and none of the metadata LM Studio clients
+ *     read (context length, quant, arch, state). We instead list the whole
+ *     catalog (via the injected `getCatalog`), mark the running one 'loaded',
+ *     and give each a friendly name plus the context fields clients size against.
+ */
+const HOP_BY_HOP = new Set([
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade",
+]);
+const MAX_ANALYSIS_BYTES = 2 * 1024 * 1024;
+// Completion bodies are buffered so the scheduler can read `model` and replay
+// them after a possible model switch. Long-context prompts are large but bounded.
+const MAX_REQUEST_BYTES = 64 * 1024 * 1024;
+const COMPLETION_RE = /\/v1\/(messages|chat\/completions)/;
+export class Telemetry {
+    constructor(keep = 50) {
+        this.keep = keep;
+        this.records = [];
+        this.totals = { requests: 0, ok: 0, reasoningOnly: 0, truncated: 0, failed: 0 };
+    }
+    record(entry) {
+        this.totals.requests += 1;
+        if (entry.verdict === "reasoning-only")
+            this.totals.reasoningOnly += 1;
+        else if (entry.verdict === "truncated")
+            this.totals.truncated += 1;
+        else if (entry.verdict === "failed")
+            this.totals.failed += 1;
+        else
+            this.totals.ok += 1;
+        this.records.push(entry);
+        if (this.records.length > this.keep)
+            this.records.shift();
+    }
+    /** Advice derived from observed behaviour, not guesswork. */
+    get warning() {
+        const { requests, reasoningOnly, truncated } = this.totals;
+        if (requests < 3)
+            return null;
+        if (reasoningOnly / requests > 0.3) {
+            return `${reasoningOnly}/${requests} responses spent all tokens on reasoning and returned no content - lower the reasoning budget`;
+        }
+        if (truncated / requests > 0.3) {
+            return `${truncated}/${requests} responses hit the token limit - raise the client's max_tokens`;
+        }
+        return null;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function asStringOrNull(value) {
+    return typeof value === "string" ? value : null;
+}
+function strlen(value) {
+    return String(value || "").length;
+}
+function readTokens(usage, key) {
+    if (!isRecord(usage))
+        return null;
+    const value = usage[key];
+    return typeof value === "number" ? value : null;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** Classify a completion body (Anthropic or OpenAI shaped). */
+export function analyse(bodyText) {
+    let parsed;
+    try {
+        parsed = JSON.parse(bodyText);
+    }
+    catch {
+        return null;
+    }
+    let finishReason = null;
+    let contentChars = 0;
+    let reasoningChars = 0;
+    let outputTokens = null;
+    let toolCalls = 0;
+    if (isRecord(parsed) && Array.isArray(parsed.content)) {
+        // Anthropic /v1/messages
+        finishReason = asStringOrNull(parsed.stop_reason);
+        outputTokens = readTokens(parsed.usage, "output_tokens");
+        for (const block of parsed.content) {
+            if (!isRecord(block))
+                continue;
+            if (block.type === "text")
+                contentChars += strlen(block.text);
+            else if (block.type === "thinking")
+                reasoningChars += strlen(block.thinking);
+            else if (block.type === "tool_use")
+                toolCalls += 1;
+        }
+    }
+    else if (isRecord(parsed) && Array.isArray(parsed.choices)) {
+        // OpenAI /v1/chat/completions
+        const first = parsed.choices[0];
+        const choice = isRecord(first) ? first : {};
+        finishReason = asStringOrNull(choice.finish_reason);
+        outputTokens = readTokens(parsed.usage, "completion_tokens");
+        const msg = isRecord(choice.message) ? choice.message : {};
+        contentChars = strlen(msg.content);
+        reasoningChars = strlen(msg.reasoning_content);
+        toolCalls = Array.isArray(msg.tool_calls) ? msg.tool_calls.length : 0;
+    }
+    else {
+        return null;
+    }
+    let verdict = "ok";
+    if (contentChars === 0 && toolCalls === 0 && reasoningChars > 0)
+        verdict = "reasoning-only";
+    else if (finishReason === "length" || finishReason === "max_tokens")
+        verdict = "truncated";
+    return { finishReason, contentChars, reasoningChars, outputTokens, toolCalls, verdict };
+}
+function errorBody(status, message) {
+    return JSON.stringify({
+        type: "error",
+        error: { type: status === 503 ? "overloaded_error" : "api_error", message },
+    });
+}
+export function describeModel(model, options = {}) {
+    if (!model)
+        return null;
+    const { state = "not-loaded", profile = null, createdAt = null } = options;
+    const md = model.metadata || {};
+    const entry = {
+        // Standard OpenAI fields — id is the friendly name, never the file path.
+        id: model.displayName,
+        object: "model",
+        created: Math.floor((createdAt ? createdAt.getTime() : Date.now()) / 1000),
+        owned_by: model.publisher || "local",
+        // LM Studio enrichment.
+        type: model.mmprojPath ? "vlm" : "llm",
+        publisher: model.publisher || null,
+        arch: md.arch || null,
+        compatibility_type: "gguf",
+        quantization: model.quant || null,
+        state,
+        max_context_length: md.contextLength ?? null,
+    };
+    if (state === "loaded" && profile && profile.contextSize) {
+        // llama-server splits -c across --parallel slots, so the window a single
+        // request actually gets is the total divided by the concurrency.
+        const slots = Math.max(1, profile.parallelSlots || 1);
+        entry.loaded_context_length = Math.floor(profile.contextSize / slots);
+    }
+    return entry;
+}
+function resolveCatalog(getCatalog) {
+    try {
+        return (typeof getCatalog === "function" ? getCatalog() : getCatalog) || [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Build the LM Studio-style catalog: every model found on disk, with the one
+ * the supervisor is running marked 'loaded'. Falls back to just the running
+ * model when no catalog provider is wired in.
+ */
+export function buildModelList(supervisor, getCatalog) {
+    const loadedId = supervisor.model ? supervisor.model.id : null;
+    const stateOf = (model) => {
+        if (!loadedId || model.id !== loadedId)
+            return "not-loaded";
+        if (supervisor.state === "ready")
+            return "loaded";
+        if (supervisor.state === "starting")
+            return "loading";
+        return "not-loaded";
+    };
+    let catalog = resolveCatalog(getCatalog);
+    // Guarantee the running model appears even if the snapshot predates it.
+    if (supervisor.model && !catalog.some((m) => m.id === loadedId)) {
+        catalog = [supervisor.model, ...catalog];
+    }
+    return catalog.map((model) => describeModel(model, {
+        state: stateOf(model),
+        profile: model.id === loadedId ? supervisor.profile : null,
+        createdAt: model.id === loadedId ? supervisor.startedAt : null,
+    }));
+}
+/** Handle the model-discovery endpoints ourselves; returns true if it did. */
+function handleModelsRoute(req, res, supervisor, getCatalog) {
+    if (req.method !== "GET")
+        return false;
+    const url = (req.url || "").split("?")[0];
+    const isList = url === "/v1/models" || url === "/api/v0/models";
+    const single = url.startsWith("/v1/models/")
+        ? decodeURIComponent(url.slice("/v1/models/".length))
+        : null;
+    if (!isList && single === null)
+        return false;
+    const list = buildModelList(supervisor, getCatalog);
+    let payload;
+    if (single !== null) {
+        const entry = list.find((e) => e.id === single);
+        if (!entry) {
+            const body = errorBody(404, `model "${single}" was not found`);
+            res.writeHead(404, {
+                "content-type": "application/json",
+                "content-length": Buffer.byteLength(body),
+            });
+            res.end(body);
+            return true;
+        }
+        payload = entry;
+    }
+    else {
+        payload = { object: "list", data: list };
+    }
+    const body = JSON.stringify(payload);
+    res.writeHead(200, {
+        "content-type": "application/json",
+        "content-length": Buffer.byteLength(body),
+    });
+    res.end(body);
+    return true;
+}
+function sendError(res, status, message) {
+    if (res.headersSent) {
+        if (!res.writableEnded)
+            res.destroy();
+        return;
+    }
+    const body = errorBody(status, message);
+    const headers = {
+        "content-type": "application/json",
+        "content-length": Buffer.byteLength(body),
+    };
+    if (status === 503)
+        headers["retry-after"] = "5";
+    res.writeHead(status, headers);
+    res.end(body);
+}
+/**
+ * Forward a buffered completion body to the resident llama-server and stream the
+ * reply back, teeing non-streaming bodies for classification. Resolves once the
+ * client response is fully concluded (it owns the response in every outcome,
+ * including upstream errors), so the scheduler can move to the next turn.
+ */
+function proxyBuffered({ agent, supervisor, telemetry, logger, req, res, body, }) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const done = () => {
+            if (!settled) {
+                settled = true;
+                resolve();
+            }
+        };
+        const headers = {};
+        for (const [name, value] of Object.entries(req.headers)) {
+            if (!HOP_BY_HOP.has(name.toLowerCase()))
+                headers[name] = value;
+        }
+        headers.host = `${supervisor.host}:${supervisor.internalPort}`;
+        headers["content-length"] = Buffer.byteLength(body);
+        const started = Date.now();
+        const upstream = http.request({
+            host: supervisor.host,
+            port: supervisor.internalPort,
+            path: req.url,
+            method: req.method,
+            headers,
+            agent,
+        }, (upstreamRes) => {
+            const outHeaders = {};
+            for (const [name, value] of Object.entries(upstreamRes.headers)) {
+                if (!HOP_BY_HOP.has(name.toLowerCase()))
+                    outHeaders[name] = value;
+            }
+            res.writeHead(upstreamRes.statusCode ?? 502, outHeaders);
+            const isStream = String(upstreamRes.headers["content-type"] || "").includes("event-stream");
+            if (isStream) {
+                let sawContent = false;
+                let sawReasoning = false;
+                upstreamRes.on("data", (chunk) => {
+                    const text = String(chunk);
+                    if (text.includes('"text_delta"') || /"content"\s*:\s*"[^"]/.test(text))
+                        sawContent = true;
+                    if (text.includes("thinking") || text.includes("reasoning"))
+                        sawReasoning = true;
+                });
+                upstreamRes.on("end", () => {
+                    telemetry.record({
+                        at: new Date().toISOString(),
+                        path: req.url,
+                        ms: Date.now() - started,
+                        streamed: true,
+                        verdict: !sawContent && sawReasoning ? "reasoning-only" : "ok",
+                    });
+                    done();
+                });
+                upstreamRes.pipe(res);
+                return;
+            }
+            const chunks = [];
+            let size = 0;
+            upstreamRes.on("data", (chunk) => {
+                if (size < MAX_ANALYSIS_BYTES) {
+                    chunks.push(chunk);
+                    size += chunk.length;
+                }
+                if (!res.writableEnded && !res.destroyed)
+                    res.write(chunk);
+            });
+            upstreamRes.on("end", () => {
+                if (!res.writableEnded && !res.destroyed)
+                    res.end();
+                const analysis = analyse(Buffer.concat(chunks).toString("utf8"));
+                const entry = {
+                    at: new Date().toISOString(),
+                    path: req.url,
+                    ms: Date.now() - started,
+                    streamed: false,
+                    ...(analysis ?? { verdict: "ok" }),
+                };
+                telemetry.record(entry);
+                if (entry.verdict === "reasoning-only") {
+                    logger?.warn?.(`reasoning-only response: ${entry.outputTokens} tokens, ${entry.reasoningChars} reasoning chars, 0 content`);
+                }
+                done();
+            });
+        });
+        res.on("close", () => {
+            if (!res.writableFinished && !upstream.destroyed)
+                upstream.destroy();
+        });
+        res.on("error", () => {
+            if (!upstream.destroyed)
+                upstream.destroy();
+        });
+        upstream.on("error", (error) => {
+            telemetry.record({
+                at: new Date().toISOString(),
+                path: req.url,
+                verdict: "failed",
+                error: error.message,
+            });
+            sendError(res, 502, `Upstream llama-server error: ${error.message}`);
+            done();
+        });
+        upstream.end(body);
+    });
+}
+/**
+ * Pure model-admission decision, factored out of the router so it is unit
+ * testable. `pinned` is the single model a locked host serves; `resolved` is the
+ * normal catalog resolution used when the lock is off. With the lock on, a
+ * request naming a model other than the pin is refused (409) rather than queuing
+ * a switch; an unnamed request rides the pin.
+ */
+export function decideModelGate(params) {
+    const { lockModel, requestedName, pinned, resolved } = params;
+    if (lockModel) {
+        if (!pinned) {
+            return { ok: false, status: 503, message: "no model is loaded yet on this locked host" };
+        }
+        if (requestedName && requestedName !== pinned.id && requestedName !== pinned.displayName) {
+            return {
+                ok: false,
+                status: 409,
+                message: `model switching is disabled on this host; only "${pinned.displayName}" is served`,
+            };
+        }
+        return { ok: true, model: pinned };
+    }
+    if (!resolved) {
+        return {
+            ok: false,
+            status: requestedName ? 404 : 503,
+            message: requestedName
+                ? `model "${requestedName}" was not found in the catalog`
+                : "no model is available to serve",
+        };
+    }
+    return { ok: true, model: resolved };
+}
+/** Buffer a bounded JSON request body (for POST /__host/config). */
+function readJsonBody(req, limit, cb) {
+    const chunks = [];
+    let size = 0;
+    let tooBig = false;
+    req.on("data", (chunk) => {
+        size += chunk.length;
+        if (size > limit)
+            tooBig = true;
+        else
+            chunks.push(chunk);
+    });
+    req.on("error", () => cb({ ok: false, error: "request stream error" }));
+    req.on("end", () => {
+        if (tooBig) {
+            cb({ ok: false, error: "request body too large" });
+            return;
+        }
+        try {
+            const text = Buffer.concat(chunks).toString("utf8") || "{}";
+            cb({ ok: true, body: JSON.parse(text) });
+        }
+        catch {
+            cb({ ok: false, error: "invalid JSON body" });
+        }
+    });
+}
+/** Buffer a completion request, resolve its target model, and queue it. */
+function scheduleCompletion({ req, res, agent, supervisor, telemetry, logger, scheduler, modelGate, }) {
+    const chunks = [];
+    let size = 0;
+    let tooBig = false;
+    req.on("data", (chunk) => {
+        size += chunk.length;
+        if (size > MAX_REQUEST_BYTES)
+            tooBig = true;
+        else
+            chunks.push(chunk);
+    });
+    req.on("error", () => {
+        /* client vanished before we could queue it */
+    });
+    req.on("end", () => {
+        if (tooBig) {
+            sendError(res, 413, "request body too large");
+            return;
+        }
+        const body = Buffer.concat(chunks);
+        let modelName = null;
+        try {
+            const parsed = JSON.parse(body.toString("utf8"));
+            modelName = isRecord(parsed) && typeof parsed.model === "string" ? parsed.model : null;
+        }
+        catch {
+            /* leave null */
+        }
+        const gate = modelGate(modelName);
+        if (!gate.ok) {
+            sendError(res, gate.status, gate.message);
+            return;
+        }
+        const model = gate.model;
+        scheduler
+            .submit(model, () => proxyBuffered({ agent, supervisor, telemetry, logger, req, res, body }))
+            .catch((error) => sendError(res, 502, `could not serve ${model.displayName}: ${errorMessage(error)}`));
+    });
+}
+// The bench ranking is read from disk (one JSON per run). A completion request
+// must not pay that IO, and rankings only change when a bench run finishes
+// (rare), so the router caches the ranking and re-reads it at most once per
+// window — the cheap time-based trigger.
+const RANKING_TTL_MS = 60000;
+export function createRouter({ supervisor, telemetry, logger, getCatalog = null, loadModel = null, loadRanking = () => rankModels(), queryGpuInfo = queryGpu, version = null, getConfig = null, getEvals = null, getLockModel = () => false, getDefaultModel = () => null, applyConfigPatch = null, getAllowConfigWrite = () => false, }) {
+    const agent = new http.Agent({ keepAlive: true, maxSockets: 32 });
+    const scheduler = loadModel
+        ? new Scheduler({ supervisor, loadModel, logger: (m) => logger?.warn?.(m) })
+        : null;
+    // GPU total VRAM is static hardware, so it is queried once at startup and
+    // cached. Absent (no nvidia-smi) or not-yet-resolved leaves the fit predicate
+    // undefined, and the selector skips the VRAM filter — mirroring serve.ts.
+    let fitPredicate;
+    void (async () => {
+        try {
+            fitPredicate = makeVramFitPredicate(await queryGpuInfo());
+        }
+        catch {
+            /* GPU info absent → skip the fit filter */
+        }
+    })();
+    // TTL-cached bench ranking (see RANKING_TTL_MS above).
+    let rankingCache = [];
+    let rankingAt = 0;
+    const getRanking = () => {
+        const now = Date.now();
+        if (now - rankingAt < RANKING_TTL_MS && rankingAt !== 0)
+            return rankingCache;
+        try {
+            rankingCache = loadRanking();
+        }
+        catch {
+            /* keep the last good ranking (or the empty default) on a read error */
+        }
+        rankingAt = now;
+        return rankingCache;
+    };
+    const resolveModel = (name) => {
+        const catalog = resolveCatalog(getCatalog);
+        if (name) {
+            const hit = catalog.find((m) => m.displayName === name || m.id === name);
+            if (hit)
+                return hit;
+            if (supervisor.model &&
+                (supervisor.model.displayName === name || supervisor.model.id === name)) {
+                return supervisor.model;
+            }
+            return null;
+        }
+        // No model named: pick the best-ranked coding model that fits the VRAM
+        // budget, instead of blindly serving whatever is loaded. The existing
+        // default (loaded model, else catalog[0]) is the fallback when no candidate
+        // survives, and the loaded model is a tiebreak so equal-scored picks do not
+        // trigger a needless swap.
+        const fallback = supervisor.model || catalog[0] || null;
+        return selectCodingModel({
+            models: catalog,
+            ranking: getRanking(),
+            fits: fitPredicate,
+            preferLoadedId: supervisor.model?.id ?? null,
+            fallback,
+        });
+    };
+    // The single model this host will serve when switching is locked: the
+    // resident model if one is up, else the configured default resolved through
+    // the catalog. Null means nothing is loadable yet.
+    const pinnedModel = () => {
+        if (supervisor.model)
+            return supervisor.model;
+        const def = getDefaultModel();
+        return def ? resolveModel(def) : null;
+    };
+    // Decide whether a completion for `name` may run. The lock/default are read
+    // live so a POST /__host/config change takes effect without a restart. Only
+    // resolve the branch the lock actually uses.
+    const modelGate = (name) => {
+        const lock = getLockModel();
+        return decideModelGate({
+            lockModel: lock,
+            requestedName: name,
+            pinned: lock ? pinnedModel() : null,
+            resolved: lock ? null : resolveModel(name),
+        });
+    };
+    const sendJson = (res, payload) => {
+        const body = JSON.stringify(payload, null, 2);
+        res.writeHead(200, {
+            "content-type": "application/json",
+            "content-length": Buffer.byteLength(body),
+        });
+        res.end(body);
+    };
+    return function handler(req, res) {
+        // Host-management read surface (`/__host/*`): the single API both the TUI and
+        // Otto's GUI consume, so the two never drift. Status is live; config and
+        // evals are point-in-time reads the daemon proxies to its settings UI.
+        if (req.url === "/__host/status") {
+            sendJson(res, {
+                version,
+                ...supervisor.status(),
+                telemetry: { ...telemetry.totals, warning: telemetry.warning },
+                scheduler: scheduler ? scheduler.stats() : null,
+                recent: telemetry.records.slice(-10),
+            });
+            return;
+        }
+        // Config write: apply an editable patch (model/lock live, the rest persisted).
+        // Must precede the GET read below, which matches the same URL for any method.
+        // Refused unless the owner opted into remote configuration.
+        if (req.method === "POST" && req.url === "/__host/config") {
+            if (!applyConfigPatch || !getAllowConfigWrite()) {
+                sendError(res, 403, "remote configuration is disabled on this brain");
+                return;
+            }
+            readJsonBody(req, MAX_REQUEST_BYTES, (result) => {
+                if (!result.ok) {
+                    sendError(res, 400, result.error);
+                    return;
+                }
+                applyConfigPatch(result.body)
+                    .then((cfg) => sendJson(res, cfg))
+                    .catch((err) => sendError(res, 500, `could not apply config: ${errorMessage(err)}`));
+            });
+            return;
+        }
+        if (req.url === "/__host/config" && getConfig) {
+            sendJson(res, getConfig());
+            return;
+        }
+        if (req.url === "/__host/evals" && getEvals) {
+            sendJson(res, getEvals());
+            return;
+        }
+        // Answer model discovery ourselves so ids are real names (not paths), the
+        // whole catalog is listed, and each carries LM Studio's context fields.
+        if (handleModelsRoute(req, res, supervisor, getCatalog))
+            return;
+        // With a scheduler wired in, completion requests are queued and served in
+        // turns — including loading/switching to the model they ask for — instead
+        // of failing when it is not the resident one.
+        if (scheduler && COMPLETION_RE.test(req.url || "")) {
+            scheduleCompletion({
+                req,
+                res,
+                agent,
+                supervisor,
+                telemetry,
+                logger,
+                scheduler,
+                modelGate,
+            });
+            return;
+        }
+        if (supervisor.state !== "ready") {
+            const detail = supervisor.state === "starting"
+                ? `The model is still loading (${supervisor.model?.displayName ?? "unknown"}). Retry shortly.`
+                : `No model is currently loaded (state: ${supervisor.state}).${supervisor.lastError ? ` Last error: ${supervisor.lastError}` : ""}`;
+            const body = errorBody(503, detail);
+            res.writeHead(503, {
+                "content-type": "application/json",
+                "content-length": Buffer.byteLength(body),
+                "retry-after": "5",
+            });
+            res.end(body);
+            return;
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(req.headers)) {
+            if (!HOP_BY_HOP.has(name.toLowerCase()))
+                headers[name] = value;
+        }
+        headers.host = `${supervisor.host}:${supervisor.internalPort}`;
+        const started = Date.now();
+        const upstream = http.request({
+            host: supervisor.host,
+            port: supervisor.internalPort,
+            path: req.url,
+            method: req.method,
+            headers,
+            agent,
+        }, (upstreamRes) => {
+            const outHeaders = {};
+            for (const [name, value] of Object.entries(upstreamRes.headers)) {
+                if (!HOP_BY_HOP.has(name.toLowerCase()))
+                    outHeaders[name] = value;
+            }
+            res.writeHead(upstreamRes.statusCode ?? 502, outHeaders);
+            const isCompletion = /\/v1\/(messages|chat\/completions)/.test(req.url || "");
+            const isStream = String(upstreamRes.headers["content-type"] || "").includes("event-stream");
+            if (!isCompletion || isStream) {
+                // Streaming: pass through untouched, but note whether any content
+                // delta ever arrived so a reasoning-only stream is still visible.
+                let sawContent = false;
+                let sawReasoning = false;
+                if (isCompletion) {
+                    upstreamRes.on("data", (chunk) => {
+                        const text = String(chunk);
+                        if (text.includes('"text_delta"') || /"content"\s*:\s*"[^"]/.test(text))
+                            sawContent = true;
+                        if (text.includes("thinking") || text.includes("reasoning"))
+                            sawReasoning = true;
+                    });
+                    upstreamRes.on("end", () => {
+                        telemetry.record({
+                            at: new Date().toISOString(),
+                            path: req.url,
+                            ms: Date.now() - started,
+                            streamed: true,
+                            verdict: !sawContent && sawReasoning ? "reasoning-only" : "ok",
+                        });
+                    });
+                }
+                upstreamRes.pipe(res);
+                return;
+            }
+            // Non-streaming completion: tee the body so we can classify it.
+            const chunks = [];
+            let size = 0;
+            upstreamRes.on("data", (chunk) => {
+                if (size < MAX_ANALYSIS_BYTES) {
+                    chunks.push(chunk);
+                    size += chunk.length;
+                }
+                if (!res.writableEnded && !res.destroyed)
+                    res.write(chunk);
+            });
+            upstreamRes.on("end", () => {
+                if (!res.writableEnded && !res.destroyed)
+                    res.end();
+                const analysis = analyse(Buffer.concat(chunks).toString("utf8"));
+                const entry = {
+                    at: new Date().toISOString(),
+                    path: req.url,
+                    ms: Date.now() - started,
+                    streamed: false,
+                    ...(analysis ?? { verdict: "ok" }),
+                };
+                telemetry.record(entry);
+                if (entry.verdict === "reasoning-only") {
+                    logger?.warn(`reasoning-only response: ${entry.outputTokens} tokens, ${entry.reasoningChars} reasoning chars, 0 content`);
+                }
+            });
+        });
+        res.on("close", () => {
+            if (!res.writableFinished && !upstream.destroyed)
+                upstream.destroy();
+        });
+        // A broken client socket makes the response stream emit 'error'. Without a
+        // listener Node rethrows it as uncaught and takes the whole host down, so
+        // absorb it and tear the upstream request down.
+        res.on("error", () => {
+            if (!upstream.destroyed)
+                upstream.destroy();
+        });
+        upstream.on("error", (error) => {
+            telemetry.record({
+                at: new Date().toISOString(),
+                path: req.url,
+                verdict: "failed",
+                error: error.message,
+            });
+            if (res.headersSent) {
+                res.destroy();
+                return;
+            }
+            const body = errorBody(502, `Upstream llama-server error: ${error.message}`);
+            res.writeHead(502, {
+                "content-type": "application/json",
+                "content-length": Buffer.byteLength(body),
+            });
+            res.end(body);
+        });
+        req.pipe(upstream);
+    };
+}
+//# sourceMappingURL=router.js.map