waypoi 0.0.0

package/dist/src/routing/router.js

@@ -0,0 +1,338 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routeRequest = routeRequest;
+const httpClient_1 = require("../transport/httpClient");
+const scheduler_1 = require("../pools/scheduler");
+const registry_1 = require("../protocols/registry");
+const modelRegistry_1 = require("../providers/modelRegistry");
+const repository_1 = require("../providers/repository");
+async function routeRequest(paths, publicModel, path, payload, headers, signal, requirements) {
+    const operation = (0, registry_1.routePathToOperation)(path);
+    const streamRequested = payload.stream === true;
+    const resolved = await (0, modelRegistry_1.resolveModel)(paths, publicModel, {
+        requiredInput: requirements?.requiredInput,
+        requiredOutput: requirements?.requiredOutput,
+    }, operation ? { operation, stream: streamRequested } : undefined);
+    if (resolved.kind === "ambiguous") {
+        const error = new Error(`Model '${resolved.input}' is ambiguous. Use canonical model ID: ${resolved.matches.join(", ")}`);
+        error.type = "invalid_request";
+        error.retryable = false;
+        throw error;
+    }
+    if (resolved.kind === "deprecated_pool_alias") {
+        const error = new Error(`Model alias '${resolved.input}' is deprecated. Use '${resolved.replacement}' instead.`);
+        error.type = "invalid_request";
+        error.retryable = false;
+        throw error;
+    }
+    if (resolved.kind === "none") {
+        const error = new Error(`Unknown model '${resolved.input}'`);
+        error.type = "no_endpoints";
+        error.retryable = false;
+        throw error;
+    }
+    if (resolved.kind === "pool") {
+        const poolSelection = await (0, scheduler_1.selectPoolCandidates)(paths, resolved.alias, {
+            requiredInput: requirements?.requiredInput,
+            requiredOutput: requirements?.requiredOutput,
+        }, operation ? { operation, stream: streamRequested } : undefined);
+        if (!poolSelection || poolSelection.candidates.length === 0) {
+            const exhaustedByLimits = poolSelection?.skipped.some((item) => item.reason === "cooldown" || item.reason === "request_budget_exhausted");
+            const streamUnsupported = poolSelection?.skipped.some((item) => item.reason === "stream_unsupported");
+            const error = new Error("No eligible endpoints for model");
+            error.type = exhaustedByLimits
+                ? "rate_limited"
+                : streamUnsupported
+                    ? "protocol_stream_unsupported"
+                    : "no_endpoints";
+            error.retryable = Boolean(exhaustedByLimits);
+            throw error;
+        }
+        return routeWithPoolCandidates(paths, resolved.alias, path, payload, headers, signal, poolSelection.pool.id, poolSelection.candidates, requirements, operation, streamRequested);
+    }
+    if (resolved.candidates.length === 0) {
+        const error = new Error("No eligible endpoints for model");
+        error.type = "no_endpoints";
+        error.retryable = false;
+        throw error;
+    }
+    return routeWithPoolCandidates(paths, resolved.canonicalId, path, payload, headers, signal, `model:${resolved.canonicalId}`, resolved.candidates, requirements, operation, streamRequested);
+}
+async function routeWithPoolCandidates(paths, publicModel, path, payload, headers, signal, poolId, candidates, requirements, operation, streamRequested) {
+    if (candidates.length === 0) {
+        const error = new Error("No eligible endpoints for model");
+        error.type = "no_endpoints";
+        error.retryable = false;
+        throw error;
+    }
+    let lastError = null;
+    let attempts = 0;
+    let rateLimitSwitches = 0;
+    const seenProviders = new Set();
+    const seenModels = new Set();
+    const triedModels = [];
+    const triedModelSet = new Set();
+    const isSmartAlias = publicModel === "smart";
+    for (const candidate of candidates) {
+        attempts += 1;
+        seenProviders.add(candidate.providerId);
+        seenModels.add(candidate.modelId);
+        const candidateName = `${candidate.providerId}/${candidate.modelId}`;
+        if (!triedModelSet.has(candidateName)) {
+            triedModelSet.add(candidateName);
+            triedModels.push(candidateName);
+        }
+        const endpoint = (0, scheduler_1.buildEndpointFromCandidate)(candidate);
+        const adapter = (0, registry_1.getProtocolAdapter)(candidate.protocol);
+        if (!adapter) {
+            continue;
+        }
+        const support = adapter.supports({
+            operation: operation ?? "chat_completions",
+            stream: streamRequested,
+            capabilities: candidate.capabilities,
+            requiredInput: requirements?.requiredInput,
+            requiredOutput: requirements?.requiredOutput,
+        });
+        if (!support.supported) {
+            continue;
+        }
+        const timeoutMs = candidate.limits?.timeoutMs ?? 60_000;
+        const start = Date.now();
+        await (0, scheduler_1.markPoolAttempt)(paths, candidate, (0, scheduler_1.estimateTokensFromPayload)(payload));
+        let requestData = null;
+        try {
+            requestData = await adapter.buildRequest({
+                paths,
+                operation: operation ?? "chat_completions",
+                stream: streamRequested,
+                path,
+                payload: { ...payload, model: candidate.upstreamModel },
+                publicModel,
+                upstreamModel: candidate.upstreamModel,
+                endpoint,
+                auth: candidate.auth,
+                config: candidate.protocolConfig,
+            });
+            const response = await (0, httpClient_1.proxyUpstream)(endpoint, requestData.path, requestData.payload, mergeForwardHeaders(headers, requestData.headers), timeoutMs, signal, { skipDefaultAuth: requestData.skipDefaultAuth });
+            const latency = Date.now() - start;
+            const classification = (0, httpClient_1.classifyHttpStatus)(response.statusCode);
+            if (isSmartAlias && shouldFailoverForIncompatibleStatus(response.statusCode)) {
+                await (0, scheduler_1.markPoolFailure)(paths, candidate, {
+                    error: `operation_unsupported_${response.statusCode}`,
+                    headers: response.headers,
+                });
+                await drainBody(response.body);
+                lastError = new Error(`Incompatible status ${response.statusCode}`);
+                lastError.type = classification.type;
+                lastError.retryable = true;
+                continue;
+            }
+            if (classification.retryable) {
+                if (response.statusCode === 429) {
+                    rateLimitSwitches += 1;
+                }
+                await (0, scheduler_1.markPoolFailure)(paths, candidate, {
+                    error: classification.type,
+                    rateLimited: response.statusCode === 429,
+                    headers: response.headers,
+                });
+                await drainBody(response.body);
+                lastError = new Error(`Retryable status ${response.statusCode}`);
+                lastError.type = classification.type;
+                lastError.retryable = true;
+                continue;
+            }
+            const normalizedResponse = await maybeNormalizeResponse(adapter, {
+                operation: operation ?? "chat_completions",
+                stream: streamRequested,
+                path,
+                publicModel,
+                upstreamModel: candidate.upstreamModel,
+                requestPayload: requestData.payload,
+                upstreamResult: response,
+                config: candidate.protocolConfig,
+            }, response);
+            await (0, scheduler_1.markPoolSuccess)(paths, candidate, latency);
+            return {
+                attempt: {
+                    endpoint,
+                    upstreamModel: candidate.upstreamModel,
+                    response: normalizedResponse,
+                    pool: {
+                        id: poolId,
+                        alias: publicModel,
+                        candidateAttempts: attempts,
+                        failovers: Math.max(0, attempts - 1),
+                        rateLimitSwitches,
+                        distinctProviders: seenProviders.size,
+                        distinctModels: seenModels.size,
+                    },
+                },
+                retryable: false,
+            };
+        }
+        catch (error) {
+            let classified = (0, httpClient_1.classifyUpstreamError)(error);
+            if (classified.type === "tls_verify_failed" &&
+                endpoint.insecureTls !== true &&
+                requestData &&
+                isHostnameAllowlisted(candidate)) {
+                const insecureEndpoint = { ...endpoint, insecureTls: true };
+                await (0, scheduler_1.markPoolAttempt)(paths, candidate, (0, scheduler_1.estimateTokensFromPayload)(payload));
+                try {
+                    const retryResponse = await (0, httpClient_1.proxyUpstream)(insecureEndpoint, requestData.path, requestData.payload, mergeForwardHeaders(headers, requestData.headers), timeoutMs, signal, { skipDefaultAuth: requestData.skipDefaultAuth });
+                    const latency = Date.now() - start;
+                    const retryClassification = (0, httpClient_1.classifyHttpStatus)(retryResponse.statusCode);
+                    if (isSmartAlias && shouldFailoverForIncompatibleStatus(retryResponse.statusCode)) {
+                        await (0, scheduler_1.markPoolFailure)(paths, candidate, {
+                            error: `operation_unsupported_${retryResponse.statusCode}`,
+                            headers: retryResponse.headers,
+                        });
+                        await drainBody(retryResponse.body);
+                        lastError = new Error(`Incompatible status ${retryResponse.statusCode}`);
+                        lastError.type = retryClassification.type;
+                        lastError.retryable = true;
+                        continue;
+                    }
+                    if (retryClassification.retryable) {
+                        if (retryResponse.statusCode === 429) {
+                            rateLimitSwitches += 1;
+                        }
+                        await (0, scheduler_1.markPoolFailure)(paths, candidate, {
+                            error: retryClassification.type,
+                            rateLimited: retryResponse.statusCode === 429,
+                            headers: retryResponse.headers,
+                        });
+                        await drainBody(retryResponse.body);
+                        lastError = new Error(`Retryable status ${retryResponse.statusCode}`);
+                        lastError.type = retryClassification.type;
+                        lastError.retryable = true;
+                        continue;
+                    }
+                    const normalizedRetryResponse = await maybeNormalizeResponse(adapter, {
+                        operation: operation ?? "chat_completions",
+                        stream: streamRequested,
+                        path,
+                        publicModel,
+                        upstreamModel: candidate.upstreamModel,
+                        requestPayload: requestData.payload,
+                        upstreamResult: retryResponse,
+                        config: candidate.protocolConfig,
+                    }, retryResponse);
+                    if (retryClassification.type === "ok") {
+                        await (0, repository_1.setProviderModelInsecureTls)(paths, candidate.providerId, candidate.providerModelId ?? candidate.modelId, true);
+                    }
+                    await (0, scheduler_1.markPoolSuccess)(paths, candidate, latency);
+                    return {
+                        attempt: {
+                            endpoint: insecureEndpoint,
+                            upstreamModel: candidate.upstreamModel,
+                            response: normalizedRetryResponse,
+                            pool: {
+                                id: poolId,
+                                alias: publicModel,
+                                candidateAttempts: attempts,
+                                failovers: Math.max(0, attempts - 1),
+                                rateLimitSwitches,
+                                distinctProviders: seenProviders.size,
+                                distinctModels: seenModels.size,
+                            },
+                        },
+                        retryable: false,
+                    };
+                }
+                catch (retryError) {
+                    classified = (0, httpClient_1.classifyUpstreamError)(retryError);
+                }
+            }
+            if (classified.type === "tls_verify_failed") {
+                classified.message = tlsVerifyFailureMessage(candidate);
+            }
+            lastError = classified;
+            await (0, scheduler_1.markPoolFailure)(paths, candidate, {
+                error: classified.type,
+                rateLimited: classified.type === "rate_limited",
+            });
+            if (!classified.retryable) {
+                throw maybeEnrichSmartError(classified, triedModels, poolId, isSmartAlias);
+            }
+        }
+    }
+    if (lastError) {
+        throw maybeEnrichSmartError(lastError, triedModels, poolId, isSmartAlias);
+    }
+    const error = new Error("No endpoints succeeded");
+    error.type = "no_endpoints";
+    error.retryable = true;
+    throw maybeEnrichSmartError(error, triedModels, poolId, isSmartAlias);
+}
+function shouldFailoverForIncompatibleStatus(statusCode) {
+    return statusCode === 404 || statusCode === 405 || statusCode === 501;
+}
+function maybeEnrichSmartError(error, triedModels, poolId, shouldEnrich) {
+    if (!shouldEnrich) {
+        return error;
+    }
+    error.poolId = poolId;
+    error.triedModels = triedModels.slice(0, 10);
+    if (error.triedModels.length > 0) {
+        error.message = `Smart routing failed. Tried models: ${error.triedModels.join(", ")}. Cause: ${error.message}`;
+    }
+    else {
+        error.message = `Smart routing failed. No eligible models. Cause: ${error.message}`;
+    }
+    return error;
+}
+function isHostnameAllowlisted(candidate) {
+    const allowlist = candidate.autoInsecureTlsDomains ?? [];
+    if (allowlist.length === 0) {
+        return false;
+    }
+    const hostname = getHostname(candidate.baseUrl);
+    if (!hostname) {
+        return false;
+    }
+    return allowlist.some((suffix) => matchesDomainSuffix(hostname, suffix));
+}
+function getHostname(baseUrl) {
+    try {
+        return new URL(baseUrl).hostname.toLowerCase();
+    }
+    catch {
+        return null;
+    }
+}
+function matchesDomainSuffix(hostname, suffix) {
+    const normalizedSuffix = suffix.trim().toLowerCase();
+    if (!normalizedSuffix) {
+        return false;
+    }
+    return hostname === normalizedSuffix || hostname.endsWith(`.${normalizedSuffix}`);
+}
+function tlsVerifyFailureMessage(candidate) {
+    return `Upstream TLS verify failed for ${candidate.providerId}/${candidate.modelId}. Configure provider/model insecureTls or provider allowlist.`;
+}
+async function maybeNormalizeResponse(adapter, context, fallback) {
+    if (!adapter.normalizeResponse) {
+        return fallback;
+    }
+    return adapter.normalizeResponse(context);
+}
+async function drainBody(stream) {
+    return new Promise((resolve) => {
+        stream.on("end", resolve);
+        stream.on("close", resolve);
+        stream.on("error", resolve);
+        stream.resume();
+    });
+}
+function mergeForwardHeaders(base, extras) {
+    if (!extras || Object.keys(extras).length === 0) {
+        return base;
+    }
+    return {
+        ...base,
+        ...extras,
+    };
+}

package/dist/src/services/imageGeneration.js

@@ -0,0 +1,280 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveGenerationModel = resolveGenerationModel;
+exports.runImageGeneration = runImageGeneration;
+exports.normalizeImageGenerationPayload = normalizeImageGenerationPayload;
+exports.normalizeChatImagePayload = normalizeChatImagePayload;
+const router_1 = require("../routing/router");
+const scheduler_1 = require("../pools/scheduler");
+const modelRegistry_1 = require("../providers/modelRegistry");
+const imageCache_1 = require("../storage/imageCache");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+async function resolveGenerationModel(paths, requestedModel) {
+    if (requestedModel) {
+        return requestedModel;
+    }
+    // Keep compatibility with existing /v1/images/generations fallback behavior.
+    return pickDefaultDiffusionModel(paths);
+}
+async function runImageGeneration(paths, request, headers, signal) {
+    const model = request.model
+        ? request.model
+        : request.image_url
+            ? await pickDefaultImageEditModel(paths)
+            : await resolveGenerationModel(paths, request.model);
+    if (!model) {
+        const error = new Error("No diffusion model available. Add or enable a provider model.");
+        error.type = "no_diffusion_model";
+        error.retryable = false;
+        throw error;
+    }
+    let body;
+    let outcome;
+    if (request.image_url) {
+        const chatPayload = {
+            model,
+            stream: false,
+            messages: [
+                {
+                    role: "user",
+                    content: [
+                        { type: "text", text: request.prompt },
+                        { type: "image_url", image_url: { url: request.image_url } },
+                    ],
+                },
+            ],
+        };
+        try {
+            outcome = await (0, router_1.routeRequest)(paths, model, "/v1/chat/completions", chatPayload, headers, signal, {
+                requiredInput: ["text", "image"],
+                requiredOutput: ["image"],
+            });
+        }
+        catch (error) {
+            const typed = error;
+            if (typed.type !== "no_endpoints") {
+                throw error;
+            }
+            outcome = await (0, router_1.routeRequest)(paths, model, "/v1/chat/completions", chatPayload, headers, signal, {
+                requiredInput: ["text"],
+                requiredOutput: ["image"],
+            });
+        }
+        body = await readBody(outcome.attempt.response);
+        body.payload = normalizeChatImagePayload(body.payload);
+    }
+    else {
+        outcome = await (0, router_1.routeRequest)(paths, model, "/v1/images/generations", { ...request, model }, headers, signal, {
+            endpointType: "diffusion",
+            requiredInput: ["text"],
+            requiredOutput: ["image"],
+        });
+        body = await readBody(outcome.attempt.response);
+    }
+    return {
+        model,
+        statusCode: outcome.attempt.response.statusCode,
+        headers: outcome.attempt.response.headers,
+        payload: body.payload,
+        route: {
+            endpointId: outcome.attempt.endpoint.id,
+            endpointName: outcome.attempt.endpoint.name,
+            upstreamModel: outcome.attempt.upstreamModel,
+        },
+    };
+}
+async function normalizeImageGenerationPayload(paths, payload, model) {
+    const asObject = (payload ?? {});
+    const created = typeof asObject.created === "number" ? asObject.created : Math.floor(Date.now() / 1000);
+    const data = Array.isArray(asObject.data) ? asObject.data : [];
+    const images = [];
+    for (let index = 0; index < data.length; index += 1) {
+        const item = (data[index] ?? {});
+        const entry = { index };
+        if (typeof item.revised_prompt === "string" && item.revised_prompt.length > 0) {
+            entry.revised_prompt = item.revised_prompt;
+        }
+        if (typeof item.b64_json === "string" && item.b64_json.length > 0) {
+            entry.b64_json = item.b64_json;
+        }
+        if (typeof item.url === "string" && item.url.length > 0) {
+            entry.url = item.url;
+        }
+        if (!entry.b64_json && entry.url) {
+            const extracted = await tryExtractBase64FromUrl(paths, entry.url);
+            if (extracted) {
+                entry.b64_json = extracted.b64;
+                if (!entry.url.startsWith("data:")) {
+                    entry.url = `data:${extracted.mimeType};base64,${extracted.b64}`;
+                }
+            }
+        }
+        if (!entry.url && entry.b64_json) {
+            entry.url = `data:image/png;base64,${entry.b64_json}`;
+        }
+        images.push(entry);
+    }
+    return { model, created, images };
+}
+function normalizeChatImagePayload(payload) {
+    const root = payload;
+    const created = typeof root?.created === "number" ? root.created : Math.floor(Date.now() / 1000);
+    const choices = Array.isArray(root?.choices) ? root.choices : [];
+    const firstChoice = (choices[0] ?? null);
+    const content = firstChoice?.message?.content;
+    const data = [];
+    let revisedPrompt;
+    if (Array.isArray(content)) {
+        for (const item of content) {
+            if (!item || typeof item !== "object") {
+                continue;
+            }
+            const typed = item;
+            const type = typeof typed.type === "string" ? typed.type : "";
+            if (!revisedPrompt && type === "text" && typeof typed.text === "string") {
+                revisedPrompt = typed.text.trim() || undefined;
+            }
+            if (type === "image_url") {
+                const imageUrlObject = typed.image_url;
+                if (typeof imageUrlObject?.url === "string" && imageUrlObject.url.length > 0) {
+                    data.push({ url: imageUrlObject.url });
+                }
+            }
+            else if (type === "image" && typeof typed.image === "string" && typed.image.length > 0) {
+                data.push({ url: typed.image });
+            }
+        }
+    }
+    if (typeof content === "string" && content.startsWith("data:image/")) {
+        data.push({ url: content });
+    }
+    if (data.length === 0) {
+        const error = new Error("Upstream chat completion did not return any image output.");
+        error.type = "invalid_upstream_response";
+        error.retryable = true;
+        throw error;
+    }
+    if (revisedPrompt) {
+        data[0].revised_prompt = revisedPrompt;
+    }
+    return { created, data };
+}
+async function pickDefaultDiffusionModel(paths) {
+    const smart = await (0, scheduler_1.selectPoolCandidates)(paths, "smart", {
+        requiredInput: ["text"],
+        requiredOutput: ["image"],
+    }, {
+        operation: "images_generation",
+        stream: false,
+    });
+    if (smart && smart.candidates.length > 0) {
+        return "smart";
+    }
+    const byCapabilities = await (0, modelRegistry_1.pickBestProviderModelByCapabilities)(paths, { requiredInput: ["text"], requiredOutput: ["image"] }, "diffusion");
+    if (byCapabilities) {
+        return byCapabilities;
+    }
+    return null;
+}
+async function pickDefaultImageEditModel(paths) {
+    const smart = await (0, scheduler_1.selectPoolCandidates)(paths, "smart", {
+        requiredInput: ["image", "text"],
+        requiredOutput: ["image"],
+    }, {
+        operation: "images_edits",
+        stream: false,
+    });
+    if (smart && smart.candidates.length > 0) {
+        return "smart";
+    }
+    const byCapabilities = await (0, modelRegistry_1.pickBestProviderModelByCapabilities)(paths, { requiredInput: ["image"], requiredOutput: ["image"] }, "diffusion");
+    if (byCapabilities) {
+        return byCapabilities;
+    }
+    return pickDefaultDiffusionModel(paths);
+}
+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 = normalizeContentType(response.headers);
+    if (contentType.includes("application/json")) {
+        try {
+            return { payload: JSON.parse(buffer.toString("utf8")) };
+        }
+        catch {
+            return { payload: buffer };
+        }
+    }
+    return { payload: buffer };
+}
+function normalizeContentType(headers) {
+    const ct = headers["content-type"] ?? headers["Content-Type"];
+    if (Array.isArray(ct))
+        return ct.join(", ");
+    return ct ?? "";
+}
+async function tryExtractBase64FromUrl(paths, url) {
+    if (url.startsWith("data:")) {
+        const match = url.match(/^data:([^;]+);base64,(.+)$/i);
+        if (!match)
+            return null;
+        return { mimeType: match[1], b64: match[2].replace(/\s+/g, "") };
+    }
+    const hash = extractLocalHash(url);
+    if (!hash)
+        return null;
+    const mediaPath = await (0, imageCache_1.getMediaPath)(paths, hash);
+    const mediaEntry = await (0, imageCache_1.getMediaEntry)(paths, hash);
+    if (!mediaPath)
+        return null;
+    const buffer = await fs_1.promises.readFile(mediaPath);
+    const mimeType = mediaEntry?.mimeType ?? mimeFromExt(mediaPath);
+    return { mimeType, b64: buffer.toString("base64") };
+}
+function extractLocalHash(url) {
+    const normalized = normalizeLocalUrl(url);
+    if (!normalized) {
+        return null;
+    }
+    const mediaMatch = normalized.match(/^\/admin\/(media|images)\/([a-f0-9]{16})$/i);
+    if (!mediaMatch) {
+        return null;
+    }
+    return mediaMatch[2];
+}
+function normalizeLocalUrl(url) {
+    if (url.startsWith("/")) {
+        return url;
+    }
+    try {
+        const parsed = new URL(url);
+        if (!["http:", "https:"].includes(parsed.protocol)) {
+            return null;
+        }
+        if (!["localhost", "127.0.0.1", "::1"].includes(parsed.hostname)) {
+            return null;
+        }
+        return parsed.pathname;
+    }
+    catch {
+        return null;
+    }
+}
+function mimeFromExt(filePath) {
+    const ext = path_1.default.extname(filePath).slice(1).toLowerCase();
+    const map = {
+        png: "image/png",
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        gif: "image/gif",
+        webp: "image/webp",
+    };
+    return map[ext] ?? "application/octet-stream";
+}