llm-simple-router 1.0.4 → 1.0.6

package/dist/admin/quick-setup.js

@@ -1,11 +1,13 @@
 import { Type } from "@sinclair/typebox";
+import { request as httpRequest } from "http";
+import { request as httpsRequest } from "https";
 import { createProvider, PROVIDER_CONCURRENCY_DEFAULTS } from "../db/providers.js";
 import { createMappingGroup, updateMappingGroup } from "../db/mappings.js";
 import { createRetryRule } from "../db/retry-rules.js";
 import { upsertTransformRule } from "../db/transform-rules.js";
 import { encrypt } from "../utils/crypto.js";
 import { getSetting } from "../db/settings.js";
-import { HTTP_CREATED, HTTP_BAD_REQUEST, HTTP_CONFLICT } from "./constants.js";
+import { HTTP_CREATED, HTTP_BAD_REQUEST, HTTP_BAD_GATEWAY, HTTP_CONFLICT } from "./constants.js";
 import { API_CODE, apiError } from "./api-response.js";
 const PROVIDER_NAME_RE = /^[a-zA-Z0-9_-]+$/;
 const API_KEY_PREVIEW_MIN_LENGTH = 8;
@@ -222,5 +224,160 @@ export const adminQuickSetupRoutes = (app, options, done) => {
         });
         return reply.code(HTTP_CREATED).send({ success: true, provider_id: providerId });
     });
+    // ---------- Test Connection ----------
+    const TestConnectionSchema = Type.Object({
+        api_type: Type.Union([Type.Literal("openai"), Type.Literal("openai-responses"), Type.Literal("anthropic")]),
+        base_url: Type.String({ minLength: 1 }),
+        upstream_path: Type.Optional(Type.Union([Type.String({ minLength: 1 }), Type.Null()])),
+        api_key: Type.String({ minLength: 1 }),
+        model: Type.Optional(Type.String()),
+    });
+    app.post("/admin/api/test-connection", { schema: { body: TestConnectionSchema } }, async (request, reply) => {
+        const body = request.body;
+        const apiType = body.api_type;
+        const baseUrl = body.base_url.replace(/\/+$/, "");
+        const upstreamPath = body.upstream_path ?? null;
+        const apiKey = body.api_key;
+        // Determine model and path based on api_type
+        let targetPath;
+        let reqBody;
+        let authHeader;
+        if (apiType === "anthropic") {
+            targetPath = upstreamPath ?? "/v1/messages";
+            reqBody = {
+                model: body.model ?? "claude-3-5-haiku-20241022",
+                max_tokens: 32,
+                messages: [{ role: "user", content: "Hi" }],
+            };
+            authHeader = `x-api-key`;
+        }
+        else {
+            // openai or openai-responses
+            targetPath = upstreamPath ?? "/v1/chat/completions";
+            reqBody = {
+                model: body.model ?? "gpt-4o-mini",
+                max_tokens: 32,
+                messages: [
+                    { role: "system", content: "You are a helpful assistant." },
+                    { role: "user", content: "Say hi in one word." },
+                ],
+            };
+            authHeader = "authorization";
+        }
+        // Build full URL with dedup logic
+        const fullUrl = buildTestUrl(baseUrl, targetPath);
+        try {
+            const result = await sendTestRequest(fullUrl, apiType, apiKey, authHeader, reqBody);
+            return reply.send({ ok: true, model: body.model, latency_ms: result.latencyMs });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : JSON.stringify(err);
+            return reply.code(HTTP_BAD_GATEWAY).send({ ok: false, error: message });
+        }
+    });
     done();
 };
+// ---------- Test Connection Helpers ----------
+const TEST_REQUEST_TIMEOUT_MS = 15_000;
+const HTTPS_DEFAULT_PORT = 443;
+const HTTP_DEFAULT_PORT = 80;
+const HTTP_SUCCESS_MIN = 200;
+const HTTP_SUCCESS_MAX = 300;
+/** Build full URL, applying dedup logic for base_url already containing the path */
+function buildTestUrl(baseUrl, upstreamPath) {
+    const KNOWN_SUFFIXES = ["/chat/completions", "/messages", "/responses"];
+    const normalized = baseUrl.replace(/\/+$/, "");
+    if (normalized.endsWith(upstreamPath))
+        return normalized;
+    for (const suffix of KNOWN_SUFFIXES) {
+        if (normalized.endsWith(suffix))
+            return normalized;
+    }
+    // Check for /v1 prefix overlap
+    const versionMatch = upstreamPath.match(/^(\/v\d+)(.*)/);
+    if (versionMatch) {
+        const [, prefix, rest] = versionMatch;
+        if (normalized.endsWith(prefix))
+            return `${normalized}${rest}`;
+    }
+    // Generic overlap detection
+    const segments = upstreamPath.split("/");
+    const MIN_OVERLAP_SEGMENTS = 2;
+    for (let len = segments.length - 1; len >= MIN_OVERLAP_SEGMENTS; len--) {
+        const candidate = segments.slice(0, len).join("/");
+        if (candidate.length > 0 && normalized.endsWith(candidate)) {
+            return `${normalized}${upstreamPath.slice(candidate.length)}`;
+        }
+    }
+    if (!upstreamPath.startsWith("/"))
+        return `${normalized}/${upstreamPath}`;
+    return `${normalized}${upstreamPath}`;
+}
+/** Send a real test request to the upstream provider */
+function sendTestRequest(fullUrl, apiType, apiKey, authHeaderKey, reqBody) {
+    return new Promise((resolve, reject) => {
+        const start = Date.now();
+        const url = new URL(fullUrl);
+        const payload = JSON.stringify(reqBody);
+        const headers = {
+            "content-type": "application/json",
+            "accept": "application/json",
+            "user-agent": "llm-simple-router/test-connection",
+        };
+        if (authHeaderKey === "x-api-key") {
+            headers["x-api-key"] = apiKey;
+            headers["anthropic-version"] = "2023-06-01";
+            headers["content-type"] = "application/json";
+        }
+        else {
+            headers["authorization"] = `Bearer ${apiKey}`;
+        }
+        const options = {
+            hostname: url.hostname,
+            port: url.port || (url.protocol === "https:" ? HTTPS_DEFAULT_PORT : HTTP_DEFAULT_PORT),
+            path: url.pathname + url.search,
+            method: "POST",
+            headers: { ...headers, "content-length": `${Buffer.byteLength(payload)}` },
+        };
+        const mod = url.protocol === "https:" ? httpsRequest : httpRequest;
+        const req = mod(options, (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => {
+                const statusCode = res.statusCode ?? 0;
+                const body = Buffer.concat(chunks).toString("utf-8");
+                const latencyMs = Date.now() - start;
+                if (statusCode >= HTTP_SUCCESS_MIN && statusCode < HTTP_SUCCESS_MAX) {
+                    resolve({ latencyMs });
+                }
+                else {
+                    // Try to extract error message from response
+                    let errMsg = `HTTP ${statusCode}`;
+                    try {
+                        const parsed = JSON.parse(body);
+                        const error = parsed.error;
+                        if (error?.message) {
+                            errMsg = typeof error.message === "string" ? error.message : JSON.stringify(error.message);
+                        }
+                        else if (parsed.message) {
+                            errMsg = typeof parsed.message === "string" ? parsed.message : JSON.stringify(parsed.message);
+                        }
+                    }
+                    catch {
+                        // response body is not valid JSON, keep default HTTP error
+                        void 0;
+                    }
+                    reject(new Error(errMsg));
+                }
+            });
+            res.on("error", (err) => reject(err));
+        });
+        req.setTimeout(TEST_REQUEST_TIMEOUT_MS, () => {
+            req.destroy();
+            reject(new Error("Connection timed out"));
+        });
+        req.on("error", (err) => reject(err));
+        req.write(payload);
+        req.end();
+    });
+}

package/dist/admin/settings-import-export.js

@@ -36,6 +36,26 @@ export const adminImportExportRoutes = (app, options, done) => {
                     }
                     catch { /* eslint-disable-line taste/no-silent-catch -- 无法解密则保留原值 */ }
                 }
+                // 解密 endpoints JSON 内嵌套的 api_key
+                if (typeof row.endpoints === "string" && row.endpoints) {
+                    try {
+                        const eps = JSON.parse(row.endpoints);
+                        for (const ep of eps) {
+                            if (typeof ep.api_key === "string" && ep.api_key) {
+                                ep.api_key = decrypt(ep.api_key, encryptionKey);
+                            }
+                        }
+                        row.endpoints = JSON.stringify(eps);
+                    }
+                    catch { /* eslint-disable-line taste/no-silent-catch -- 无法解密则保留原值 */ }
+                }
+                // 解密 proxy_password
+                if (typeof row.proxy_password === "string" && row.proxy_password) {
+                    try {
+                        row.proxy_password = decrypt(row.proxy_password, encryptionKey);
+                    }
+                    catch { /* eslint-disable-line taste/no-silent-catch -- 无法解密则保留原值 */ }
+                }
             }
             for (const row of (data.router_keys || [])) {
                 if (typeof row.key_encrypted === "string") {
@@ -74,6 +94,23 @@ export const adminImportExportRoutes = (app, options, done) => {
                 if (typeof row.api_key === "string" && row.api_key) {
                     row.api_key = encrypt(row.api_key, encryptionKey);
                 }
+                // 重加密 endpoints JSON 内嵌套的 api_key
+                if (typeof row.endpoints === "string" && row.endpoints) {
+                    try {
+                        const eps = JSON.parse(row.endpoints);
+                        for (const ep of eps) {
+                            if (typeof ep.api_key === "string" && ep.api_key) {
+                                ep.api_key = encrypt(ep.api_key, encryptionKey);
+                            }
+                        }
+                        row.endpoints = JSON.stringify(eps);
+                    }
+                    catch { /* eslint-disable-line taste/no-silent-catch -- 无法解析则保留原值 */ }
+                }
+                // 重加密 proxy_password
+                if (typeof row.proxy_password === "string" && row.proxy_password) {
+                    row.proxy_password = encrypt(row.proxy_password, encryptionKey);
+                }
             }
             for (const row of (importData.router_keys || [])) {
                 if (typeof row.key === "string") {

package/dist/config/model-context.js

@@ -73,6 +73,11 @@ export const MODEL_CONTEXT_WINDOWS = {
     "step-2-16k": 16000,
     "step-1-8k": 8000,
     "step-1-32k": 32000,
+    // 小米 MiMo
+    "mimo-v2.5-pro": 1000000,
+    "mimo-v2.5": 1000000,
+    "mimo-v2-omni": 128000,
+    "mimo-v2-pro": 128000,
     // 硅基流动
     "deepseek-ai/DeepSeek-V3.2-Exp": 128000,
     "deepseek-ai/DeepSeek-R1": 128000,
@@ -130,9 +135,11 @@ export const MODEL_CAPABILITIES = {
     "qwen3.5-flash": ["text", "image"],
     // ── 火山引擎 ── Doubao Seed 2.0 Pro 规格：Input Text, Images, Video
     "doubao-seed-2-0-pro-260215": ["text", "image", "video"],
-    // ── 小米 MiMo ── 只有 omni 版本支持图片，pro 版本是纯文本
+    // ── 小米 MiMo ──
+    "mimo-v2.5-pro": ["text", "image"],
+    "mimo-v2.5": ["text", "image"],
     "mimo-v2-omni": ["text", "image", "audio", "video"],
-    "mimo-v2.5": ["text", "image", "audio", "video"],
+    "mimo-v2-pro": ["text"],
 };
 export const DEFAULT_CONTEXT_WINDOW = 200000;
 export const OVERFLOW_THRESHOLD = 1000000;