waypoi 0.0.0

package/dist/src/storage/repositories.js

@@ -0,0 +1,388 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invalidateConfigCache = invalidateConfigCache;
+exports.listEndpoints = listEndpoints;
+exports.createEndpoint = createEndpoint;
+exports.updateEndpoint = updateEndpoint;
+exports.setEndpointDisabled = setEndpointDisabled;
+exports.deleteEndpointByIdOrName = deleteEndpointByIdOrName;
+exports.getEndpointByIdOrName = getEndpointByIdOrName;
+exports.getEligibleEndpointsForModel = getEligibleEndpointsForModel;
+exports.listEligibleEndpoints = listEligibleEndpoints;
+exports.sortEndpointsForRouting = sortEndpointsForRouting;
+exports.updateHealthSuccess = updateHealthSuccess;
+exports.updateHealthFailure = updateHealthFailure;
+exports.markEndpointDown = markEndpointDown;
+exports.updateHealthCheck = updateHealthCheck;
+exports.listPublicModels = listPublicModels;
+exports.listModelsWithTypes = listModelsWithTypes;
+exports.pickBestLlmModel = pickBestLlmModel;
+exports.pickBestModelByCapabilities = pickBestModelByCapabilities;
+exports.getModelCapabilitiesForEndpoint = getModelCapabilitiesForEndpoint;
+exports.logRequest = logRequest;
+exports.getStats = getStats;
+exports.getUsageByEndpoint = getUsageByEndpoint;
+const files_1 = require("./files");
+const modelCapabilities_1 = require("../utils/modelCapabilities");
+const modelRegistry_1 = require("../providers/modelRegistry");
+const cache = {
+    config: null,
+    health: null,
+    lastLoadedAt: 0
+};
+const CACHE_TTL_MS = 1000; // 1 second TTL for cache
+/**
+ * Invalidate the config cache. Call this when config changes externally.
+ */
+function invalidateConfigCache() {
+    cache.config = null;
+    cache.health = null;
+    cache.lastLoadedAt = 0;
+    console.log("[repositories] Config cache invalidated");
+}
+/**
+ * Check if cache is valid
+ */
+function isCacheValid() {
+    return cache.config !== null && (Date.now() - cache.lastLoadedAt) < CACHE_TTL_MS;
+}
+async function getCachedConfig(paths) {
+    if (!isCacheValid()) {
+        cache.config = await (0, files_1.loadConfig)(paths);
+        cache.lastLoadedAt = Date.now();
+    }
+    return cache.config;
+}
+async function getCachedHealth(paths) {
+    // Health is always fresh-loaded since it changes frequently
+    return (0, files_1.loadHealth)(paths);
+}
+async function listEndpoints(paths) {
+    const config = await getCachedConfig(paths);
+    const normalized = normalizeConfig(config);
+    if (normalized.changed) {
+        await (0, files_1.saveConfig)(paths, normalized.config);
+        cache.config = normalized.config;
+    }
+    const health = await getCachedHealth(paths);
+    return normalized.config.endpoints.map((endpoint) => ({
+        ...endpoint,
+        health: health.endpoints[endpoint.id] ?? (0, files_1.defaultHealth)()
+    }));
+}
+async function createEndpoint(paths, input) {
+    const normalized = normalizeConfig(await (0, files_1.loadConfig)(paths));
+    if (normalized.changed) {
+        await (0, files_1.saveConfig)(paths, normalized.config);
+    }
+    const config = normalized.config;
+    const now = new Date();
+    const endpoint = {
+        ...input,
+        id: (0, files_1.newEndpointId)(),
+        health: (0, files_1.defaultHealth)(),
+        disabled: input.disabled ?? false,
+        createdAt: now,
+        updatedAt: now
+    };
+    config.endpoints.push(stripHealth(endpoint));
+    await (0, files_1.saveConfig)(paths, config);
+    const health = await (0, files_1.loadHealth)(paths);
+    health.endpoints[endpoint.id] = endpoint.health;
+    await (0, files_1.saveHealth)(paths, health);
+    return endpoint;
+}
+async function updateEndpoint(paths, id, patch) {
+    const config = normalizeConfig(await (0, files_1.loadConfig)(paths)).config;
+    const idx = config.endpoints.findIndex((endpoint) => endpoint.id === id);
+    if (idx === -1) {
+        return null;
+    }
+    const existing = config.endpoints[idx];
+    const updated = {
+        ...existing,
+        ...stripHealth(patch),
+        updatedAt: new Date()
+    };
+    config.endpoints[idx] = updated;
+    await (0, files_1.saveConfig)(paths, config);
+    const health = await (0, files_1.loadHealth)(paths);
+    const healthState = health.endpoints[id] ?? (0, files_1.defaultHealth)();
+    return { ...updated, health: healthState };
+}
+async function setEndpointDisabled(paths, id, disabled) {
+    const endpoint = await updateEndpoint(paths, id, { disabled });
+    return endpoint;
+}
+async function deleteEndpointByIdOrName(paths, value) {
+    const config = normalizeConfig(await (0, files_1.loadConfig)(paths)).config;
+    const target = config.endpoints.find((endpoint) => endpoint.id === value || endpoint.name === value);
+    if (!target) {
+        return null;
+    }
+    config.endpoints = config.endpoints.filter((endpoint) => endpoint.id !== target.id);
+    await (0, files_1.saveConfig)(paths, config);
+    const health = await (0, files_1.loadHealth)(paths);
+    const healthState = health.endpoints[target.id] ?? (0, files_1.defaultHealth)();
+    delete health.endpoints[target.id];
+    await (0, files_1.saveHealth)(paths, health);
+    return { ...target, health: healthState };
+}
+async function getEndpointByIdOrName(paths, value) {
+    const config = normalizeConfig(await (0, files_1.loadConfig)(paths)).config;
+    const endpoint = config.endpoints.find((item) => item.id === value || item.name === value);
+    if (!endpoint) {
+        return null;
+    }
+    const health = await (0, files_1.loadHealth)(paths);
+    return { ...endpoint, health: health.endpoints[endpoint.id] ?? (0, files_1.defaultHealth)() };
+}
+async function getEligibleEndpointsForModel(paths, publicModel, requirements = {}) {
+    const endpoints = await listEndpoints(paths);
+    const now = new Date();
+    return endpoints.filter((endpoint) => {
+        if (endpoint.disabled) {
+            return false;
+        }
+        // Filter by endpoint type if specified
+        if (requirements.endpointType && endpoint.type !== requirements.endpointType) {
+            return false;
+        }
+        const model = endpoint.models.find((mapping) => mapping.publicName === publicModel);
+        if (!model) {
+            return false;
+        }
+        const capabilities = (0, modelCapabilities_1.resolveCapabilities)(model, endpoint.type);
+        if (!(0, modelCapabilities_1.supportsRequirements)(capabilities, requirements)) {
+            return false;
+        }
+        if (endpoint.health.status === "down") {
+            return false;
+        }
+        if (endpoint.health.downUntil && endpoint.health.downUntil > now) {
+            return false;
+        }
+        return true;
+    });
+}
+async function listEligibleEndpoints(paths) {
+    const endpoints = await listEndpoints(paths);
+    const now = new Date();
+    return endpoints.filter((endpoint) => {
+        if (endpoint.disabled) {
+            return false;
+        }
+        if (endpoint.health.status === "down") {
+            return false;
+        }
+        if (endpoint.health.downUntil && endpoint.health.downUntil > now) {
+            return false;
+        }
+        return true;
+    });
+}
+function sortEndpointsForRouting(endpoints) {
+    return endpoints.sort((a, b) => {
+        if (a.priority !== b.priority) {
+            return a.priority - b.priority;
+        }
+        const aLatency = a.health.latencyMsEwma ?? Number.POSITIVE_INFINITY;
+        const bLatency = b.health.latencyMsEwma ?? Number.POSITIVE_INFINITY;
+        return aLatency - bLatency;
+    });
+}
+async function updateHealthSuccess(paths, endpointId, latencyMs) {
+    const health = await (0, files_1.loadHealth)(paths);
+    const now = new Date();
+    const current = health.endpoints[endpointId] ?? (0, files_1.defaultHealth)();
+    const nextLatency = ewma(current.latencyMsEwma, latencyMs);
+    health.endpoints[endpointId] = {
+        ...current,
+        status: "up",
+        lastSuccessAt: now,
+        consecutiveFailures: 0,
+        latencyMsEwma: nextLatency,
+        downUntil: undefined
+    };
+    await (0, files_1.saveHealth)(paths, health);
+}
+async function updateHealthFailure(paths, endpointId) {
+    const health = await (0, files_1.loadHealth)(paths);
+    const now = new Date();
+    const current = health.endpoints[endpointId] ?? (0, files_1.defaultHealth)();
+    const next = {
+        ...current,
+        lastFailureAt: now,
+        consecutiveFailures: current.consecutiveFailures + 1
+    };
+    health.endpoints[endpointId] = next;
+    await (0, files_1.saveHealth)(paths, health);
+    return { consecutiveFailures: next.consecutiveFailures };
+}
+async function markEndpointDown(paths, endpointId, downUntil) {
+    const health = await (0, files_1.loadHealth)(paths);
+    const current = health.endpoints[endpointId] ?? (0, files_1.defaultHealth)();
+    health.endpoints[endpointId] = {
+        ...current,
+        status: "down",
+        downUntil
+    };
+    await (0, files_1.saveHealth)(paths, health);
+}
+async function updateHealthCheck(paths, endpointId, status, latencyMs) {
+    const health = await (0, files_1.loadHealth)(paths);
+    const now = new Date();
+    const current = health.endpoints[endpointId] ?? (0, files_1.defaultHealth)();
+    const next = {
+        ...current,
+        status,
+        lastCheckedAt: now
+    };
+    if (latencyMs !== null) {
+        next.latencyMsEwma = ewma(current.latencyMsEwma, latencyMs);
+        next.lastSuccessAt = now;
+    }
+    else {
+        next.lastFailureAt = now;
+    }
+    health.endpoints[endpointId] = next;
+    await (0, files_1.saveHealth)(paths, health);
+}
+async function listPublicModels(paths) {
+    const config = normalizeConfig(await (0, files_1.loadConfig)(paths)).config;
+    const names = new Set();
+    for (const endpoint of config.endpoints) {
+        for (const model of endpoint.models) {
+            names.add(model.publicName);
+        }
+    }
+    return Array.from(names).sort();
+}
+async function listModelsWithTypes(paths) {
+    // Get endpoints with health status to filter out unhealthy ones
+    const endpoints = await listEligibleEndpoints(paths);
+    const models = new Map();
+    for (const endpoint of endpoints) {
+        for (const model of endpoint.models) {
+            // First endpoint wins (in case model is on multiple endpoints)
+            if (!models.has(model.publicName)) {
+                models.set(model.publicName, {
+                    id: model.publicName,
+                    type: endpoint.type,
+                    endpointName: endpoint.name,
+                    capabilities: (0, modelCapabilities_1.resolveCapabilities)(model, endpoint.type),
+                });
+            }
+        }
+    }
+    return Array.from(models.values()).sort((a, b) => a.id.localeCompare(b.id));
+}
+/**
+ * Pick the best available LLM model based on endpoint priority and health.
+ * Returns the publicName of the first LLM model from the highest-priority healthy endpoint.
+ */
+async function pickBestLlmModel(paths) {
+    return (0, modelRegistry_1.pickBestProviderModelByCapabilities)(paths, { requiredInput: ["text"], requiredOutput: ["text"] }, "llm");
+}
+async function pickBestModelByCapabilities(paths, requirements, preferredEndpointType) {
+    return (0, modelRegistry_1.pickBestProviderModelByCapabilities)(paths, requirements, preferredEndpointType);
+}
+function getModelCapabilitiesForEndpoint(endpointType, mapping) {
+    return (0, modelCapabilities_1.resolveCapabilities)(mapping, endpointType);
+}
+async function logRequest(paths, log) {
+    await (0, files_1.appendRequestLog)(paths, log);
+}
+async function getStats(paths, windowMs) {
+    const since = Date.now() - windowMs;
+    const logs = await (0, files_1.readRequestLogs)(paths);
+    const filtered = logs.filter((log) => new Date(log.ts).getTime() >= since);
+    if (filtered.length === 0) {
+        return { total: 0, success: 0, errors: 0, avgLatencyMs: null };
+    }
+    let sumLatency = 0;
+    let latencyCount = 0;
+    let errors = 0;
+    for (const log of filtered) {
+        if (log.result.errorType) {
+            errors += 1;
+        }
+        if (typeof log.result.latencyMs === "number") {
+            sumLatency += log.result.latencyMs;
+            latencyCount += 1;
+        }
+    }
+    const avgLatencyMs = latencyCount > 0 ? sumLatency / latencyCount : null;
+    return {
+        total: filtered.length,
+        success: filtered.length - errors,
+        errors,
+        avgLatencyMs
+    };
+}
+async function getUsageByEndpoint(paths) {
+    const logs = await (0, files_1.readRequestLogs)(paths);
+    const totals = new Map();
+    for (const log of logs) {
+        const endpointId = log.route.endpointId;
+        if (!endpointId) {
+            continue;
+        }
+        const entry = totals.get(endpointId) ?? { endpointName: log.route.endpointName ?? "unknown", totalTokens: 0, count: 0 };
+        entry.totalTokens += log.result.totalTokens ?? 0;
+        entry.count += 1;
+        totals.set(endpointId, entry);
+    }
+    return Array.from(totals.entries()).map(([endpointId, entry]) => ({
+        endpointId,
+        endpointName: entry.endpointName,
+        totalTokens: entry.totalTokens,
+        count: entry.count
+    }));
+}
+function ewma(prev, next, alpha = 0.2) {
+    if (prev === undefined) {
+        return next;
+    }
+    return alpha * next + (1 - alpha) * prev;
+}
+function stripHealth(endpoint) {
+    const { health: _health, ...rest } = endpoint;
+    return rest;
+}
+function normalizeConfig(config) {
+    let changed = false;
+    const endpoints = config.endpoints.map((endpoint) => {
+        let next = endpoint;
+        if (!endpoint.id) {
+            next = { ...next, id: (0, files_1.newEndpointId)() };
+            changed = true;
+        }
+        if (!next.type) {
+            next = { ...next, type: "llm" };
+            changed = true;
+        }
+        if (typeof next.disabled !== "boolean") {
+            next = { ...next, disabled: false };
+            changed = true;
+        }
+        if (!next.createdAt) {
+            next = { ...next, createdAt: new Date() };
+            changed = true;
+        }
+        else if (!(next.createdAt instanceof Date)) {
+            next = { ...next, createdAt: new Date(next.createdAt) };
+            changed = true;
+        }
+        if (!next.updatedAt) {
+            next = { ...next, updatedAt: new Date() };
+            changed = true;
+        }
+        else if (!(next.updatedAt instanceof Date)) {
+            next = { ...next, updatedAt: new Date(next.updatedAt) };
+            changed = true;
+        }
+        return next;
+    });
+    return { config: { ...config, endpoints }, changed };
+}