waypoi 0.0.0

package/dist/src/providers/importer.js

@@ -0,0 +1,289 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importProviders = importProviders;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+const registry_1 = require("../protocols/registry");
+const repository_1 = require("./repository");
+async function importProviders(paths, options) {
+    const registryPath = path_1.default.resolve(options.registryPath);
+    const registryDir = path_1.default.dirname(registryPath);
+    const registryRaw = await fs_1.promises.readFile(registryPath, "utf8");
+    const registry = (yaml_1.default.parse(registryRaw) ?? {});
+    const envMap = await loadEnvMap(options.envFilePath);
+    const warnings = [];
+    const providers = [];
+    const existing = await (0, repository_1.loadProviderStore)(paths);
+    const existingById = new Map(existing.providers.map((provider) => [provider.id, provider]));
+    for (const entry of registry.providers ?? []) {
+        if (!entry?.id || !entry.file) {
+            warnings.push(`Skipping malformed registry entry: ${JSON.stringify(entry)}`);
+            continue;
+        }
+        const providerConfigPath = path_1.default.resolve(registryDir, entry.file);
+        let configRaw;
+        try {
+            configRaw = await fs_1.promises.readFile(providerConfigPath, "utf8");
+        }
+        catch (error) {
+            warnings.push(`Failed to load provider config ${providerConfigPath}: ${error.message}`);
+            continue;
+        }
+        const config = (yaml_1.default.parse(configRaw) ?? {});
+        const protocolRaw = (config.endpoint?.protocol ?? entry.protocol ?? "unknown").toLowerCase();
+        const normalizedProtocol = (0, registry_1.canonicalizeProtocol)(protocolRaw);
+        const protocol = normalizedProtocol === "openai" || normalizedProtocol === "inference_v2" || normalizedProtocol === "dashscope"
+            ? normalizedProtocol
+            : "unknown";
+        const auth = parseAuthConfig(config.auth);
+        const protocolConfig = parseProtocolConfig(config, protocol);
+        let supportsRouting = (0, registry_1.hasProtocolAdapter)(protocol);
+        const providerId = config.$id ?? entry.id;
+        const previous = existingById.get(providerId);
+        const envVar = typeof config.env === "string" ? config.env : undefined;
+        const apiKey = resolveApiKey(envVar, envMap, previous?.apiKey, options.overwriteAuth ?? false);
+        const baseUrl = config.endpoint?.baseUrl;
+        if (!baseUrl) {
+            warnings.push(`Provider '${providerId}' has no endpoint.baseUrl; skipped.`);
+            continue;
+        }
+        if (protocol === "inference_v2" && !protocolConfig?.router) {
+            warnings.push(`Provider '${providerId}' protocol '${protocolRaw}' requires endpoint.router; imported non-routable.`);
+            supportsRouting = false;
+        }
+        if (!supportsRouting) {
+            warnings.push(`Provider '${providerId}' protocol '${protocolRaw}' imported as non-routable in v1.`);
+        }
+        const models = (config.models ?? [])
+            .map((model) => {
+            if (!model.id) {
+                warnings.push(`Provider '${providerId}' has model without id; skipped.`);
+                return null;
+            }
+            const providerModelId = `${providerId}/${model.id}`;
+            const capabilities = toCapabilities(model.modalities ?? [], model.capabilities ?? {});
+            return {
+                providerModelId,
+                providerId,
+                modelId: model.id,
+                upstreamModel: model.upstream ?? model.id,
+                baseUrl: typeof model.baseUrl === "string" ? model.baseUrl : undefined,
+                apiKey: typeof model.apiKey === "string" ? model.apiKey : undefined,
+                insecureTls: model.insecureTls === true,
+                enabled: model.enabled !== false,
+                aliases: [],
+                free: model.free !== false,
+                modalities: model.modalities ?? [],
+                capabilities,
+                endpointType: inferEndpointType(capabilities),
+                benchmark: normalizeBenchmark(model.benchmark),
+                limits: model.limits,
+            };
+        })
+            .filter((model) => model !== null);
+        providers.push({
+            id: providerId,
+            name: config.name ?? entry.name ?? providerId,
+            description: config.description,
+            docs: config.docs,
+            protocol,
+            protocolRaw,
+            protocolConfig,
+            baseUrl,
+            insecureTls: previous?.insecureTls ?? (config.endpoint?.insecureTls === true),
+            autoInsecureTlsDomains: previous?.autoInsecureTlsDomains ?? (0, repository_1.normalizeDomainSuffixes)(config.autoInsecureTlsDomains),
+            enabled: previous?.enabled ?? true,
+            supportsRouting,
+            auth,
+            envVar,
+            apiKey,
+            limits: config.limits,
+            models,
+            warnings: supportsRouting ? undefined : [`Unsupported protocol: ${protocolRaw}`],
+            importedAt: new Date().toISOString(),
+        });
+    }
+    await (0, repository_1.saveProviderStore)(paths, providers);
+    return {
+        importedProviders: providers.length,
+        importedModels: providers.reduce((sum, provider) => sum + provider.models.length, 0),
+        warnings,
+        providers,
+    };
+}
+function parseAuthConfig(auth) {
+    if (!auth || typeof auth !== "object") {
+        return undefined;
+    }
+    const type = typeof auth.type === "string" ? auth.type.trim().toLowerCase() : "";
+    if (!type || !["bearer", "query", "header", "none"].includes(type)) {
+        return undefined;
+    }
+    return {
+        type: type,
+        keyParam: typeof auth.keyParam === "string" ? auth.keyParam : undefined,
+        headerName: typeof auth.headerName === "string" ? auth.headerName : undefined,
+        keyPrefix: typeof auth.keyPrefix === "string" ? auth.keyPrefix : undefined,
+    };
+}
+function parseProtocolConfig(config, protocol) {
+    if (protocol !== "inference_v2") {
+        return undefined;
+    }
+    const router = typeof config.endpoint?.router === "string"
+        ? config.endpoint.router.trim()
+        : undefined;
+    const responseTextPaths = extractStringArray(config.endpoint?.responseTextPaths ?? config.responseTextPaths);
+    return {
+        router: router && router.length > 0 ? router : undefined,
+        responseTextPaths: responseTextPaths.length > 0 ? responseTextPaths : undefined,
+    };
+}
+function extractStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
+        .filter((entry) => entry.length > 0);
+}
+function resolveApiKey(envVar, envMap, previous, overwriteAuth) {
+    if (!envVar) {
+        return previous;
+    }
+    const fromEnvFile = envMap[envVar];
+    const fromProcess = process.env[envVar];
+    const value = fromEnvFile ?? fromProcess;
+    if (!value && !previous) {
+        return undefined;
+    }
+    if (!overwriteAuth && previous) {
+        return previous;
+    }
+    return value ?? previous;
+}
+async function loadEnvMap(envFilePath) {
+    const loaded = {};
+    const candidates = envFilePath ? [envFilePath] : [];
+    for (const candidate of candidates) {
+        const fullPath = path_1.default.resolve(candidate);
+        try {
+            const raw = await fs_1.promises.readFile(fullPath, "utf8");
+            parseEnvInto(raw, loaded);
+            break;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+    return loaded;
+}
+function parseEnvInto(raw, out) {
+    const lines = raw.split("\n");
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) {
+            continue;
+        }
+        const equals = trimmed.indexOf("=");
+        if (equals <= 0) {
+            continue;
+        }
+        const key = trimmed.slice(0, equals).trim();
+        let value = trimmed.slice(equals + 1).trim();
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        if (key) {
+            out[key] = value;
+        }
+    }
+}
+function normalizeBenchmark(benchmark) {
+    if (!benchmark || typeof benchmark.livebench !== "number" || !Number.isFinite(benchmark.livebench)) {
+        return undefined;
+    }
+    return { livebench: benchmark.livebench };
+}
+function toCapabilities(modalities, caps) {
+    const input = new Set();
+    const output = new Set();
+    for (const modality of modalities) {
+        switch (modality) {
+            case "text-to-text":
+                input.add("text");
+                output.add("text");
+                break;
+            case "image-to-text":
+                input.add("image");
+                input.add("text");
+                output.add("text");
+                break;
+            case "text-to-image":
+                input.add("text");
+                output.add("image");
+                break;
+            case "audio-to-text":
+                input.add("audio");
+                output.add("text");
+                break;
+            case "text-to-audio":
+                input.add("text");
+                output.add("audio");
+                break;
+            case "text-to-embedding":
+                input.add("text");
+                output.add("embedding");
+                break;
+            case "text-to-video":
+                input.add("text");
+                output.add("video");
+                break;
+            case "image-to-video":
+                input.add("text");
+                input.add("image");
+                output.add("video");
+                break;
+            case "text-image-to-video":
+                input.add("text");
+                input.add("image");
+                output.add("video");
+                break;
+        }
+    }
+    if (input.size === 0 || output.size === 0) {
+        input.add("text");
+        output.add(caps.vision ? "text" : "text");
+    }
+    if (caps.vision && !input.has("image")) {
+        input.add("image");
+    }
+    return {
+        input: Array.from(input),
+        output: Array.from(output),
+        supportsTools: caps.tools,
+        supportsStreaming: caps.streaming,
+        source: "configured",
+    };
+}
+function inferEndpointType(capabilities) {
+    if (capabilities.output.includes("embedding")) {
+        return "embedding";
+    }
+    if (capabilities.output.includes("video")) {
+        return "video";
+    }
+    if (capabilities.output.includes("image")) {
+        return "diffusion";
+    }
+    if (capabilities.output.includes("audio")) {
+        return "audio";
+    }
+    return "llm";
+}

package/dist/src/providers/modelRegistry.js

@@ -0,0 +1,313 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listModelsForApi = listModelsForApi;
+exports.resolveModel = resolveModel;
+exports.pickBestProviderModelByCapabilities = pickBestProviderModelByCapabilities;
+exports.listModelAliases = listModelAliases;
+exports.getAvailableSmartPool = getAvailableSmartPool;
+const repository_1 = require("../pools/repository");
+const registry_1 = require("../protocols/registry");
+const modelCapabilities_1 = require("../utils/modelCapabilities");
+const repository_2 = require("./repository");
+const health_1 = require("./health");
+const SCORE_FALLBACK = 20;
+const SMART_ALIAS = "smart";
+async function listModelsForApi(paths, options) {
+    const providers = await (0, repository_2.listProviders)(paths);
+    const healthMap = await (0, health_1.getProviderModelHealthMap)(paths);
+    const entries = [];
+    for (const provider of providers) {
+        for (const model of provider.models) {
+            const health = healthMap[model.providerModelId];
+            const status = health?.status ?? "unknown";
+            if (options?.availableOnly && status === "down") {
+                continue;
+            }
+            const canonicalId = (0, repository_2.canonicalProviderModelId)(provider.id, model.modelId);
+            entries.push({
+                id: canonicalId,
+                provider_id: provider.id,
+                model_id: model.modelId,
+                provider_model_id: model.providerModelId,
+                object: "model",
+                owned_by: "waypoi",
+                endpoint_type: model.endpointType,
+                capabilities: model.capabilities,
+                enabled: provider.enabled && model.enabled !== false,
+                aliases: model.aliases ?? [],
+                slug: canonicalId,
+                waypoi_health: {
+                    status,
+                    lastCheckedAt: health?.lastCheckedAt ? new Date(health.lastCheckedAt).toISOString() : undefined,
+                    consecutiveFailures: health?.consecutiveFailures,
+                    latencyMsEwma: health?.latencyMsEwma,
+                },
+            });
+        }
+    }
+    return entries.sort((a, b) => a.id.localeCompare(b.id));
+}
+async function resolveModel(paths, inputId, requirements, routing) {
+    const pool = await (0, repository_1.getPoolByAlias)(paths, inputId);
+    if (pool) {
+        return { kind: "pool", alias: inputId };
+    }
+    const models = await flattenProviderModels(paths);
+    const healthMap = await (0, health_1.getProviderModelHealthMap)(paths);
+    const canonicalMatch = models.find((entry) => {
+        return entry.canonicalId === inputId || entry.model.providerModelId === inputId;
+    });
+    if (canonicalMatch) {
+        const candidates = await buildAndFilterCandidates(paths, [canonicalMatch], requirements, routing, healthMap);
+        return {
+            kind: "direct",
+            canonicalId: canonicalMatch.canonicalId,
+            candidates,
+        };
+    }
+    const aliasMatches = models.filter((entry) => {
+        if (entry.model.modelId === inputId) {
+            return true;
+        }
+        return Boolean(entry.model.aliases?.includes(inputId));
+    });
+    if (aliasMatches.length === 0) {
+        return { kind: "none", input: inputId };
+    }
+    if (aliasMatches.length > 1) {
+        return {
+            kind: "ambiguous",
+            input: inputId,
+            matches: aliasMatches.map((entry) => entry.canonicalId).sort(),
+        };
+    }
+    const winner = aliasMatches[0];
+    const candidates = await buildAndFilterCandidates(paths, [winner], requirements, routing, healthMap);
+    return {
+        kind: "direct",
+        canonicalId: winner.canonicalId,
+        candidates,
+    };
+}
+async function pickBestProviderModelByCapabilities(paths, requirements, preferredEndpointType) {
+    const all = await flattenProviderModels(paths);
+    const healthMap = await (0, health_1.getProviderModelHealthMap)(paths);
+    const filtered = all
+        .filter((entry) => entry.provider.enabled && entry.model.enabled !== false)
+        .filter((entry) => {
+        const health = healthMap[entry.model.providerModelId];
+        return health?.status !== "down";
+    })
+        .filter((entry) => (0, modelCapabilities_1.supportsRequirements)(entry.model.capabilities, requirements));
+    if (filtered.length === 0) {
+        return null;
+    }
+    const ranked = filtered.sort((a, b) => {
+        if (preferredEndpointType) {
+            const aPreferred = a.model.endpointType === preferredEndpointType ? 1 : 0;
+            const bPreferred = b.model.endpointType === preferredEndpointType ? 1 : 0;
+            if (aPreferred !== bPreferred) {
+                return bPreferred - aPreferred;
+            }
+        }
+        const aScore = typeof a.model.benchmark?.livebench === "number" ? a.model.benchmark.livebench : SCORE_FALLBACK;
+        const bScore = typeof b.model.benchmark?.livebench === "number" ? b.model.benchmark.livebench : SCORE_FALLBACK;
+        if (aScore !== bScore) {
+            return bScore - aScore;
+        }
+        return a.canonicalId.localeCompare(b.canonicalId);
+    });
+    return ranked[0].canonicalId;
+}
+async function listModelAliases(paths) {
+    const providers = await (0, repository_2.listProviders)(paths);
+    const aliases = new Set();
+    for (const provider of providers) {
+        for (const model of provider.models) {
+            for (const alias of model.aliases ?? []) {
+                aliases.add(alias);
+            }
+        }
+    }
+    const pools = await (0, repository_1.listPools)(paths);
+    for (const pool of pools) {
+        for (const alias of pool.aliases) {
+            if (alias === SMART_ALIAS) {
+                aliases.add(alias);
+            }
+        }
+    }
+    return Array.from(aliases).sort();
+}
+async function getAvailableSmartPool(paths) {
+    const pool = await (0, repository_1.getPoolByAlias)(paths, SMART_ALIAS);
+    if (!pool) {
+        return null;
+    }
+    const healthMap = await (0, health_1.getProviderModelHealthMap)(paths);
+    const candidates = pool.candidates.filter((candidate) => {
+        if (!candidate.providerEnabled || !candidate.modelEnabled || !candidate.supportsRouting) {
+            return false;
+        }
+        if (!candidate.baseUrl) {
+            return false;
+        }
+        if (!(0, registry_1.getProtocolAdapter)(candidate.protocol)) {
+            return false;
+        }
+        if (candidate.providerModelId) {
+            const health = healthMap[candidate.providerModelId];
+            if (health?.status === "down") {
+                return false;
+            }
+        }
+        const requiresApiKey = (candidate.auth?.type ?? "bearer") !== "none";
+        if (requiresApiKey && !candidate.apiKey) {
+            return false;
+        }
+        return true;
+    });
+    if (candidates.length === 0) {
+        return null;
+    }
+    return {
+        id: pool.id,
+        alias: SMART_ALIAS,
+        strategy: pool.strategy,
+        candidateCount: candidates.length,
+        capabilities: unionCapabilities(candidates),
+    };
+}
+async function flattenProviderModels(paths) {
+    const providers = await (0, repository_2.listProviders)(paths);
+    const flattened = [];
+    for (const provider of providers) {
+        for (const model of provider.models) {
+            flattened.push({
+                provider,
+                model,
+                canonicalId: (0, repository_2.canonicalProviderModelId)(provider.id, model.modelId),
+            });
+        }
+    }
+    return flattened;
+}
+async function buildAndFilterCandidates(paths, entries, requirements, routing, healthMap) {
+    const accepted = [];
+    const modelHealth = healthMap ?? (await (0, health_1.getProviderModelHealthMap)(paths));
+    for (const entry of entries) {
+        const candidate = buildCandidate(entry.provider, entry.model);
+        if (!candidate.providerEnabled || !candidate.modelEnabled) {
+            continue;
+        }
+        if (candidate.providerModelId) {
+            const health = modelHealth[candidate.providerModelId];
+            if (health?.status === "down") {
+                continue;
+            }
+        }
+        if (!candidate.baseUrl) {
+            continue;
+        }
+        const adapter = (0, registry_1.getProtocolAdapter)(candidate.protocol);
+        if (!candidate.supportsRouting || !adapter) {
+            continue;
+        }
+        const requiresApiKey = (candidate.auth?.type ?? "bearer") !== "none";
+        if (requiresApiKey && !candidate.apiKey) {
+            continue;
+        }
+        if (!(0, modelCapabilities_1.supportsRequirements)(candidate.capabilities, requirements)) {
+            continue;
+        }
+        if (routing) {
+            const support = adapter.supports({
+                operation: routing.operation,
+                stream: routing.stream,
+                capabilities: candidate.capabilities,
+                requiredInput: requirements.requiredInput,
+                requiredOutput: requirements.requiredOutput,
+            });
+            if (!support.supported) {
+                continue;
+            }
+        }
+        accepted.push(candidate);
+    }
+    return accepted.sort((a, b) => {
+        if (b.score !== a.score) {
+            return b.score - a.score;
+        }
+        return a.id.localeCompare(b.id);
+    });
+}
+function buildCandidate(provider, model) {
+    const score = model.benchmark?.livebench;
+    const baseUrl = model.baseUrl ?? provider.baseUrl;
+    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: baseUrl ?? "",
+        apiKey: model.apiKey ?? provider.apiKey,
+        insecureTls: (0, repository_2.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 : SCORE_FALLBACK,
+        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,
+        },
+    };
+}
+function unionCapabilities(candidates) {
+    const input = new Set();
+    const output = new Set();
+    let supportsTools = false;
+    let supportsStreaming = false;
+    for (const candidate of candidates) {
+        for (const modality of candidate.capabilities.input) {
+            input.add(modality);
+        }
+        for (const modality of candidate.capabilities.output) {
+            output.add(modality);
+        }
+        if (candidate.capabilities.supportsTools) {
+            supportsTools = true;
+        }
+        if (candidate.capabilities.supportsStreaming) {
+            supportsStreaming = true;
+        }
+    }
+    const capabilities = {
+        input: Array.from(input).sort(),
+        output: Array.from(output).sort(),
+        source: "inferred",
+    };
+    if (supportsTools) {
+        capabilities.supportsTools = true;
+    }
+    if (supportsStreaming) {
+        capabilities.supportsStreaming = true;
+    }
+    return capabilities;
+}