waypoi 0.0.0

package/dist/src/pools/scheduler.js

@@ -0,0 +1,360 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectPoolCandidates = selectPoolCandidates;
+exports.markPoolAttempt = markPoolAttempt;
+exports.markPoolSuccess = markPoolSuccess;
+exports.markPoolFailure = markPoolFailure;
+exports.buildEndpointFromCandidate = buildEndpointFromCandidate;
+exports.estimateTokensFromPayload = estimateTokensFromPayload;
+exports.deriveCooldownMsFromHeaders = deriveCooldownMsFromHeaders;
+const files_1 = require("../storage/files");
+const modelCapabilities_1 = require("../utils/modelCapabilities");
+const registry_1 = require("../protocols/registry");
+const repository_1 = require("./repository");
+const health_1 = require("../providers/health");
+const DEFAULT_COOLDOWN_MS = 60_000;
+async function selectPoolCandidates(paths, alias, requirements, routing) {
+    const pool = await (0, repository_1.getPoolByAlias)(paths, alias);
+    if (!pool) {
+        return null;
+    }
+    const healthMap = await (0, health_1.getProviderModelHealthMap)(paths);
+    const state = await (0, repository_1.loadPoolState)(paths);
+    const now = Date.now();
+    const skipped = [];
+    const candidates = [];
+    for (const candidate of pool.candidates) {
+        const candidateState = getCandidateState(state.candidates, candidate.id);
+        refreshWindows(candidateState, now);
+        const adapter = (0, registry_1.getProtocolAdapter)(candidate.protocol);
+        if (!candidate.supportsRouting || !adapter) {
+            skipped.push({ candidateId: candidate.id, reason: "unsupported_protocol" });
+            continue;
+        }
+        if (!candidate.baseUrl) {
+            skipped.push({ candidateId: candidate.id, reason: "missing_base_url" });
+            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) {
+                skipped.push({
+                    candidateId: candidate.id,
+                    reason: support.reason ?? "unsupported_operation",
+                });
+                continue;
+            }
+        }
+        const requiresApiKey = (candidate.auth?.type ?? "bearer") !== "none";
+        if (requiresApiKey && !candidate.apiKey) {
+            skipped.push({ candidateId: candidate.id, reason: "missing_api_key" });
+            continue;
+        }
+        if (!candidate.providerEnabled) {
+            skipped.push({ candidateId: candidate.id, reason: "provider_disabled" });
+            continue;
+        }
+        if (!candidate.modelEnabled) {
+            skipped.push({ candidateId: candidate.id, reason: "model_disabled" });
+            continue;
+        }
+        if (candidate.providerModelId) {
+            const health = healthMap[candidate.providerModelId];
+            if (health?.status === "down") {
+                skipped.push({ candidateId: candidate.id, reason: "health_down" });
+                continue;
+            }
+        }
+        if (requirements &&
+            !(0, modelCapabilities_1.supportsRequirements)(candidate.capabilities, {
+                requiredInput: requirements.requiredInput,
+                requiredOutput: requirements.requiredOutput,
+            })) {
+            skipped.push({ candidateId: candidate.id, reason: "capability_mismatch" });
+            continue;
+        }
+        if (candidateState.cooldownUntil && new Date(candidateState.cooldownUntil).getTime() > now) {
+            skipped.push({ candidateId: candidate.id, reason: "cooldown" });
+            continue;
+        }
+        if (isRequestBudgetExhausted(candidate, candidateState)) {
+            skipped.push({ candidateId: candidate.id, reason: "request_budget_exhausted" });
+            continue;
+        }
+        candidates.push(candidate);
+    }
+    candidates.sort((a, b) => {
+        if (b.score !== a.score) {
+            return b.score - a.score;
+        }
+        const aState = getCandidateState(state.candidates, a.id);
+        const bState = getCandidateState(state.candidates, b.id);
+        const aFailureRatio = failureRatio(aState);
+        const bFailureRatio = failureRatio(bState);
+        if (aFailureRatio !== bFailureRatio) {
+            return aFailureRatio - bFailureRatio;
+        }
+        const aLatency = aState.latencyMsEwma ?? Number.POSITIVE_INFINITY;
+        const bLatency = bState.latencyMsEwma ?? Number.POSITIVE_INFINITY;
+        if (aLatency !== bLatency) {
+            return aLatency - bLatency;
+        }
+        return `${a.providerId}/${a.modelId}`.localeCompare(`${b.providerId}/${b.modelId}`);
+    });
+    await (0, repository_1.savePoolState)(paths, state);
+    return {
+        pool,
+        candidates,
+        skipped,
+    };
+}
+async function markPoolAttempt(paths, candidate, estimatedTokens) {
+    const state = await (0, repository_1.loadPoolState)(paths);
+    const entry = getCandidateState(state.candidates, candidate.id);
+    const now = Date.now();
+    refreshWindows(entry, now);
+    entry.attempts += 1;
+    entry.minuteRequests += 1;
+    entry.dayRequests += 1;
+    if (estimatedTokens > 0) {
+        entry.minuteTokens += estimatedTokens;
+        entry.dayTokens += estimatedTokens;
+    }
+    entry.lastUsedAt = new Date(now).toISOString();
+    await (0, repository_1.savePoolState)(paths, state);
+}
+async function markPoolSuccess(paths, candidate, latencyMs, consumedTokens = 0) {
+    const state = await (0, repository_1.loadPoolState)(paths);
+    const entry = getCandidateState(state.candidates, candidate.id);
+    const now = Date.now();
+    refreshWindows(entry, now);
+    entry.successes += 1;
+    entry.lastError = undefined;
+    entry.cooldownUntil = undefined;
+    entry.latencyMsEwma = ewma(entry.latencyMsEwma, latencyMs);
+    entry.lastUsedAt = new Date(now).toISOString();
+    if (consumedTokens > 0) {
+        entry.minuteTokens += consumedTokens;
+        entry.dayTokens += consumedTokens;
+    }
+    await (0, repository_1.savePoolState)(paths, state);
+}
+async function markPoolFailure(paths, candidate, details) {
+    const state = await (0, repository_1.loadPoolState)(paths);
+    const entry = getCandidateState(state.candidates, candidate.id);
+    const now = Date.now();
+    refreshWindows(entry, now);
+    entry.failures += 1;
+    entry.lastError = details.error;
+    entry.lastUsedAt = new Date(now).toISOString();
+    if (details.rateLimited) {
+        entry.rateLimitHits += 1;
+        const cooldownMs = deriveCooldownMsFromHeaders(details.headers ?? {}, DEFAULT_COOLDOWN_MS);
+        entry.cooldownUntil = new Date(now + cooldownMs).toISOString();
+    }
+    else if (entry.failures >= 3) {
+        entry.cooldownUntil = new Date(now + 30_000).toISOString();
+    }
+    await (0, repository_1.savePoolState)(paths, state);
+}
+function buildEndpointFromCandidate(candidate) {
+    const now = new Date();
+    return {
+        id: `pool:${candidate.id}`,
+        name: `${candidate.providerName}/${candidate.modelId}`,
+        baseUrl: candidate.baseUrl,
+        apiKey: candidate.apiKey,
+        disabled: false,
+        insecureTls: candidate.insecureTls === true,
+        priority: 0,
+        type: candidate.endpointType,
+        models: [
+            {
+                publicName: candidate.modelId,
+                upstreamModel: candidate.upstreamModel,
+                capabilities: candidate.capabilities,
+            },
+        ],
+        health: (0, files_1.defaultHealth)(),
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+function estimateTokensFromPayload(payload) {
+    const maxTokens = payload.max_tokens;
+    if (typeof maxTokens === "number" && Number.isFinite(maxTokens) && maxTokens > 0) {
+        return Math.floor(maxTokens);
+    }
+    return 0;
+}
+function deriveCooldownMsFromHeaders(headers, fallbackMs) {
+    const retryAfter = headerValue(headers, "retry-after");
+    if (retryAfter) {
+        const asNumber = Number(retryAfter);
+        if (Number.isFinite(asNumber) && asNumber >= 0) {
+            return Math.max(1_000, asNumber * 1_000);
+        }
+        const asDate = Date.parse(retryAfter);
+        if (Number.isFinite(asDate)) {
+            return Math.max(1_000, asDate - Date.now());
+        }
+    }
+    const resetKeys = ["x-ratelimit-reset", "x-ratelimit-reset-requests", "ratelimit-reset"];
+    for (const key of resetKeys) {
+        const value = headerValue(headers, key);
+        if (!value) {
+            continue;
+        }
+        const parsed = Number(value);
+        if (!Number.isFinite(parsed)) {
+            continue;
+        }
+        if (parsed > 1_000_000_000) {
+            return Math.max(1_000, parsed * 1_000 - Date.now());
+        }
+        return Math.max(1_000, parsed * 1_000);
+    }
+    return fallbackMs;
+}
+function headerValue(headers, key) {
+    const exact = headers[key];
+    if (typeof exact === "string") {
+        return exact;
+    }
+    if (Array.isArray(exact) && exact.length > 0) {
+        return exact[0];
+    }
+    const found = Object.entries(headers).find(([name]) => name.toLowerCase() === key.toLowerCase());
+    if (!found) {
+        return undefined;
+    }
+    const value = found[1];
+    if (typeof value === "string") {
+        return value;
+    }
+    if (Array.isArray(value) && value.length > 0) {
+        return value[0];
+    }
+    return undefined;
+}
+function getCandidateState(states, candidateId) {
+    const existing = states[candidateId];
+    if (existing) {
+        return existing;
+    }
+    const created = {
+        candidateId,
+        attempts: 0,
+        successes: 0,
+        failures: 0,
+        rateLimitHits: 0,
+        minuteRequests: 0,
+        minuteTokens: 0,
+        hourRequests: 0,
+        hourTokens: 0,
+        dayRequests: 0,
+        dayTokens: 0,
+        weekRequests: 0,
+        weekTokens: 0,
+    };
+    states[candidateId] = created;
+    return created;
+}
+function refreshWindows(state, now) {
+    const minuteStart = state.minuteWindowStartedAt
+        ? new Date(state.minuteWindowStartedAt).getTime()
+        : Number.NaN;
+    if (!Number.isFinite(minuteStart) || now - minuteStart >= 60_000) {
+        state.minuteWindowStartedAt = new Date(now).toISOString();
+        state.minuteRequests = 0;
+        state.minuteTokens = 0;
+    }
+    const hourStart = state.hourWindowStartedAt
+        ? new Date(state.hourWindowStartedAt).getTime()
+        : Number.NaN;
+    if (!Number.isFinite(hourStart) || now - hourStart >= 3_600_000) {
+        state.hourWindowStartedAt = new Date(now).toISOString();
+        state.hourRequests = 0;
+        state.hourTokens = 0;
+    }
+    const dayStart = state.dayWindowStartedAt
+        ? new Date(state.dayWindowStartedAt).getTime()
+        : Number.NaN;
+    if (!Number.isFinite(dayStart) || now - dayStart >= 86_400_000) {
+        state.dayWindowStartedAt = new Date(now).toISOString();
+        state.dayRequests = 0;
+        state.dayTokens = 0;
+    }
+    const weekStart = state.weekWindowStartedAt
+        ? new Date(state.weekWindowStartedAt).getTime()
+        : Number.NaN;
+    if (!Number.isFinite(weekStart) || now - weekStart >= 604_800_000) {
+        state.weekWindowStartedAt = new Date(now).toISOString();
+        state.weekRequests = 0;
+        state.weekTokens = 0;
+    }
+    if (state.cooldownUntil && new Date(state.cooldownUntil).getTime() <= now) {
+        state.cooldownUntil = undefined;
+    }
+}
+function isRequestBudgetExhausted(candidate, state) {
+    if (typeof candidate.limits?.requestsPerMinute === "number") {
+        if (state.minuteRequests >= candidate.limits.requestsPerMinute) {
+            return true;
+        }
+    }
+    if (typeof candidate.limits?.requestsPerHour === "number") {
+        if (state.hourRequests >= candidate.limits.requestsPerHour) {
+            return true;
+        }
+    }
+    if (typeof candidate.limits?.requestsPerDay === "number") {
+        if (state.dayRequests >= candidate.limits.requestsPerDay) {
+            return true;
+        }
+    }
+    if (typeof candidate.limits?.requestsPerWeek === "number") {
+        if (state.weekRequests >= candidate.limits.requestsPerWeek) {
+            return true;
+        }
+    }
+    if (typeof candidate.limits?.tokensPerMinute === "number") {
+        if (state.minuteTokens >= candidate.limits.tokensPerMinute) {
+            return true;
+        }
+    }
+    if (typeof candidate.limits?.tokensPerHour === "number") {
+        if (state.hourTokens >= candidate.limits.tokensPerHour) {
+            return true;
+        }
+    }
+    if (typeof candidate.limits?.tokensPerDay === "number") {
+        if (state.dayTokens >= candidate.limits.tokensPerDay) {
+            return true;
+        }
+    }
+    if (typeof candidate.limits?.tokensPerWeek === "number") {
+        if (state.weekTokens >= candidate.limits.tokensPerWeek) {
+            return true;
+        }
+    }
+    return false;
+}
+function failureRatio(state) {
+    if (state.attempts <= 0) {
+        return 0;
+    }
+    return state.failures / state.attempts;
+}
+function ewma(previous, next, alpha = 0.2) {
+    if (previous === undefined) {
+        return next;
+    }
+    return alpha * next + (1 - alpha) * previous;
+}

package/dist/src/pools/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/protocols/adapters/dashscope.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dashscopeProtocolAdapter = void 0;
+const ALL_OPERATIONS = [
+    "images_generation",
+    "images_edits",
+    "video_generations",
+];
+const STREAM_OPERATIONS = [];
+const DASHSCOPE_IMAGE_GEN_PATH = "/api/v1/services/aigc/image-generation/generation";
+const DASHSCOPE_VIDEO_GEN_PATH = "/api/v1/services/aigc/video-generation/video-synthesis";
+const DASHSCOPE_TASK_QUERY_PATH = "/api/v1/tasks";
+const DASHSCOPE_MULTIMODAL_GEN_PATH = "/api/v1/services/aigc/multimodal-generation/generation";
+const TASK_POLL_INTERVAL_MS = 5000;
+const TASK_POLL_TIMEOUT_MS = 300000;
+exports.dashscopeProtocolAdapter = {
+    id: "dashscope",
+    supportedOperations: [...ALL_OPERATIONS],
+    streamSupportedOperations: [...STREAM_OPERATIONS],
+    supports(context) {
+        if (!ALL_OPERATIONS.includes(context.operation)) {
+            return { supported: false, reason: "unsupported_operation" };
+        }
+        if (context.stream) {
+            return { supported: false, reason: "stream_unsupported" };
+        }
+        return { supported: true };
+    },
+    async buildRequest(context) {
+        const { operation, payload, upstreamModel } = context;
+        if (operation === "images_generation" || operation === "images_edits") {
+            return buildImageRequest(payload, upstreamModel);
+        }
+        if (operation === "video_generations") {
+            return buildVideoRequest(payload, upstreamModel);
+        }
+        throw new Error(`Unsupported operation for dashscope: ${operation}`);
+    },
+    async normalizeResponse(context) {
+        const { operation, upstreamResult } = context;
+        if (operation === "images_generation" || operation === "images_edits") {
+            return normalizeImageResponse(upstreamResult);
+        }
+        if (operation === "video_generations") {
+            return normalizeVideoResponse(upstreamResult);
+        }
+        throw new Error(`Unsupported operation for dashscope: ${operation}`);
+    },
+};
+function buildImageRequest(payload, model) {
+    const prompt = payload.prompt ?? "";
+    const negativePrompt = payload.negative_prompt ?? "";
+    const imageUrl = payload.image_url;
+    const n = payload.n ?? 1;
+    const size = payload.size ?? "1K";
+    const seed = payload.seed;
+    const watermark = payload.watermark ?? false;
+    const promptExtend = payload.prompt_extend ?? true;
+    const content = [];
+    if (prompt) {
+        content.push({ text: prompt });
+    }
+    if (imageUrl) {
+        content.push({ image: imageUrl });
+    }
+    const body = {
+        model,
+        input: {
+            messages: [
+                {
+                    role: "user",
+                    content,
+                },
+            ],
+        },
+        parameters: {
+            n,
+            size,
+            watermark,
+            prompt_extend: promptExtend,
+            ...(negativePrompt ? { negative_prompt: negativePrompt } : {}),
+            ...(seed !== undefined ? { seed } : {}),
+        },
+    };
+    return {
+        path: DASHSCOPE_IMAGE_GEN_PATH,
+        payload: body,
+        headers: {
+            "X-DashScope-Async": "enable",
+        },
+    };
+}
+function buildVideoRequest(payload, model) {
+    const prompt = payload.prompt ?? "";
+    const negativePrompt = payload.negative_prompt ?? "";
+    const imageUrl = payload.image_url;
+    const audioUrl = payload.audio_url;
+    const duration = payload.duration ?? 5;
+    const resolution = payload.resolution ?? "720P";
+    const seed = payload.seed;
+    const watermark = payload.watermark ?? false;
+    const promptExtend = payload.prompt_extend ?? true;
+    const input = {
+        prompt,
+    };
+    if (imageUrl) {
+        input.img_url = imageUrl;
+    }
+    if (audioUrl) {
+        input.audio_url = audioUrl;
+    }
+    if (negativePrompt) {
+        input.negative_prompt = negativePrompt;
+    }
+    const body = {
+        model,
+        input,
+        parameters: {
+            resolution,
+            duration,
+            prompt_extend: promptExtend,
+            watermark,
+            ...(seed !== undefined ? { seed } : {}),
+        },
+    };
+    return {
+        path: DASHSCOPE_VIDEO_GEN_PATH,
+        payload: body,
+        headers: {
+            "X-DashScope-Async": "enable",
+        },
+    };
+}
+async function normalizeImageResponse(upstreamResult) {
+    const chunks = [];
+    for await (const chunk of upstreamResult.body) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const buffer = Buffer.concat(chunks);
+    const body = JSON.parse(buffer.toString("utf8"));
+    if (body.code || body.output?.task_status === "FAILED") {
+        throw new Error(`DashScope task failed: ${body.message ?? body.output?.message ?? "Unknown error"}`);
+    }
+    const taskId = body.output?.task_id;
+    if (!taskId) {
+        throw new Error("No task_id in DashScope response");
+    }
+    const taskResult = await pollForTaskCompletion(taskId, upstreamResult.headers);
+    const output = taskResult.output;
+    const choices = output?.choices ?? [];
+    const data = [];
+    for (const choice of choices) {
+        const messageContent = choice.message?.content ?? [];
+        for (const item of messageContent) {
+            if (item.type === "image" && item.image) {
+                data.push({ url: item.image });
+            }
+        }
+    }
+    const usage = (taskResult.usage ?? {});
+    const normalizedBody = {
+        created: Math.floor(Date.now() / 1000),
+        data,
+        usage: {
+            image_count: usage.image_count ?? data.length,
+            size: usage.size ?? "",
+        },
+        dashscope_request_id: taskResult.request_id,
+    };
+    const normalizedBuffer = Buffer.from(JSON.stringify(normalizedBody));
+    return {
+        statusCode: 200,
+        headers: upstreamResult.headers,
+        body: createReadStream(normalizedBuffer),
+    };
+}
+async function normalizeVideoResponse(upstreamResult) {
+    const chunks = [];
+    for await (const chunk of upstreamResult.body) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const buffer = Buffer.concat(chunks);
+    const body = JSON.parse(buffer.toString("utf8"));
+    if (body.code || body.output?.task_status === "FAILED") {
+        throw new Error(`DashScope task failed: ${body.message ?? body.output?.message ?? "Unknown error"}`);
+    }
+    const taskId = body.output?.task_id;
+    if (!taskId) {
+        throw new Error("No task_id in DashScope response");
+    }
+    const taskResult = await pollForTaskCompletion(taskId, upstreamResult.headers);
+    const output = taskResult.output;
+    if (output?.task_status !== "SUCCEEDED") {
+        throw new Error(`DashScope task did not succeed: ${output?.task_status}`);
+    }
+    const videoUrl = output?.video_url;
+    const data = [];
+    if (videoUrl) {
+        data.push({ url: videoUrl, revised_prompt: output?.orig_prompt });
+    }
+    const usage = (taskResult.usage ?? {});
+    const normalizedBody = {
+        created: Math.floor(Date.now() / 1000),
+        data,
+        usage: {
+            video_count: usage.video_count ?? 1,
+            duration: usage.duration ?? 0,
+            resolution: usage.SR ?? "",
+        },
+        dashscope_request_id: taskResult.request_id,
+    };
+    const normalizedBuffer = Buffer.from(JSON.stringify(normalizedBody));
+    return {
+        statusCode: 200,
+        headers: upstreamResult.headers,
+        body: createReadStream(normalizedBuffer),
+    };
+}
+async function pollForTaskCompletion(taskId, headers) {
+    const apiKey = extractApiKey(headers);
+    if (!apiKey) {
+        throw new Error("No API key available for task polling");
+    }
+    const baseUrl = extractBaseUrl(headers);
+    const startTime = Date.now();
+    while (Date.now() - startTime < TASK_POLL_TIMEOUT_MS) {
+        await sleep(TASK_POLL_INTERVAL_MS);
+        const queryUrl = `${baseUrl}${DASHSCOPE_TASK_QUERY_PATH}/${taskId}`;
+        const response = await fetch(queryUrl, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+            },
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Task query failed: ${response.status} ${errorText}`);
+        }
+        const result = (await response.json());
+        const taskStatus = result?.output?.task_status;
+        if (taskStatus === "SUCCEEDED" || taskStatus === "FAILED") {
+            return result;
+        }
+    }
+    throw new Error(`Task polling timed out after ${TASK_POLL_TIMEOUT_MS}ms`);
+}
+function extractApiKey(headers) {
+    const auth = headers["authorization"] ?? headers["Authorization"];
+    if (typeof auth === "string" && auth.startsWith("Bearer ")) {
+        return auth.slice(7);
+    }
+    return null;
+}
+function extractBaseUrl(headers) {
+    const xBaseUrl = headers["x-dashscope-base-url"] ?? headers["X-DashScope-Base-Url"];
+    if (typeof xBaseUrl === "string") {
+        return xBaseUrl;
+    }
+    return "https://dashscope-intl.aliyuncs.com";
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createReadStream(buffer) {
+    const { Readable } = require("stream");
+    return Readable.from(buffer);
+}