@nvae/llmswitch 0.2.0 → 0.5.0

package/dist/store/profiles.js

@@ -1,6 +1,6 @@
 import { existsSync, readdirSync, unlinkSync } from "node:fs";
 import { readFileSync } from "node:fs";
-import { isApiFormat } from "../types.js";
+import { isApiFormat, normalizeProxyValue } from "../types.js";
 import { normalizeBaseUrlForFormat } from "../utils/base-url.js";
 import { atomicWriteFile, ensureDir, maskSecret } from "../utils/fs.js";
 import { getProfilePath, getProfilesDir, getStatePath, getToolStoreDir, } from "../utils/paths.js";
@@ -63,6 +63,44 @@ export function requireProfile(tool, name) {
     }
     return profile;
 }
+/** 归一化引用串：小写并去掉分隔符（kimi-openai ↔ kimiOpenai）。 */
+export function normalizeReference(value) {
+    return value.toLowerCase().replace(/[_\s./-]+/g, "");
+}
+/**
+ * 按用户输入解析 profile：优先名称精确匹配，其次显示名称精确匹配，
+ * 再尝试归一化（大小写/分隔符）与包含匹配；多义时返回 null。
+ */
+export function resolveProfile(tool, query) {
+    const trimmed = query.trim();
+    if (!trimmed)
+        return null;
+    const byName = readProfile(tool, trimmed);
+    if (byName)
+        return byName;
+    const profiles = listProfiles(tool);
+    const normalized = normalizeReference(trimmed);
+    const exactDisplay = profiles.find((p) => normalizeReference(p.displayName) === normalized);
+    if (exactDisplay)
+        return exactDisplay;
+    const fuzzy = profiles.filter((p) => normalizeReference(p.displayName).includes(normalized) ||
+        normalizeReference(p.name).includes(normalized));
+    return fuzzy.length === 1 ? fuzzy[0] : null;
+}
+export function resolveProfileOrThrow(tool, query) {
+    const profile = resolveProfile(tool, query);
+    if (!profile) {
+        const profiles = listProfiles(tool);
+        if (profiles.length === 0) {
+            throw new Error(`暂无 ${tool} 供应商。请先：llms ${tool} provider`);
+        }
+        const names = profiles
+            .map((p) => `${p.name}（${p.displayName}）`)
+            .join(", ");
+        throw new Error(`未找到匹配「${query}」的供应商。现有：${names}。可通过名称或显示名称引用。`);
+    }
+    return profile;
+}
 export function saveProfile(tool, profile) {
     assertValidProfileName(profile.name);
     if (!isApiFormat(profile.apiFormat)) {
@@ -191,7 +229,7 @@ function normalizeProfile(raw, fallbackName) {
             fast: raw.models?.fast || undefined,
             list: list.length ? list : raw.models?.default ? [raw.models.default] : [],
         },
-        proxy: raw.proxy,
+        proxy: normalizeProxyValue(raw.proxy),
         bridgeMode: raw.bridgeMode,
         headers: raw.headers || {},
         updatedAt: raw.updatedAt || new Date(0).toISOString(),

package/dist/types.js

@@ -11,7 +11,24 @@ export function isApiFormat(value) {
     return API_FORMATS.includes(value);
 }
 export function emptyProxy(proxy) {
-    if (!proxy)
-        return true;
-    return !proxy.http && !proxy.https && !proxy.all;
+    return !proxy || !proxy.trim();
+}
+/**
+ * Coerce a stored proxy value into a single URL string. Accepts the current
+ * string form, or the legacy `{ http, https, all }` object (preferring `all`,
+ * then `https`, then `http`). Returns undefined when no proxy is set.
+ */
+export function normalizeProxyValue(raw) {
+    if (typeof raw === "string") {
+        const trimmed = raw.trim();
+        return trimmed ? trimmed : undefined;
+    }
+    if (raw && typeof raw === "object") {
+        const row = raw;
+        for (const value of [row.all, row.https, row.http]) {
+            if (typeof value === "string" && value.trim())
+                return value.trim();
+        }
+    }
+    return undefined;
 }

package/dist/utils/detect-format.js

@@ -0,0 +1,178 @@
+import { supportedFormats } from "../formats/compatibility.js";
+import { requestWithNodeTransport } from "../bridge/transport.js";
+import { baseUrlFromModelsEndpoint, buildModelsRequestHeaders, modelListEndpoints, parseModelIds, } from "./fetch-models.js";
+const PROBE_TIMEOUT_MS = 4000;
+async function probe(url, method, headers, proxy, body) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+    try {
+        const res = await requestWithNodeTransport({
+            url,
+            method,
+            headers,
+            proxy,
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal: controller.signal,
+            totalTimeoutMs: PROBE_TIMEOUT_MS,
+        });
+        let json = null;
+        try {
+            json = await res.json();
+        }
+        catch {
+            return null;
+        }
+        return { status: res.status, json };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** GET /models（Anthropic 头）成功且返回模型 → anthropic 兼容。 */
+async function probeAnthropicModels(baseUrl, apiKey, proxy) {
+    const headers = buildModelsRequestHeaders("anthropic", apiKey);
+    for (const endpoint of modelListEndpoints(baseUrl)) {
+        const res = await probe(endpoint, "GET", headers, proxy);
+        if (res &&
+            res.status >= 200 &&
+            res.status < 300 &&
+            parseModelIds(res.json).length > 0) {
+            return true;
+        }
+    }
+    return false;
+}
+/** GET /models（Bearer 头）成功 → OpenAI 兼容。 */
+async function probeOpenAiModels(baseUrl, apiKey, proxy) {
+    const headers = buildModelsRequestHeaders("openai-chat", apiKey);
+    for (const endpoint of modelListEndpoints(baseUrl)) {
+        const res = await probe(endpoint, "GET", headers, proxy);
+        if (res &&
+            res.status >= 200 &&
+            res.status < 300 &&
+            parseModelIds(res.json).length > 0) {
+            return endpoint;
+        }
+    }
+    return null;
+}
+/**
+ * POST 探测某一路由是否存在：404/501 或非 JSON 响应视为不存在；
+ * 400/401/422/200 等带 JSON body 的响应视为路由存在。
+ */
+async function routeExists(baseUrl, suffix, apiKey, proxy, body) {
+    const base = baseUrl.trim().replace(/\/+$/, "");
+    const candidates = [];
+    if (/\/v1$/i.test(base)) {
+        candidates.push(`${base}/${suffix}`);
+    }
+    else {
+        candidates.push(`${base}/${suffix}`);
+        candidates.push(`${base}/v1/${suffix}`);
+    }
+    const headers = {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+    };
+    if (apiKey.trim())
+        headers.Authorization = `Bearer ${apiKey.trim()}`;
+    for (const endpoint of candidates) {
+        const res = await probe(endpoint, "POST", headers, proxy, body);
+        if (!res)
+            continue;
+        if (res.status === 404 || res.status === 501 || res.status === 405) {
+            continue;
+        }
+        if (res.json === null)
+            continue;
+        return true;
+    }
+    return false;
+}
+/** GET /api/tags（Ollama 原生）成功且返回模型 → 本地 Ollama。 */
+async function probeOllamaTags(baseUrl, proxy) {
+    const base = baseUrl.trim().replace(/\/+$/, "");
+    const endpoint = `${base}/api/tags`;
+    const res = await probe(endpoint, "GET", { Accept: "application/json" }, proxy);
+    return (res !== null &&
+        res.status >= 200 &&
+        res.status < 300 &&
+        parseModelIds(res.json).length > 0);
+}
+/**
+ * 自动识别上游接口类型。探测策略（每个请求 4s 超时，串行）：
+ * 1. Anthropic /models（有 Key 且工具支持时，claude/opencode 优先原生）
+ * 2. OpenAI /models（无 Key 也探测，覆盖 Ollama /vLLM 等本地服务）
+ * 3. Ollama 原生 /api/tags（兼容 OpenAI 兼容层缺失的旧版本）
+ * 4. /models 全失败且有 Key 时兜底探测 /v1/chat/completions 路由
+ * 全部失败返回 detected: false，由调用方回退到人工选择。
+ */
+export async function detectApiFormat(tool, opts) {
+    const base = opts.baseUrl.trim();
+    const key = opts.apiKey.trim();
+    const supported = supportedFormats(tool);
+    const fallback = {
+        apiFormat: "openai-chat",
+        detected: false,
+    };
+    // 没有 URL 无法探测
+    if (!base)
+        return fallback;
+    const chatResult = {
+        apiFormat: "openai-chat",
+        bridgeMode: tool === "codex" ? "chat" : undefined,
+        detected: true,
+        source: "openai-models",
+    };
+    if (key && supported.includes("anthropic")) {
+        const antOk = await probeAnthropicModels(base, key, opts.proxy);
+        if (antOk) {
+            return {
+                apiFormat: "anthropic",
+                detected: true,
+                source: "anthropic",
+                resolvedBaseUrl: base.replace(/\/+$/, ""),
+            };
+        }
+    }
+    const modelsEndpoint = await probeOpenAiModels(base, key, opts.proxy);
+    if (modelsEndpoint) {
+        const resolvedBaseUrl = baseUrlFromModelsEndpoint(modelsEndpoint) || base.replace(/\/+$/, "");
+        // 无 Key 时不做 POST 探测（本地服务默认 chat 最兼容）
+        if (key && supported.includes("openai-responses")) {
+            const responsesOk = await routeExists(resolvedBaseUrl, "responses", key, opts.proxy, { model: "", input: "hi" });
+            if (responsesOk) {
+                return {
+                    apiFormat: "openai-responses",
+                    detected: true,
+                    source: "openai-models",
+                    resolvedBaseUrl,
+                };
+            }
+        }
+        return { ...chatResult, resolvedBaseUrl };
+    }
+    // Ollama 原生 API（/v1 兼容层可能缺失）：映射到 OpenAI Chat + /v1
+    if (supported.includes("openai-chat")) {
+        const ollamaOk = await probeOllamaTags(base, opts.proxy);
+        if (ollamaOk) {
+            return {
+                ...chatResult,
+                source: "ollama-tags",
+                resolvedBaseUrl: `${base.replace(/\/+$/, "")}/v1`,
+            };
+        }
+    }
+    if (key && supported.includes("openai-chat")) {
+        const chatOk = await routeExists(base, "chat/completions", key, opts.proxy, {
+            model: "",
+            messages: [],
+        });
+        if (chatOk)
+            return { ...chatResult, source: "openai-route" };
+    }
+    return fallback;
+}

package/dist/utils/fetch-models.js

@@ -1,6 +1,5 @@
-import { emptyProxy } from "../types.js";
+import { requestWithNodeTransport } from "../bridge/transport.js";
 import { normalizeBaseUrlForFormat } from "./base-url.js";
-import { buildProxyEnv } from "./proxy.js";
 /**
  * Derive the API base URL from a successful .../models endpoint.
  */
@@ -45,20 +44,28 @@ export function modelListEndpoints(baseUrl) {
     }
     return endpoints;
 }
-export function buildModelsRequestHeaders(apiFormat, apiKey) {
+export function buildModelsRequestHeaders(apiFormat, apiKey, customHeaders = {}) {
     const headers = {
         Accept: "application/json",
     };
-    if (!apiKey)
-        return headers;
-    if (apiFormat === "anthropic") {
-        headers["x-api-key"] = apiKey;
-        headers["anthropic-version"] = "2023-06-01";
-        // Some gateways also accept Bearer
-        headers.Authorization = `Bearer ${apiKey}`;
+    if (apiKey) {
+        if (apiFormat === "anthropic") {
+            headers["x-api-key"] = apiKey;
+            headers["anthropic-version"] = "2023-06-01";
+            headers.Authorization = `Bearer ${apiKey}`;
+        }
+        else {
+            headers.Authorization = `Bearer ${apiKey}`;
+        }
     }
-    else {
-        headers.Authorization = `Bearer ${apiKey}`;
+    for (const [name, value] of Object.entries(customHeaders)) {
+        if (/[\r\n]/.test(name) || /[\r\n]/.test(value)) {
+            throw new Error(`无效的模型请求 header: ${name}`);
+        }
+        const existing = Object.keys(headers).find((key) => key.toLowerCase() === name.toLowerCase());
+        if (existing)
+            delete headers[existing];
+        headers[name] = value;
     }
     return headers;
 }
@@ -93,51 +100,58 @@ export function parseModelIds(payload) {
  * Tries several common /models paths; uses proxy env when configured.
  */
 export async function fetchModelList(options) {
-    const { baseUrl, apiKey, apiFormat, proxy, timeoutMs = 20_000 } = options;
+    const { baseUrl, apiKey, apiFormat, proxy, headers: customHeaders, timeoutMs = 20_000, } = options;
     if (!baseUrl?.trim()) {
         throw new Error("Base URL 为空，无法拉取模型列表");
     }
-    if (!apiKey?.trim()) {
-        throw new Error("API Key 为空，无法拉取模型列表");
-    }
     const effectiveBaseUrl = normalizeBaseUrlForFormat(apiFormat, baseUrl);
     const endpoints = modelListEndpoints(effectiveBaseUrl);
-    const headers = buildModelsRequestHeaders(apiFormat, apiKey.trim());
-    const restore = applyProxyEnv(proxy);
+    // 无 Key 的本地服务（如 Ollama 原生 API）兜底探测 /api/tags
+    if (!apiKey?.trim()) {
+        const root = effectiveBaseUrl
+            .replace(/\/v1$/i, "")
+            .replace(/\/+$/, "");
+        const tags = `${root}/api/tags`;
+        if (!endpoints.includes(tags))
+            endpoints.push(tags);
+    }
+    const headers = buildModelsRequestHeaders(apiFormat, apiKey.trim(), customHeaders);
     const errors = [];
-    try {
-        for (const endpoint of endpoints) {
-            try {
-                const models = await requestModels(endpoint, headers, timeoutMs);
-                if (models.length > 0) {
-                    const resolvedBaseUrl = baseUrlFromModelsEndpoint(endpoint) || effectiveBaseUrl;
-                    return {
-                        models,
-                        endpoint,
-                        resolvedBaseUrl: normalizeBaseUrlForFormat(apiFormat, resolvedBaseUrl),
-                    };
-                }
-                errors.push(`${endpoint} → 返回空列表`);
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                errors.push(`${endpoint} → ${msg}`);
+    for (const endpoint of endpoints) {
+        try {
+            const models = await requestModels(endpoint, headers, timeoutMs, proxy);
+            if (models.length > 0) {
+                // Anthropic Messages base URLs are not implied by a sibling /v1/models
+                // endpoint; keep the operator-provided base for those.
+                const resolvedBaseUrl = apiFormat === "anthropic"
+                    ? effectiveBaseUrl
+                    : baseUrlFromModelsEndpoint(endpoint) || effectiveBaseUrl;
+                return {
+                    models,
+                    endpoint,
+                    resolvedBaseUrl: normalizeBaseUrlForFormat(apiFormat, resolvedBaseUrl),
+                };
             }
+            errors.push(`${endpoint} → 返回空列表`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            errors.push(`${endpoint} → ${msg}`);
         }
-    }
-    finally {
-        restore();
     }
     throw new Error(`无法从接口拉取模型列表。\n${errors.map((e) => `  - ${e}`).join("\n")}`);
 }
-async function requestModels(endpoint, headers, timeoutMs) {
+async function requestModels(endpoint, headers, timeoutMs, proxy) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeoutMs);
     try {
-        const res = await fetch(endpoint, {
+        const res = await requestWithNodeTransport({
+            url: endpoint,
             method: "GET",
             headers,
+            proxy,
             signal: controller.signal,
+            totalTimeoutMs: timeoutMs,
         });
         if (!res.ok) {
             const body = (await res.text().catch(() => "")).slice(0, 200);
@@ -156,22 +170,3 @@ async function requestModels(endpoint, headers, timeoutMs) {
         clearTimeout(timer);
     }
 }
-function applyProxyEnv(proxy) {
-    if (emptyProxy(proxy))
-        return () => undefined;
-    const next = buildProxyEnv(proxy);
-    const keys = Object.keys(next);
-    const backup = new Map();
-    for (const key of keys) {
-        backup.set(key, process.env[key]);
-        process.env[key] = next[key];
-    }
-    return () => {
-        for (const [key, value] of backup) {
-            if (value === undefined)
-                delete process.env[key];
-            else
-                process.env[key] = value;
-        }
-    };
-}

package/dist/utils/proxy.js

@@ -8,39 +8,23 @@ export const PROXY_ENV_KEYS = [
     "all_proxy",
 ];
 /**
- * Build proxy env vars for injection into tool configs.
- * Prefer explicit http/https; when only `all` is set (e.g. socks5h),
- * set ALL_PROXY (and lowercase) and also mirror to HTTP(S)_PROXY
- * so runtimes that only read those still attempt the proxy URL.
+ * Build proxy env vars for injection into tool configs. A single proxy URL is
+ * applied to all traffic, so HTTP_PROXY, HTTPS_PROXY and ALL_PROXY (plus their
+ * lowercase forms) are all set to that URL. SOCKS URLs are honored by runtimes
+ * that read these variables.
  */
 export function buildProxyEnv(proxy) {
     if (emptyProxy(proxy))
         return {};
-    const env = {};
-    const http = proxy.http?.trim();
-    const https = proxy.https?.trim();
-    const all = proxy.all?.trim();
-    if (all) {
-        env.ALL_PROXY = all;
-        env.all_proxy = all;
-    }
-    if (http) {
-        env.HTTP_PROXY = http;
-        env.http_proxy = http;
-    }
-    else if (all) {
-        env.HTTP_PROXY = all;
-        env.http_proxy = all;
-    }
-    if (https) {
-        env.HTTPS_PROXY = https;
-        env.https_proxy = https;
-    }
-    else if (all) {
-        env.HTTPS_PROXY = all;
-        env.https_proxy = all;
-    }
-    return env;
+    const url = proxy.trim();
+    return {
+        HTTP_PROXY: url,
+        HTTPS_PROXY: url,
+        ALL_PROXY: url,
+        http_proxy: url,
+        https_proxy: url,
+        all_proxy: url,
+    };
 }
 export function clearProxyEnvKeys(env) {
     for (const key of PROXY_ENV_KEYS) {
@@ -57,12 +41,5 @@ export function applyProxyToEnvRecord(env, proxy) {
 export function formatProxySummary(proxy) {
     if (emptyProxy(proxy))
         return "(none)";
-    const parts = [];
-    if (proxy?.http)
-        parts.push(`http=${proxy.http}`);
-    if (proxy?.https)
-        parts.push(`https=${proxy.https}`);
-    if (proxy?.all)
-        parts.push(`all=${proxy.all}`);
-    return parts.join(", ");
+    return proxy.trim();
 }

package/dist/utils/version.js

@@ -0,0 +1,9 @@
+import { readFileSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageJsonPath = resolve(__dirname, "../../package.json");
+export function getVersion() {
+    const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    return pkg.version ?? "unknown";
+}

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@nvae/llmswitch",
-  "version": "0.2.0",
+  "version": "0.5.0",
   "description": "CLI to switch LLM providers and models for Claude Code, Codex, and OpenCode",
   "type": "module",
   "bin": {
     "llms": "dist/index.js",
-    "llm-switch": "dist/index.js"
+    "llm-switch": "dist/index.js",
+    "llmswitch": "dist/index.js"
   },
   "files": [
     "dist",
@@ -39,7 +40,9 @@
   "dependencies": {
     "@clack/prompts": "^0.11.0",
     "commander": "^14.0.0",
-    "smol-toml": "^1.4.2"
+    "https-proxy-agent": "7.0.6",
+    "smol-toml": "^1.4.2",
+    "socks-proxy-agent": "8.0.5"
   },
   "devDependencies": {
     "@types/bun": "^1.2.19",