waypoi 0.0.0

package/dist/src/routes/audio.js

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAudioRoutes = registerAudioRoutes;
+const crypto_1 = require("crypto");
+const stream_1 = require("stream");
+const router_1 = require("../routing/router");
+const repositories_1 = require("../storage/repositories");
+const scheduler_1 = require("../pools/scheduler");
+const modelRegistry_1 = require("../providers/modelRegistry");
+const requestCapture_1 = require("../middleware/requestCapture");
+async function registerAudioRoutes(app, paths) {
+    // POST /v1/audio/transcriptions (speech-to-text)
+    app.post("/v1/audio/transcriptions", async (req, reply) => {
+        // Multipart form data: file, model, language, prompt, response_format, temperature
+        const body = req.body;
+        const model = body?.model ?? await pickDefaultAudioModel(paths);
+        if (!model) {
+            reply.code(400).send({ error: { message: "No audio model available. Add or enable a provider model." } });
+            return;
+        }
+        const requestId = (0, crypto_1.randomUUID)();
+        const start = Date.now();
+        const controller = new AbortController();
+        req.raw.on("close", () => controller.abort());
+        try {
+            const outcome = await (0, router_1.routeRequest)(paths, model, "/v1/audio/transcriptions", body, req.headers, controller.signal, {
+                endpointType: "audio",
+                requiredInput: ["audio"],
+                requiredOutput: ["text"],
+            });
+            const upstreamBody = await readBody(outcome.attempt.response);
+            setHeaders(reply, outcome.attempt.response.headers);
+            reply.code(outcome.attempt.response.statusCode).send(upstreamBody.payload);
+            (0, requestCapture_1.setCaptureRouting)(reply, {
+                publicModel: model,
+                endpointId: outcome.attempt.endpoint.id,
+                endpointName: outcome.attempt.endpoint.name,
+                upstreamModel: outcome.attempt.upstreamModel,
+            });
+            await (0, repositories_1.logRequest)(paths, buildLog(requestId, model, outcome, Date.now() - start));
+        }
+        catch (error) {
+            const errorType = error.type ?? error.name;
+            (0, requestCapture_1.setCaptureError)(reply, { type: errorType, message: error.message });
+            await (0, repositories_1.logRequest)(paths, {
+                requestId,
+                ts: new Date(),
+                route: { publicModel: model },
+                request: { stream: false },
+                result: { errorType, errorMessage: error.message }
+            });
+            if (errorType === "invalid_request") {
+                reply.code(400).send({ error: { message: error.message } });
+                return;
+            }
+            if (errorType === "tls_verify_failed") {
+                reply.code(502).send({ error: { message: error.message, type: errorType } });
+                return;
+            }
+            const status = errorType === "no_endpoints" ||
+                errorType === "protocol_stream_unsupported" ||
+                errorType === "unsupported_protocol" ||
+                errorType === "invalid_protocol_config"
+                ? 400
+                : errorType === "rate_limited"
+                    ? 429
+                    : 502;
+            reply.code(status).send({ error: { message: "Transcription unavailable", type: errorType } });
+        }
+    });
+    // POST /v1/audio/translations (translation to English)
+    app.post("/v1/audio/translations", async (req, reply) => {
+        const body = req.body;
+        const model = body?.model ?? await pickDefaultAudioModel(paths);
+        if (!model) {
+            reply.code(400).send({ error: { message: "No audio model available. Add or enable a provider model." } });
+            return;
+        }
+        const requestId = (0, crypto_1.randomUUID)();
+        const start = Date.now();
+        const controller = new AbortController();
+        req.raw.on("close", () => controller.abort());
+        try {
+            const outcome = await (0, router_1.routeRequest)(paths, model, "/v1/audio/translations", body, req.headers, controller.signal, {
+                endpointType: "audio",
+                requiredInput: ["audio"],
+                requiredOutput: ["text"],
+            });
+            const upstreamBody = await readBody(outcome.attempt.response);
+            setHeaders(reply, outcome.attempt.response.headers);
+            reply.code(outcome.attempt.response.statusCode).send(upstreamBody.payload);
+            (0, requestCapture_1.setCaptureRouting)(reply, {
+                publicModel: model,
+                endpointId: outcome.attempt.endpoint.id,
+                endpointName: outcome.attempt.endpoint.name,
+                upstreamModel: outcome.attempt.upstreamModel,
+            });
+            await (0, repositories_1.logRequest)(paths, buildLog(requestId, model, outcome, Date.now() - start));
+        }
+        catch (error) {
+            const errorType = error.type ?? error.name;
+            (0, requestCapture_1.setCaptureError)(reply, { type: errorType, message: error.message });
+            await (0, repositories_1.logRequest)(paths, {
+                requestId,
+                ts: new Date(),
+                route: { publicModel: model },
+                request: { stream: false },
+                result: { errorType, errorMessage: error.message }
+            });
+            if (errorType === "invalid_request") {
+                reply.code(400).send({ error: { message: error.message } });
+                return;
+            }
+            if (errorType === "tls_verify_failed") {
+                reply.code(502).send({ error: { message: error.message, type: errorType } });
+                return;
+            }
+            const status = errorType === "no_endpoints" ||
+                errorType === "protocol_stream_unsupported" ||
+                errorType === "unsupported_protocol" ||
+                errorType === "invalid_protocol_config"
+                ? 400
+                : errorType === "rate_limited"
+                    ? 429
+                    : 502;
+            reply.code(status).send({ error: { message: "Translation unavailable", type: errorType } });
+        }
+    });
+    // POST /v1/audio/speech (text-to-speech)
+    app.post("/v1/audio/speech", async (req, reply) => {
+        const body = req.body;
+        if (!body?.input || !body?.voice) {
+            reply.code(400).send({ error: { message: "input and voice are required" } });
+            return;
+        }
+        const model = body.model ?? await pickDefaultTtsModel(paths);
+        if (!model) {
+            reply.code(400).send({ error: { message: "No TTS model available. Add or enable a text-to-audio provider model." } });
+            return;
+        }
+        const requestId = (0, crypto_1.randomUUID)();
+        const start = Date.now();
+        const controller = new AbortController();
+        req.raw.on("close", () => controller.abort());
+        try {
+            const outcome = await (0, router_1.routeRequest)(paths, model, "/v1/audio/speech", { ...body, model }, req.headers, controller.signal, {
+                endpointType: "audio",
+                requiredInput: ["text"],
+                requiredOutput: ["audio"],
+            });
+            // Speech returns binary audio - stream it directly
+            await streamResponse(reply, outcome.attempt.response);
+            (0, requestCapture_1.setCaptureResponseOverride)(reply, {
+                $type: "stream",
+                contentType: normalizeHeaders(outcome.attempt.response.headers)["content-type"] ?? "application/octet-stream",
+                note: "Audio stream captured as metadata",
+            }, outcome.attempt.response.headers);
+            (0, requestCapture_1.setCaptureRouting)(reply, {
+                publicModel: model,
+                endpointId: outcome.attempt.endpoint.id,
+                endpointName: outcome.attempt.endpoint.name,
+                upstreamModel: outcome.attempt.upstreamModel,
+            });
+            await (0, repositories_1.logRequest)(paths, buildLog(requestId, model, outcome, Date.now() - start));
+        }
+        catch (error) {
+            const errorType = error.type ?? error.name;
+            (0, requestCapture_1.setCaptureError)(reply, { type: errorType, message: error.message });
+            await (0, repositories_1.logRequest)(paths, {
+                requestId,
+                ts: new Date(),
+                route: { publicModel: model },
+                request: { stream: false },
+                result: { errorType, errorMessage: error.message }
+            });
+            // Don't try to send error if headers already sent (streaming started)
+            if (reply.raw.headersSent) {
+                req.log.warn({ err: error }, "Error after streaming started");
+                reply.raw.end();
+                return;
+            }
+            if (errorType === "invalid_request") {
+                reply.code(400).send({ error: { message: error.message } });
+                return;
+            }
+            if (errorType === "tls_verify_failed") {
+                reply.code(502).send({ error: { message: error.message, type: errorType } });
+                return;
+            }
+            const status = errorType === "no_endpoints" ||
+                errorType === "protocol_stream_unsupported" ||
+                errorType === "unsupported_protocol" ||
+                errorType === "invalid_protocol_config"
+                ? 400
+                : errorType === "rate_limited"
+                    ? 429
+                    : 502;
+            reply.code(status).send({ error: { message: "Speech synthesis unavailable", type: errorType } });
+        }
+    });
+}
+async function pickDefaultAudioModel(paths) {
+    const smart = await (0, scheduler_1.selectPoolCandidates)(paths, "smart", {
+        requiredInput: ["audio"],
+        requiredOutput: ["text"],
+    }, {
+        operation: "audio_transcriptions",
+        stream: false,
+    });
+    if (smart && smart.candidates.length > 0) {
+        return "smart";
+    }
+    const byCapabilities = await (0, modelRegistry_1.pickBestProviderModelByCapabilities)(paths, { requiredInput: ["audio"], requiredOutput: ["text"] }, "audio");
+    if (byCapabilities) {
+        return byCapabilities;
+    }
+    return null;
+}
+async function pickDefaultTtsModel(paths) {
+    const smart = await (0, scheduler_1.selectPoolCandidates)(paths, "smart", {
+        requiredInput: ["text"],
+        requiredOutput: ["audio"],
+    }, {
+        operation: "audio_speech",
+        stream: false,
+    });
+    if (smart && smart.candidates.length > 0) {
+        return "smart";
+    }
+    const byCapabilities = await (0, modelRegistry_1.pickBestProviderModelByCapabilities)(paths, { requiredInput: ["text"], requiredOutput: ["audio"] }, "audio");
+    if (byCapabilities) {
+        return byCapabilities;
+    }
+    return null;
+}
+async function streamResponse(reply, response) {
+    const headers = normalizeHeaders(response.headers);
+    reply.raw.writeHead(response.statusCode, headers);
+    await new Promise((resolve, reject) => {
+        (0, stream_1.pipeline)(response.body, reply.raw, (err) => {
+            if (err)
+                reject(err);
+            else
+                resolve();
+        });
+    });
+}
+function setHeaders(reply, headers) {
+    const normalized = normalizeHeaders(headers);
+    for (const [key, value] of Object.entries(normalized)) {
+        reply.header(key, value);
+    }
+}
+function normalizeHeaders(headers) {
+    const normalized = {};
+    for (const [key, value] of Object.entries(headers)) {
+        normalized[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
+    }
+    return normalized;
+}
+async function readBody(response) {
+    const chunks = [];
+    for await (const chunk of response.body) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const buffer = Buffer.concat(chunks);
+    const contentType = normalizeHeaders(response.headers)["content-type"] ?? "";
+    if (contentType.includes("application/json")) {
+        try {
+            return { payload: JSON.parse(buffer.toString("utf8")) };
+        }
+        catch {
+            return { payload: buffer };
+        }
+    }
+    return { payload: buffer };
+}
+function buildLog(requestId, model, outcome, latencyMs) {
+    return {
+        requestId,
+        ts: new Date(),
+        route: {
+            publicModel: model,
+            endpointId: outcome.attempt.endpoint.id,
+            endpointName: outcome.attempt.endpoint.name,
+            upstreamModel: outcome.attempt.upstreamModel
+        },
+        request: { stream: false },
+        result: {
+            statusCode: outcome.attempt.response.statusCode,
+            latencyMs,
+            totalTokens: null
+        }
+    };
+}

package/dist/src/routes/chat.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerChatRoutes = registerChatRoutes;
+const crypto_1 = require("crypto");
+const stream_1 = require("stream");
+const router_1 = require("../routing/router");
+const repositories_1 = require("../storage/repositories");
+const scheduler_1 = require("../pools/scheduler");
+const modelRegistry_1 = require("../providers/modelRegistry");
+const messageMedia_1 = require("../utils/messageMedia");
+const requestCapture_1 = require("../middleware/requestCapture");
+const requestStats_1 = require("../middleware/requestStats");
+const stream_2 = require("stream");
+async function registerChatRoutes(app, paths) {
+    app.post("/v1/chat/completions", async (req, reply) => {
+        let body = req.body;
+        if (!body?.model) {
+            const fallback = await pickDefaultModel(paths);
+            if (!fallback) {
+                reply.code(400).send({ error: { message: "model is required" } });
+                return;
+            }
+            body = { ...(body ?? {}), model: fallback };
+        }
+        const requestId = (0, crypto_1.randomUUID)();
+        const start = Date.now();
+        const controller = new AbortController();
+        req.raw.on("close", () => controller.abort());
+        try {
+            const messages = body.messages;
+            const normalizedMessages = await (0, messageMedia_1.normalizeMessagesForUpstream)(paths, messages);
+            const bodyWithNormalizedMessages = {
+                ...body,
+                messages: normalizedMessages,
+            };
+            (0, requestCapture_1.setCaptureDerivedRequest)(reply, { normalizedRequest: bodyWithNormalizedMessages });
+            const media = (0, messageMedia_1.scanMessageModalities)(normalizedMessages);
+            const outcome = await (0, router_1.routeRequest)(paths, body.model, "/v1/chat/completions", bodyWithNormalizedMessages, req.headers, controller.signal, {
+                requiredInput: media.hasAudio
+                    ? media.hasImage
+                        ? ["text", "image", "audio"]
+                        : ["text", "audio"]
+                    : media.hasImage
+                        ? ["text", "image"]
+                        : ["text"],
+                requiredOutput: ["text"],
+            });
+            if (body.stream) {
+                (0, requestCapture_1.setCaptureRouting)(reply, {
+                    publicModel: body.model,
+                    endpointId: outcome.attempt.endpoint.id,
+                    endpointName: outcome.attempt.endpoint.name,
+                    upstreamModel: outcome.attempt.upstreamModel,
+                });
+                (0, requestStats_1.setStatsPayload)(reply, {
+                    endpointId: outcome.attempt.endpoint.id,
+                    endpointName: outcome.attempt.endpoint.name,
+                    upstreamModel: outcome.attempt.upstreamModel,
+                });
+                await streamResponse(reply, outcome.attempt.response);
+                await (0, repositories_1.logRequest)(paths, buildLog(requestId, body, outcome, Date.now() - start));
+                return;
+            }
+            const upstreamBody = await readBody(outcome.attempt.response);
+            (0, requestCapture_1.setCaptureResponseOverride)(reply, upstreamBody.payload, outcome.attempt.response.headers);
+            setHeaders(reply, outcome.attempt.response.headers);
+            reply.code(outcome.attempt.response.statusCode).send(upstreamBody.payload);
+            (0, requestCapture_1.setCaptureRouting)(reply, {
+                publicModel: body.model,
+                endpointId: outcome.attempt.endpoint.id,
+                endpointName: outcome.attempt.endpoint.name,
+                upstreamModel: outcome.attempt.upstreamModel,
+            });
+            (0, requestStats_1.setStatsPayload)(reply, {
+                endpointId: outcome.attempt.endpoint.id,
+                endpointName: outcome.attempt.endpoint.name,
+                upstreamModel: outcome.attempt.upstreamModel,
+                totalTokens: upstreamBody.totalTokens,
+                promptTokens: upstreamBody.promptTokens,
+                completionTokens: upstreamBody.completionTokens,
+            });
+            await (0, repositories_1.logRequest)(paths, buildLog(requestId, body, outcome, Date.now() - start, upstreamBody.totalTokens));
+        }
+        catch (error) {
+            const errorType = error.type ?? error.name;
+            (0, requestCapture_1.setCaptureError)(reply, { type: errorType, message: error.message });
+            await (0, repositories_1.logRequest)(paths, {
+                requestId,
+                ts: new Date(),
+                route: { publicModel: body?.model ?? "unknown" },
+                request: { stream: Boolean(body?.stream), maxTokens: body?.max_tokens },
+                result: {
+                    errorType,
+                    errorMessage: error.message
+                }
+            });
+            // Don't try to send error if headers already sent (streaming started)
+            if (reply.raw.headersSent) {
+                req.log.warn({ err: error }, "Error after streaming started");
+                reply.raw.end();
+                return;
+            }
+            const status = errorType === "no_endpoints" ||
+                errorType === "protocol_stream_unsupported" ||
+                errorType === "unsupported_protocol" ||
+                errorType === "invalid_protocol_config"
+                ? 400
+                : errorType === "rate_limited"
+                    ? 429
+                    : 502;
+            if (errorType === "invalid_request") {
+                reply.code(400).send({ error: { message: error.message } });
+                return;
+            }
+            if (errorType === "tls_verify_failed") {
+                reply.code(502).send({ error: { message: error.message } });
+                return;
+            }
+            reply.code(status).send({ error: { message: "Upstream unavailable" } });
+        }
+    });
+}
+async function pickDefaultModel(paths) {
+    const smart = await (0, scheduler_1.selectPoolCandidates)(paths, "smart", {
+        requiredInput: ["text"],
+        requiredOutput: ["text"],
+    }, {
+        operation: "chat_completions",
+        stream: false,
+    });
+    if (smart && smart.candidates.length > 0) {
+        return "smart";
+    }
+    const byCapabilities = await (0, modelRegistry_1.pickBestProviderModelByCapabilities)(paths, { requiredInput: ["text"], requiredOutput: ["text"] }, "llm");
+    if (byCapabilities) {
+        return byCapabilities;
+    }
+    return null;
+}
+async function streamResponse(reply, response) {
+    const headers = normalizeHeaders(response.headers);
+    if (!headers["content-type"]) {
+        headers["content-type"] = "text/event-stream";
+    }
+    headers["cache-control"] = headers["cache-control"] ?? "no-cache";
+    const contentType = headers["content-type"] ?? "application/octet-stream";
+    (0, requestCapture_1.startCaptureStreamResponse)(reply, headers, contentType);
+    const chunks = [];
+    const captureTap = new stream_2.Transform({
+        transform(chunk, _enc, cb) {
+            const asBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            chunks.push(asBuffer);
+            (0, requestCapture_1.appendCaptureStreamChunk)(reply, asBuffer, { contentType, headers });
+            cb(null, chunk);
+        },
+    });
+    reply.raw.writeHead(response.statusCode, headers);
+    await new Promise((resolve, reject) => {
+        (0, stream_1.pipeline)(response.body, captureTap, reply.raw, (err) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve();
+        });
+    });
+    const buffer = Buffer.concat(chunks);
+    const isText = contentType.includes("text/") || contentType.includes("json") || contentType.includes("event-stream");
+    (0, requestCapture_1.setCaptureResponseOverride)(reply, {
+        $type: "stream",
+        contentType,
+        bytes: buffer.byteLength,
+        text: isText ? buffer.toString("utf8") : undefined,
+    }, headers);
+    return {
+        bytes: buffer.byteLength,
+        text: isText ? buffer.toString("utf8") : undefined,
+        contentType,
+    };
+}
+function setHeaders(reply, headers) {
+    const normalized = normalizeHeaders(headers);
+    for (const [key, value] of Object.entries(normalized)) {
+        reply.header(key, value);
+    }
+}
+function normalizeHeaders(headers) {
+    const normalized = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (Array.isArray(value)) {
+            normalized[key.toLowerCase()] = value.join(", ");
+        }
+        else {
+            normalized[key.toLowerCase()] = value;
+        }
+    }
+    return normalized;
+}
+async function readBody(response) {
+    const chunks = [];
+    for await (const chunk of response.body) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const buffer = Buffer.concat(chunks);
+    const contentType = normalizeHeaders(response.headers)["content-type"] ?? "";
+    if (contentType.includes("application/json")) {
+        try {
+            const payload = JSON.parse(buffer.toString("utf8"));
+            const usage = typeof payload === "object" && payload && payload.usage;
+            return {
+                payload,
+                totalTokens: usage?.total_tokens ?? null,
+                promptTokens: usage?.prompt_tokens ?? null,
+                completionTokens: usage?.completion_tokens ?? null,
+            };
+        }
+        catch {
+            return { payload: buffer, totalTokens: null, promptTokens: null, completionTokens: null };
+        }
+    }
+    return { payload: buffer, totalTokens: null, promptTokens: null, completionTokens: null };
+}
+function buildLog(requestId, body, outcome, latencyMs, totalTokens) {
+    return {
+        requestId,
+        ts: new Date(),
+        route: {
+            publicModel: body.model,
+            endpointId: outcome.attempt.endpoint.id,
+            endpointName: outcome.attempt.endpoint.name,
+            upstreamModel: outcome.attempt.upstreamModel
+        },
+        request: { stream: Boolean(body.stream), maxTokens: body.max_tokens },
+        result: {
+            statusCode: outcome.attempt.response.statusCode,
+            latencyMs,
+            totalTokens: totalTokens ?? null
+        }
+    };
+}

package/dist/src/routes/embeddings.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerEmbeddingsRoutes = registerEmbeddingsRoutes;
+const crypto_1 = require("crypto");
+const router_1 = require("../routing/router");
+const repositories_1 = require("../storage/repositories");
+const scheduler_1 = require("../pools/scheduler");
+const modelRegistry_1 = require("../providers/modelRegistry");
+const requestCapture_1 = require("../middleware/requestCapture");
+const requestStats_1 = require("../middleware/requestStats");
+async function registerEmbeddingsRoutes(app, paths) {
+    app.post("/v1/embeddings", async (req, reply) => {
+        let body = req.body;
+        if (!body?.model) {
+            const smart = await (0, scheduler_1.selectPoolCandidates)(paths, "smart", {
+                requiredInput: ["text"],
+                requiredOutput: ["embedding"],
+            }, {
+                operation: "embeddings",
+                stream: false,
+            });
+            if (smart && smart.candidates.length > 0) {
+                body = { ...(body ?? { input: "" }), model: "smart" };
+            }
+        }
+        if (!body?.model) {
+            const direct = await (0, modelRegistry_1.pickBestProviderModelByCapabilities)(paths, { requiredInput: ["text"], requiredOutput: ["embedding"] }, "embedding");
+            if (direct) {
+                body = { ...(body ?? { input: "" }), model: direct };
+            }
+        }
+        if (!body?.model) {
+            reply.code(400).send({ error: { message: "model is required" } });
+            return;
+        }
+        const requestId = (0, crypto_1.randomUUID)();
+        const start = Date.now();
+        const controller = new AbortController();
+        req.raw.on("close", () => controller.abort());
+        try {
+            const outcome = await (0, router_1.routeRequest)(paths, body.model, "/v1/embeddings", body, req.headers, controller.signal, {
+                endpointType: "embedding",
+                requiredInput: ["text"],
+                requiredOutput: ["embedding"],
+            });
+            const upstreamBody = await readBody(outcome.attempt.response);
+            setHeaders(reply, outcome.attempt.response.headers);
+            reply.code(outcome.attempt.response.statusCode).send(upstreamBody.payload);
+            (0, requestCapture_1.setCaptureRouting)(reply, {
+                publicModel: body.model,
+                endpointId: outcome.attempt.endpoint.id,
+                endpointName: outcome.attempt.endpoint.name,
+                upstreamModel: outcome.attempt.upstreamModel,
+            });
+            (0, requestStats_1.setStatsPayload)(reply, {
+                endpointId: outcome.attempt.endpoint.id,
+                endpointName: outcome.attempt.endpoint.name,
+                upstreamModel: outcome.attempt.upstreamModel,
+                totalTokens: upstreamBody.totalTokens,
+                promptTokens: upstreamBody.promptTokens,
+                completionTokens: upstreamBody.completionTokens,
+            });
+            await (0, repositories_1.logRequest)(paths, buildLog(requestId, body, outcome, Date.now() - start, upstreamBody.totalTokens));
+        }
+        catch (error) {
+            const errorType = error.type ?? error.name;
+            (0, requestCapture_1.setCaptureError)(reply, { type: errorType, message: error.message });
+            await (0, repositories_1.logRequest)(paths, {
+                requestId,
+                ts: new Date(),
+                route: { publicModel: body?.model ?? "unknown" },
+                request: { stream: false },
+                result: {
+                    errorType,
+                    errorMessage: error.message
+                }
+            });
+            if (errorType === "invalid_request") {
+                reply.code(400).send({ error: { message: error.message } });
+                return;
+            }
+            if (errorType === "tls_verify_failed") {
+                reply.code(502).send({ error: { message: error.message } });
+                return;
+            }
+            const status = errorType === "no_endpoints" ||
+                errorType === "protocol_stream_unsupported" ||
+                errorType === "unsupported_protocol" ||
+                errorType === "invalid_protocol_config"
+                ? 400
+                : errorType === "rate_limited"
+                    ? 429
+                    : 502;
+            reply.code(status).send({ error: { message: "Upstream unavailable" } });
+        }
+    });
+}
+function setHeaders(reply, headers) {
+    const normalized = normalizeHeaders(headers);
+    for (const [key, value] of Object.entries(normalized)) {
+        reply.header(key, value);
+    }
+}
+function normalizeHeaders(headers) {
+    const normalized = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (Array.isArray(value)) {
+            normalized[key.toLowerCase()] = value.join(", ");
+        }
+        else {
+            normalized[key.toLowerCase()] = value;
+        }
+    }
+    return normalized;
+}
+async function readBody(response) {
+    const chunks = [];
+    for await (const chunk of response.body) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const buffer = Buffer.concat(chunks);
+    const contentType = normalizeHeaders(response.headers)["content-type"] ?? "";
+    if (contentType.includes("application/json")) {
+        try {
+            const payload = JSON.parse(buffer.toString("utf8"));
+            const usage = typeof payload === "object" && payload && payload.usage;
+            return {
+                payload,
+                totalTokens: usage?.total_tokens ?? null,
+                promptTokens: usage?.prompt_tokens ?? null,
+                completionTokens: usage?.completion_tokens ?? null,
+            };
+        }
+        catch {
+            return { payload: buffer, totalTokens: null, promptTokens: null, completionTokens: null };
+        }
+    }
+    return { payload: buffer, totalTokens: null, promptTokens: null, completionTokens: null };
+}
+function buildLog(requestId, body, outcome, latencyMs, totalTokens) {
+    return {
+        requestId,
+        ts: new Date(),
+        route: {
+            publicModel: body.model,
+            endpointId: outcome.attempt.endpoint.id,
+            endpointName: outcome.attempt.endpoint.name,
+            upstreamModel: outcome.attempt.upstreamModel
+        },
+        request: { stream: false },
+        result: {
+            statusCode: outcome.attempt.response.statusCode,
+            latencyMs,
+            totalTokens: totalTokens ?? null
+        }
+    };
+}