waypoi 0.0.0

package/dist/src/middleware/requestCapture.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRequestCaptureMiddleware = registerRequestCaptureMiddleware;
+exports.setCaptureRouting = setCaptureRouting;
+exports.setCaptureDerivedRequest = setCaptureDerivedRequest;
+exports.setCaptureResponseOverride = setCaptureResponseOverride;
+exports.setCaptureError = setCaptureError;
+exports.startCaptureStreamResponse = startCaptureStreamResponse;
+exports.appendCaptureStreamChunk = appendCaptureStreamChunk;
+const crypto_1 = require("crypto");
+const captureRepository_1 = require("../storage/captureRepository");
+const captureContexts = new WeakMap();
+function meta(reply) {
+    return reply;
+}
+async function registerRequestCaptureMiddleware(app, paths) {
+    app.addHook("onRequest", async (req) => {
+        if (!req.url.startsWith("/v1/"))
+            return;
+        let enabled = false;
+        try {
+            enabled = await (0, captureRepository_1.isCaptureEnabled)(paths);
+        }
+        catch {
+            enabled = false;
+        }
+        captureContexts.set(req, {
+            id: (0, crypto_1.randomUUID)(),
+            startedAt: Date.now(),
+            enabled,
+        });
+    });
+    app.addHook("preHandler", async (req) => {
+        const context = captureContexts.get(req);
+        if (!context?.enabled)
+            return;
+        context.requestBody = safeClone(req.body);
+    });
+    app.addHook("onSend", async (req, reply, payload) => {
+        const context = captureContexts.get(req);
+        if (!context?.enabled)
+            return payload;
+        if (!meta(reply).captureResponseOverride) {
+            context.responseBody = payloadToBody(payload);
+            context.responseHeaders = reply.getHeaders();
+        }
+        return payload;
+    });
+    app.addHook("onResponse", async (req, reply) => {
+        const context = captureContexts.get(req);
+        if (!context)
+            return;
+        try {
+            if (!context.enabled)
+                return;
+            const replyMeta = meta(reply);
+            context.routing = replyMeta.captureRouting;
+            context.derivedRequest = replyMeta.captureDerivedRequest;
+            context.error = replyMeta.captureError;
+            if (replyMeta.captureResponseOverride) {
+                context.responseBody = replyMeta.captureResponseOverride.body;
+                context.responseHeaders = replyMeta.captureResponseOverride.headers;
+            }
+            await (0, captureRepository_1.persistCaptureRecord)(paths, {
+                route: req.url,
+                method: req.method,
+                statusCode: reply.statusCode,
+                latencyMs: Date.now() - context.startedAt,
+                requestHeaders: req.headers,
+                responseHeaders: context.responseHeaders ??
+                    reply.getHeaders(),
+                requestBody: context.requestBody,
+                responseBody: context.responseBody,
+                derivedRequest: context.derivedRequest,
+                routing: context.routing,
+                error: context.error,
+            });
+        }
+        catch (error) {
+            app.log.warn({ err: error }, "Failed to persist request capture");
+        }
+        finally {
+            captureContexts.delete(req);
+        }
+    });
+}
+function setCaptureRouting(reply, routing) {
+    meta(reply).captureRouting = routing;
+    const context = captureContexts.get(reply.request);
+    if (context?.enabled) {
+        context.routing = routing;
+    }
+}
+function setCaptureDerivedRequest(reply, payload) {
+    meta(reply).captureDerivedRequest = payload;
+    const context = captureContexts.get(reply.request);
+    if (context?.enabled) {
+        context.derivedRequest = payload;
+    }
+}
+function setCaptureResponseOverride(reply, body, headers) {
+    meta(reply).captureResponseOverride = { body, headers };
+    const context = captureContexts.get(reply.request);
+    if (context?.enabled) {
+        context.responseBody = body;
+        if (headers) {
+            context.responseHeaders = headers;
+        }
+    }
+}
+function setCaptureError(reply, error) {
+    meta(reply).captureError = error;
+    const context = captureContexts.get(reply.request);
+    if (context?.enabled) {
+        context.error = error;
+    }
+}
+function startCaptureStreamResponse(reply, headers, contentType, note) {
+    const body = {
+        $type: "stream",
+        contentType,
+        bytes: 0,
+    };
+    if (note) {
+        body.note = note;
+    }
+    setCaptureResponseOverride(reply, body, headers);
+}
+function appendCaptureStreamChunk(reply, chunk, options) {
+    const context = captureContexts.get(reply.request);
+    if (!context?.enabled)
+        return;
+    const body = ensureCaptureStreamBody(context, options?.contentType);
+    body.bytes += chunk.byteLength;
+    if (isTextLikeStream(body.contentType)) {
+        body.text = (body.text ?? "") + chunk.toString("utf8");
+    }
+    context.responseBody = body;
+    if (options?.headers) {
+        context.responseHeaders = options.headers;
+    }
+    meta(reply).captureResponseOverride = {
+        body,
+        headers: context.responseHeaders,
+    };
+}
+function safeClone(value) {
+    try {
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch {
+        return value;
+    }
+}
+function payloadToBody(payload) {
+    if (payload === null || payload === undefined)
+        return payload;
+    if (Buffer.isBuffer(payload)) {
+        return { $type: "buffer", base64: payload.toString("base64"), bytes: payload.byteLength };
+    }
+    if (typeof payload === "string") {
+        try {
+            return JSON.parse(payload);
+        }
+        catch {
+            return payload;
+        }
+    }
+    return payload;
+}
+function ensureCaptureStreamBody(context, contentType) {
+    const existing = context.responseBody;
+    if (existing?.$type === "stream") {
+        if (contentType) {
+            existing.contentType = contentType;
+        }
+        return existing;
+    }
+    const body = {
+        $type: "stream",
+        contentType: contentType ?? "application/octet-stream",
+        bytes: 0,
+    };
+    context.responseBody = body;
+    return body;
+}
+function isTextLikeStream(contentType) {
+    return (contentType.includes("text/") ||
+        contentType.includes("json") ||
+        contentType.includes("xml") ||
+        contentType.includes("event-stream"));
+}

package/dist/src/middleware/requestStats.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRequestStatsMiddleware = registerRequestStatsMiddleware;
+exports.setStatsPayload = setStatsPayload;
+const crypto_1 = require("crypto");
+const statsRepository_1 = require("../storage/statsRepository");
+// WeakMap to store request context without polluting request object
+const requestContexts = new WeakMap();
+async function registerRequestStatsMiddleware(app, paths) {
+    // Decorate request with stats context
+    app.decorateRequest("statsContext", null);
+    // Hook: onRequest - capture start time and request size
+    app.addHook("onRequest", async (req) => {
+        // Only track /v1/* routes
+        if (!req.url.startsWith("/v1/")) {
+            return;
+        }
+        const context = {
+            requestId: (0, crypto_1.randomUUID)(),
+            startTime: Date.now(),
+            requestBytes: 0,
+            route: req.url,
+            method: req.method
+        };
+        // Estimate request size from content-length header
+        const contentLength = req.headers["content-length"];
+        if (contentLength) {
+            context.requestBytes = parseInt(contentLength, 10) || 0;
+        }
+        requestContexts.set(req, context);
+    });
+    // Hook: preHandler - extract model from parsed body
+    app.addHook("preHandler", async (req) => {
+        const context = requestContexts.get(req);
+        if (!context)
+            return;
+        const body = req.body;
+        if (body?.model) {
+            context.publicModel = body.model;
+        }
+    });
+    // Hook: onResponse - log the stats
+    app.addHook("onResponse", async (req, reply) => {
+        const context = requestContexts.get(req);
+        if (!context)
+            return;
+        const latencyMs = Date.now() - context.startTime;
+        const statusCode = reply.statusCode;
+        // Try to get response size from content-length header
+        let responseBytes = 0;
+        const respContentLength = reply.getHeader("content-length");
+        if (respContentLength) {
+            responseBytes = typeof respContentLength === "number"
+                ? respContentLength
+                : parseInt(String(respContentLength), 10) || 0;
+        }
+        // Determine if there was an error
+        let errorType;
+        if (statusCode >= 400) {
+            if (statusCode >= 500) {
+                errorType = "server_error";
+            }
+            else if (statusCode === 429) {
+                errorType = "rate_limit";
+            }
+            else if (statusCode === 401 || statusCode === 403) {
+                errorType = "auth_error";
+            }
+            else {
+                errorType = "client_error";
+            }
+        }
+        // Extract token info from reply (if stored during route handling)
+        const statsPayload = reply.statsPayload;
+        const stats = {
+            requestId: context.requestId,
+            timestamp: new Date(),
+            route: context.route,
+            method: context.method,
+            publicModel: context.publicModel,
+            endpointId: statsPayload?.endpointId,
+            endpointName: statsPayload?.endpointName,
+            upstreamModel: statsPayload?.upstreamModel,
+            requestBytes: context.requestBytes,
+            responseBytes,
+            latencyMs,
+            statusCode,
+            errorType,
+            totalTokens: statsPayload?.totalTokens ?? estimateTokens(context.requestBytes, responseBytes),
+            promptTokens: statsPayload?.promptTokens ?? null,
+            completionTokens: statsPayload?.completionTokens ?? null
+        };
+        // Append stats asynchronously (don't block response)
+        (0, statsRepository_1.appendStats)(paths, stats).catch((err) => {
+            app.log.error({ err }, "Failed to append request stats");
+        });
+        // Cleanup
+        requestContexts.delete(req);
+    });
+}
+/**
+ * Helper to set stats payload from route handlers
+ */
+function setStatsPayload(reply, payload) {
+    reply.statsPayload = payload;
+}
+/**
+ * Estimate token count from byte sizes when actual usage is not available.
+ * Uses rough approximation: ~4 characters per token, ~1 byte per character for English.
+ * This is intentionally conservative.
+ */
+function estimateTokens(requestBytes, responseBytes) {
+    if (requestBytes === 0 && responseBytes === 0) {
+        return null;
+    }
+    // Rough estimate: 4 bytes per token average
+    return Math.ceil((requestBytes + responseBytes) / 4);
+}

package/dist/src/pools/builder.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rebuildDefaultPools = rebuildDefaultPools;
+const repository_1 = require("../providers/repository");
+const modelCapabilities_1 = require("../utils/modelCapabilities");
+const repository_2 = require("./repository");
+const repository_3 = require("../providers/repository");
+const DEFAULT_SCORE_FALLBACK = 20;
+const DEFAULT_POOLS = [
+    {
+        id: "smart",
+        aliases: ["smart"],
+        requiredInput: [],
+        requiredOutput: [],
+    },
+];
+function buildCandidate(provider, model, scoreFallback) {
+    const effectiveBaseUrl = model.baseUrl ?? provider.baseUrl;
+    const score = model.benchmark?.livebench;
+    return {
+        id: model.providerModelId,
+        providerModelId: model.providerModelId,
+        providerId: provider.id,
+        providerName: provider.name,
+        providerEnabled: provider.enabled,
+        modelEnabled: model.enabled !== false,
+        modelId: model.modelId,
+        aliases: model.aliases ?? [],
+        upstreamModel: model.upstreamModel,
+        baseUrl: effectiveBaseUrl ?? "",
+        apiKey: model.apiKey ?? provider.apiKey,
+        insecureTls: (0, repository_3.getEffectiveModelInsecureTls)(provider, model),
+        autoInsecureTlsDomains: provider.autoInsecureTlsDomains ?? [],
+        protocol: provider.protocol,
+        protocolConfig: provider.protocolConfig,
+        auth: provider.auth,
+        supportsRouting: provider.supportsRouting,
+        free: model.free,
+        endpointType: model.endpointType,
+        capabilities: model.capabilities,
+        score: typeof score === "number" ? score : scoreFallback,
+        scoreSource: typeof score === "number" ? "benchmark.livebench" : "fallback",
+        limits: {
+            requestsPerMinute: model.limits?.requests?.perMinute ?? provider.limits?.requests?.perMinute,
+            requestsPerHour: model.limits?.requests?.perHour ?? provider.limits?.requests?.perHour,
+            requestsPerDay: model.limits?.requests?.perDay ?? provider.limits?.requests?.perDay,
+            requestsPerWeek: model.limits?.requests?.perWeek ?? provider.limits?.requests?.perWeek,
+            tokensPerMinute: model.limits?.tokens?.perMinute ?? provider.limits?.tokens?.perMinute,
+            tokensPerHour: model.limits?.tokens?.perHour ?? provider.limits?.tokens?.perHour,
+            tokensPerDay: model.limits?.tokens?.perDay ?? provider.limits?.tokens?.perDay,
+            tokensPerWeek: model.limits?.tokens?.perWeek ?? provider.limits?.tokens?.perWeek,
+        },
+    };
+}
+async function rebuildDefaultPools(paths, scoreFallback = DEFAULT_SCORE_FALLBACK) {
+    const existing = await (0, repository_2.loadPools)(paths);
+    const providers = await (0, repository_1.listProviders)(paths);
+    const userPools = existing.pools.filter((p) => p.userDefined);
+    const autoPools = existing.pools.filter((p) => !p.userDefined);
+    const autoPoolIds = new Set(autoPools.map((p) => p.id));
+    const pools = DEFAULT_POOLS.map((template) => {
+        const existingAuto = autoPools.find((p) => p.id === template.id);
+        return {
+            id: template.id,
+            name: existingAuto?.name ?? template.id,
+            aliases: template.aliases,
+            enabled: existingAuto?.enabled ?? true,
+            strategy: existingAuto?.strategy ?? "highest_rank_available",
+            requiredInput: template.requiredInput,
+            requiredOutput: template.requiredOutput,
+            scoreFallback,
+            candidates: [],
+            candidateSelection: existingAuto?.candidateSelection ?? [],
+            userDefined: false,
+            updatedAt: new Date().toISOString(),
+        };
+    });
+    const allCandidates = new Map();
+    for (const provider of providers) {
+        for (const model of provider.models) {
+            const candidate = buildCandidate(provider, model, scoreFallback);
+            allCandidates.set(`${provider.id}/${model.modelId}`, candidate);
+        }
+    }
+    for (const pool of pools) {
+        for (const [key, candidate] of allCandidates) {
+            if (!candidate.modelEnabled || !candidate.providerEnabled)
+                continue;
+            if (!candidate.free && !pool.userDefined)
+                continue;
+            if ((0, modelCapabilities_1.supportsRequirements)(candidate.capabilities, {
+                requiredInput: pool.requiredInput,
+                requiredOutput: pool.requiredOutput,
+            })) {
+                pool.candidates.push(candidate);
+            }
+        }
+        if (pool.candidateSelection.length > 0) {
+            const selected = pool.candidateSelection
+                .map((sel) => allCandidates.get(sel))
+                .filter((c) => c !== undefined);
+            if (selected.length > 0) {
+                pool.candidates = selected;
+            }
+        }
+        pool.candidates = pool.candidates.sort((a, b) => {
+            if (b.score !== a.score) {
+                return b.score - a.score;
+            }
+            return `${a.providerId}/${a.modelId}`.localeCompare(`${b.providerId}/${b.modelId}`);
+        });
+    }
+    for (const userPool of userPools) {
+        if (!allPoolsHasId(pools, userPool.id)) {
+            userPool.candidates = (userPool.candidateSelection ?? [])
+                .map((sel) => allCandidates.get(sel))
+                .filter((c) => c !== undefined);
+            userPool.candidates = userPool.candidates.sort((a, b) => {
+                if (b.score !== a.score)
+                    return b.score - a.score;
+                return `${a.providerId}/${a.modelId}`.localeCompare(`${b.providerId}/${b.modelId}`);
+            });
+            userPool.updatedAt = new Date().toISOString();
+            pools.push(userPool);
+        }
+    }
+    await (0, repository_2.savePools)(paths, pools);
+    return pools;
+}
+function allPoolsHasId(pools, id) {
+    return pools.some((p) => p.id === id);
+}

package/dist/src/pools/repository.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPools = loadPools;
+exports.savePools = savePools;
+exports.listPools = listPools;
+exports.getPoolByAlias = getPoolByAlias;
+exports.loadPoolState = loadPoolState;
+exports.savePoolState = savePoolState;
+const files_1 = require("../storage/files");
+const POOLS_VERSION = 1;
+const STATE_VERSION = 1;
+function defaultPoolStore() {
+    return {
+        version: POOLS_VERSION,
+        updatedAt: new Date().toISOString(),
+        pools: [],
+    };
+}
+function defaultPoolState() {
+    return {
+        version: STATE_VERSION,
+        updatedAt: new Date().toISOString(),
+        candidates: {},
+    };
+}
+async function loadPools(paths) {
+    const store = await (0, files_1.readJsonFile)(paths.poolsPath, defaultPoolStore());
+    if (!Array.isArray(store.pools)) {
+        return defaultPoolStore();
+    }
+    return {
+        version: Number.isFinite(store.version) ? store.version : POOLS_VERSION,
+        updatedAt: typeof store.updatedAt === "string" ? store.updatedAt : new Date().toISOString(),
+        pools: store.pools,
+    };
+}
+async function savePools(paths, pools) {
+    await (0, files_1.writeJsonFile)(paths.poolsPath, {
+        version: POOLS_VERSION,
+        updatedAt: new Date().toISOString(),
+        pools,
+    });
+}
+async function listPools(paths) {
+    const store = await loadPools(paths);
+    return [...store.pools].sort((a, b) => a.id.localeCompare(b.id));
+}
+async function getPoolByAlias(paths, alias) {
+    const pools = await listPools(paths);
+    return pools.find((pool) => pool.aliases.includes(alias)) ?? null;
+}
+async function loadPoolState(paths) {
+    const state = await (0, files_1.readJsonFile)(paths.poolStatePath, defaultPoolState());
+    if (!state.candidates || typeof state.candidates !== "object") {
+        return defaultPoolState();
+    }
+    return {
+        version: Number.isFinite(state.version) ? state.version : STATE_VERSION,
+        updatedAt: typeof state.updatedAt === "string" ? state.updatedAt : new Date().toISOString(),
+        candidates: state.candidates,
+    };
+}
+async function savePoolState(paths, state) {
+    await (0, files_1.writeJsonFile)(paths.poolStatePath, {
+        ...state,
+        version: STATE_VERSION,
+        updatedAt: new Date().toISOString(),
+    });
+}