@zqagent/core 0.2.20 → 0.3.6

package/dist/internal/providers/models.js

@@ -0,0 +1,654 @@
+// src/providers/proxy.ts
+import nodeFetch from "node-fetch";
+
+// ../../node_modules/.pnpm/socks-proxy-agent@9.0.0_supports-color@7.2.0/node_modules/socks-proxy-agent/dist/index.js
+import { SocksClient } from "socks";
+
+// ../../node_modules/.pnpm/agent-base@8.0.0/node_modules/agent-base/dist/index.js
+import * as net from "net";
+import * as http from "http";
+import { Agent as HttpsAgent } from "https";
+var INTERNAL = /* @__PURE__ */ Symbol("AgentBaseInternalState");
+var Agent2 = class extends http.Agent {
+  constructor(opts) {
+    super(opts);
+    this[INTERNAL] = {};
+  }
+  /**
+   * Determine whether this is an `http` or `https` request.
+   */
+  isSecureEndpoint(options) {
+    if (options) {
+      if (typeof options.secureEndpoint === "boolean") {
+        return options.secureEndpoint;
+      }
+      if (typeof options.protocol === "string") {
+        return options.protocol === "https:";
+      }
+    }
+    const { stack } = new Error();
+    if (typeof stack !== "string")
+      return false;
+    return stack.split("\n").some((l) => l.indexOf("(https.js:") !== -1 || l.indexOf("node:https:") !== -1);
+  }
+  // In order to support async signatures in `connect()` and Node's native
+  // connection pooling in `http.Agent`, the array of sockets for each origin
+  // has to be updated synchronously. This is so the length of the array is
+  // accurate when `addRequest()` is next called. We achieve this by creating a
+  // fake socket and adding it to `sockets[origin]` and incrementing
+  // `totalSocketCount`.
+  incrementSockets(name) {
+    if (this.maxSockets === Infinity && this.maxTotalSockets === Infinity) {
+      return null;
+    }
+    if (!this.sockets[name]) {
+      this.sockets[name] = [];
+    }
+    const fakeSocket = new net.Socket({ writable: false });
+    this.sockets[name].push(fakeSocket);
+    this.totalSocketCount++;
+    return fakeSocket;
+  }
+  decrementSockets(name, socket) {
+    if (!this.sockets[name] || socket === null) {
+      return;
+    }
+    const sockets = this.sockets[name];
+    const index = sockets.indexOf(socket);
+    if (index !== -1) {
+      sockets.splice(index, 1);
+      this.totalSocketCount--;
+      if (sockets.length === 0) {
+        delete this.sockets[name];
+      }
+    }
+  }
+  // In order to properly update the socket pool, we need to call `getName()` on
+  // the core `https.Agent` if it is a secureEndpoint.
+  getName(options) {
+    const secureEndpoint = this.isSecureEndpoint(options);
+    if (secureEndpoint) {
+      return HttpsAgent.prototype.getName.call(this, options);
+    }
+    return super.getName(options);
+  }
+  createSocket(req, options, cb) {
+    const connectOpts = {
+      ...options,
+      secureEndpoint: this.isSecureEndpoint(options)
+    };
+    const name = this.getName(connectOpts);
+    const fakeSocket = this.incrementSockets(name);
+    Promise.resolve().then(() => this.connect(req, connectOpts)).then((socket) => {
+      this.decrementSockets(name, fakeSocket);
+      if (socket instanceof http.Agent) {
+        try {
+          return socket.addRequest(req, connectOpts);
+        } catch (err) {
+          return cb(err);
+        }
+      }
+      this[INTERNAL].currentSocket = socket;
+      super.createSocket(req, options, cb);
+    }, (err) => {
+      this.decrementSockets(name, fakeSocket);
+      cb(err);
+    });
+  }
+  createConnection() {
+    const socket = this[INTERNAL].currentSocket;
+    this[INTERNAL].currentSocket = void 0;
+    if (!socket) {
+      throw new Error("No socket was returned in the `connect()` function");
+    }
+    return socket;
+  }
+  get defaultPort() {
+    return this[INTERNAL].defaultPort ?? (this.protocol === "https:" ? 443 : 80);
+  }
+  set defaultPort(v) {
+    if (this[INTERNAL]) {
+      this[INTERNAL].defaultPort = v;
+    }
+  }
+  get protocol() {
+    return this[INTERNAL].protocol ?? (this.isSecureEndpoint() ? "https:" : "http:");
+  }
+  set protocol(v) {
+    if (this[INTERNAL]) {
+      this[INTERNAL].protocol = v;
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/socks-proxy-agent@9.0.0_supports-color@7.2.0/node_modules/socks-proxy-agent/dist/index.js
+import createDebug from "debug";
+import * as dns from "dns";
+import * as net2 from "net";
+import * as tls from "tls";
+import { URL } from "url";
+var debug = createDebug("socks-proxy-agent");
+var setServernameFromNonIpHost = (options) => {
+  if (options.servername === void 0 && options.host && !net2.isIP(options.host)) {
+    return {
+      ...options,
+      servername: options.host
+    };
+  }
+  return options;
+};
+function parseSocksURL(url) {
+  let lookup2 = false;
+  let type = 5;
+  const host = url.hostname;
+  const port = parseInt(url.port, 10) || 1080;
+  switch (url.protocol.replace(":", "")) {
+    case "socks4":
+      lookup2 = true;
+      type = 4;
+      break;
+    // pass through
+    case "socks4a":
+      type = 4;
+      break;
+    case "socks5":
+      lookup2 = true;
+      type = 5;
+      break;
+    // pass through
+    case "socks":
+      type = 5;
+      break;
+    case "socks5h":
+      type = 5;
+      break;
+    default:
+      throw new TypeError(`A "socks" protocol must be specified! Got: ${String(url.protocol)}`);
+  }
+  const proxy = {
+    host,
+    port,
+    type
+  };
+  if (url.username) {
+    Object.defineProperty(proxy, "userId", {
+      value: decodeURIComponent(url.username),
+      enumerable: false
+    });
+  }
+  if (url.password != null) {
+    Object.defineProperty(proxy, "password", {
+      value: decodeURIComponent(url.password),
+      enumerable: false
+    });
+  }
+  return { lookup: lookup2, proxy };
+}
+var SocksProxyAgent = class extends Agent2 {
+  constructor(uri, opts) {
+    super(opts);
+    const url = typeof uri === "string" ? new URL(uri) : uri;
+    const { proxy, lookup: lookup2 } = parseSocksURL(url);
+    this.shouldLookup = lookup2;
+    this.proxy = proxy;
+    this.timeout = opts?.timeout ?? null;
+    this.socketOptions = opts?.socketOptions ?? null;
+  }
+  /**
+   * Initiates a SOCKS connection to the specified SOCKS proxy server,
+   * which in turn connects to the specified remote host and port.
+   */
+  async connect(req, opts) {
+    const { shouldLookup, proxy, timeout } = this;
+    if (!opts.host) {
+      throw new Error("No `host` defined!");
+    }
+    let { host } = opts;
+    const { port, lookup: lookupFn = dns.lookup } = opts;
+    if (shouldLookup) {
+      host = await new Promise((resolve, reject) => {
+        lookupFn(host, {}, (err, address) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(typeof address === "string" ? address : address[0].address);
+          }
+        });
+      });
+    }
+    const socksOpts = {
+      proxy,
+      destination: {
+        host,
+        port: typeof port === "number" ? port : parseInt(port, 10)
+      },
+      command: "connect",
+      timeout: timeout ?? void 0,
+      // @ts-expect-error the type supplied by socks for socket_options is wider
+      // than necessary since socks will always override the host and port
+      socket_options: this.socketOptions ?? void 0
+    };
+    const cleanup = (tlsSocket) => {
+      req.destroy();
+      socket.destroy();
+      if (tlsSocket)
+        tlsSocket.destroy();
+    };
+    debug("Creating socks proxy connection: %o", socksOpts);
+    const { socket } = await SocksClient.createConnection(socksOpts);
+    debug("Successfully created socks proxy connection");
+    if (timeout !== null) {
+      socket.setTimeout(timeout);
+      socket.on("timeout", () => cleanup());
+    }
+    if (opts.secureEndpoint) {
+      debug("Upgrading socket connection to TLS");
+      const tlsSocket = tls.connect({
+        ...omit(setServernameFromNonIpHost(opts), "host", "path", "port"),
+        socket
+      });
+      tlsSocket.once("error", (error) => {
+        debug("Socket TLS error", error.message);
+        cleanup(tlsSocket);
+      });
+      return tlsSocket;
+    }
+    return socket;
+  }
+};
+SocksProxyAgent.protocols = [
+  "socks",
+  "socks4",
+  "socks4a",
+  "socks5",
+  "socks5h"
+];
+function omit(obj, ...keys) {
+  const ret = {};
+  let key;
+  for (key in obj) {
+    if (!keys.includes(key)) {
+      ret[key] = obj[key];
+    }
+  }
+  return ret;
+}
+
+// src/providers/proxy.ts
+function socksProxyUrl() {
+  const raw = (process.env.SOCKS5_PROXY ?? "").trim();
+  return raw || null;
+}
+function isSocks(raw) {
+  return /^socks/i.test(raw);
+}
+var cached = null;
+function socksAgent() {
+  const url = socksProxyUrl();
+  if (!url) return null;
+  if (cached?.url === url) return cached.agent;
+  let agent = null;
+  if (isSocks(url)) {
+    try {
+      agent = new SocksProxyAgent(url);
+    } catch {
+      try {
+        agent = new SocksProxyAgent(url.replace(/^socks5h:\/\//, "socks5://"));
+      } catch {
+        agent = null;
+      }
+    }
+  }
+  cached = { url, agent };
+  return agent;
+}
+function makeSocksFetch(agent) {
+  return ((url, init) => nodeFetch(String(url), { ...init, agent }));
+}
+
+// src/providers/diagnostics.ts
+function cleanLlmValue(v) {
+  if (v == null) return void 0;
+  let s = String(v).replace(/^\uFEFF/, "");
+  s = s.replace(/[\r\n\t]/g, "").trim();
+  if (s.length >= 2 && (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'"))) {
+    s = s.slice(1, -1).trim();
+  }
+  return s || void 0;
+}
+function normalizeBaseURL(raw) {
+  let s = cleanLlmValue(raw);
+  if (!s) return void 0;
+  if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(s)) s = `https://${s}`;
+  s = s.replace(/\/+$/, "");
+  s = s.replace(/\/(chat\/completions|completions|responses|models)$/i, "");
+  return s.replace(/\/+$/, "") || void 0;
+}
+function isReasoningModel(model) {
+  return /^(o\d|gpt-5)/i.test(model);
+}
+
+// src/providers/models.ts
+import {
+  capabilitiesOf,
+  normalizeCapabilities
+} from "@zqagent/shared/model-capabilities";
+async function doFetch(url, init) {
+  const agent = socksAgent();
+  if (agent) {
+    const f = makeSocksFetch(agent);
+    return f(url, init);
+  }
+  return globalThis.fetch(url, init);
+}
+function normalizeModelMeta(v) {
+  if (!Array.isArray(v)) return void 0;
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const x of v) {
+    if (!x || typeof x !== "object") continue;
+    const rec = x;
+    const id = String(rec.id ?? "").trim();
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    const ctx = Number(rec.contextWindow);
+    const capabilities = normalizeCapabilities(rec.capabilities);
+    out.push({
+      id,
+      ...Number.isFinite(ctx) && ctx > 0 ? { contextWindow: ctx } : {},
+      ...capabilities ? { capabilities } : {}
+    });
+    if (out.length >= 500) break;
+  }
+  return out;
+}
+function modelCapabilities(meta, model) {
+  return capabilitiesOf(meta, model);
+}
+function mergeModelMeta(base, patch) {
+  if (!base?.length) return patch;
+  if (!patch?.length) return base;
+  const byId = /* @__PURE__ */ new Map();
+  for (const m of base) byId.set(m.id, { ...m });
+  for (const m of patch) {
+    const prev = byId.get(m.id);
+    byId.set(m.id, {
+      ...prev,
+      ...m,
+      ...prev?.capabilities?.length ? { capabilities: prev.capabilities } : {}
+    });
+  }
+  return [...byId.values()];
+}
+function modelContextWindow(meta, model) {
+  if (!model || !meta?.length) return void 0;
+  const exact = meta.find((m) => m.id === model && m.contextWindow);
+  if (exact?.contextWindow) return exact.contextWindow;
+  const prefix = meta.find((m) => m.contextWindow && model.startsWith(m.id));
+  return prefix?.contextWindow;
+}
+var NON_CHAT_PATTERNS = [
+  /embedding/i,
+  /rerank/i,
+  /(^|[-_/.])(asr|tts)([-_/.]|$)/i,
+  /speech|voice|unisound|audio-?coding/i,
+  /realtime|livetranslate|(^|[-_])s2s([-_]|$)/i,
+  /image|wan\d|z-image|paint|draw|flux|kolors|cogview/i,
+  /deep-research|search-planning/i,
+  /(^|[-_])cmaas[-_]|confidential/i,
+  /(^|[-_])test[-_]|auto-handle|gpu-auto/i
+];
+function isChatModel(modelId) {
+  return !NON_CHAT_PATTERNS.some((re) => re.test(modelId));
+}
+function rankModels(models) {
+  const chat = [];
+  const nonChat = [];
+  for (const m of models) (isChatModel(m) ? chat : nonChat).push(m);
+  return { ordered: [...chat, ...nonChat], nonChat };
+}
+function parseModelList(body) {
+  if (!body || typeof body !== "object") return { models: [], meta: [] };
+  const data = body.data;
+  if (!Array.isArray(data)) return { models: [], meta: [] };
+  const models = [];
+  const meta = [];
+  for (const item of data) {
+    if (!item || typeof item !== "object") continue;
+    const rec = item;
+    const id = rec.id;
+    if (typeof id !== "string" || !id.trim()) continue;
+    models.push(id);
+    const ctx = rec.context_length ?? rec.context_window ?? rec.max_context_length ?? rec.max_input_tokens ?? rec.max_model_len;
+    if (typeof ctx === "number" && ctx > 0) {
+      meta.push({ id, contextWindow: ctx });
+    }
+  }
+  return { models, meta };
+}
+function modelListCandidates(baseURL) {
+  const base = baseURL.replace(/\/+$/, "");
+  if (!base) return [];
+  const out = [];
+  const add = (u) => {
+    if (u && !out.includes(u)) out.push(u);
+  };
+  add(`${base}/models`);
+  if (!/\/v\d+[a-z0-9]*$/i.test(base)) add(`${base}/v1/models`);
+  const root = stripVersionSuffix(base);
+  if (root !== base) {
+    add(`${root}/models`);
+    add(`${root}/v1/models`);
+  }
+  add(`${root}/api/v1/models`);
+  add(`${root}/api/models`);
+  return out.slice(0, 6);
+}
+function stripVersionSuffix(base) {
+  const s = base.replace(/\/+$/, "");
+  const suffixes = [
+    "/compatible-mode/v1",
+    "/compatible-mode",
+    "/openai/v1",
+    "/v1beta",
+    "/v1",
+    // DeepSeek 的 /beta 只用于前缀补全（FIM），模型列表仍在根路径
+    "/beta"
+  ];
+  for (const suf of suffixes) {
+    if (s.toLowerCase().endsWith(suf)) return s.slice(0, -suf.length).replace(/\/+$/, "");
+  }
+  return s;
+}
+async function errorSnippet(resp) {
+  const r = resp;
+  if (typeof r.text !== "function") return void 0;
+  try {
+    const text = (await r.text()).trim();
+    if (!text) return void 0;
+    try {
+      const body = JSON.parse(text);
+      const err = body["error"];
+      const msg = (err && typeof err === "object" ? String(err["message"] ?? "") : "") || String(body["message"] ?? "");
+      if (msg) {
+        return msg.replace(/\s*\(request_id:[^)]*\)/gi, "").slice(0, 160);
+      }
+    } catch {
+    }
+    return text.replace(/\s+/g, " ").slice(0, 200);
+  } catch {
+    return void 0;
+  }
+}
+async function fetchModelsWithDiagnostics(baseURL, apiKey, preferredModel, opts = {}) {
+  const base = normalizeBaseURL(baseURL) ?? baseURL.replace(/\/+$/, "");
+  const key = cleanLlmValue(apiKey) ?? "";
+  const budgetMs = opts.budgetMs ?? 25e3;
+  const timeoutMs = opts.timeoutMs ?? 8e3;
+  const started = Date.now();
+  const attempts = [];
+  const candidates = modelListCandidates(base);
+  let authFailed = false;
+  for (const url of candidates) {
+    const left = budgetMs - (Date.now() - started);
+    if (left < 500) {
+      attempts.push({ url, error: "\u8D85\u51FA\u91CD\u8BD5\u603B\u9884\u7B97\uFF0C\u672A\u5C1D\u8BD5" });
+      continue;
+    }
+    try {
+      const resp = await doFetch(url, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${key}`,
+          Accept: "application/json"
+        },
+        signal: AbortSignal.timeout(Math.min(timeoutMs, left))
+      });
+      if (!resp.ok) {
+        const status = typeof resp.status === "number" ? resp.status : void 0;
+        const detail = await errorSnippet(resp);
+        attempts.push({ url, ...status !== void 0 ? { status } : {}, ...detail ? { error: detail } : {} });
+        if (status === 401 || status === 403) authFailed = true;
+        continue;
+      }
+      const body = await resp.json();
+      const { models, meta } = parseModelList(body);
+      if (models.length === 0) {
+        attempts.push({ url, error: "\u8FD4\u56DE\u7684\u6A21\u578B\u5217\u8868\u4E3A\u7A7A" });
+        continue;
+      }
+      const { ordered, nonChat } = rankModels(models);
+      const filled = await fillContextWindow(base, key, ordered, meta, preferredModel, {
+        budgetMs: Math.max(1e3, budgetMs - (Date.now() - started))
+      });
+      return {
+        result: {
+          models: ordered,
+          endpoint: url,
+          nonChat,
+          ...filled.length > 0 ? { modelMeta: filled } : {}
+        },
+        attempts,
+        authFailed: false
+      };
+    } catch (e) {
+      attempts.push({ url, error: e instanceof Error ? e.message : String(e) });
+    }
+  }
+  return { result: null, attempts, authFailed };
+}
+function describeModelFetchFailure(baseURL, diag) {
+  const lines = diag.attempts.map((a) => {
+    const why = a.status !== void 0 ? `HTTP ${a.status}` : a.error ?? "\u8BF7\u6C42\u5931\u8D25";
+    return `  \xB7 ${a.url} \u2192 ${why}${a.status !== void 0 && a.error ? `\uFF08${a.error}\uFF09` : ""}`;
+  });
+  if (diag.authFailed) {
+    return `\u6A21\u578B\u5217\u8868\u5237\u65B0\u5931\u8D25\uFF1AAPI Key \u65E0\u6548\u6216\u65E0\u6743\u9650\uFF08Base URL\uFF1A${baseURL}\uFF09\u3002
+\u5DF2\u5C1D\u8BD5\uFF1A
+${lines.join("\n")}
+\u8BF7\u68C0\u67E5 Key \u662F\u5426\u586B\u5199\u6B63\u786E\u3001\u662F\u5426\u5DF2\u8FC7\u671F\uFF0C\u6216\u8BE5 Key \u662F\u5426\u6709\u6743\u8BBF\u95EE\u6B64\u7AEF\u70B9\u3002`;
+  }
+  return `\u6A21\u578B\u5217\u8868\u5237\u65B0\u5931\u8D25\uFF1A\u6240\u6709\u5019\u9009\u7AEF\u70B9\u90FD\u6CA1\u6709\u8FD4\u56DE\u53EF\u7528\u6A21\u578B\uFF08Base URL\uFF1A${baseURL}\uFF09\u3002
+\u5DF2\u5C1D\u8BD5\uFF1A
+${lines.join("\n")}
+\u8BF7\u786E\u8BA4 Base URL \u662F\u5426\u6B63\u786E\uFF08\u4E00\u822C\u586B\u5230 /v1 \u4E3A\u6B62\uFF0C\u5982 https://api.deepseek.com\uFF09\uFF0C\u4EE5\u53CA\u8BE5\u670D\u52A1\u662F\u5426\u63D0\u4F9B OpenAI \u517C\u5BB9\u7684 GET /models \u63A5\u53E3\u3002`;
+}
+async function fillContextWindow(base, key, models, meta, preferred, opts = {}) {
+  if (meta.length > 0) return meta;
+  const target = preferred?.trim() || models[0];
+  if (!target) return meta;
+  const ctx = await fetchModelContext(base, key, target, opts.budgetMs);
+  return ctx ? [{ id: target, contextWindow: ctx }] : meta;
+}
+async function fetchModels(baseURL, apiKey, preferredModel) {
+  const diag = await fetchModelsWithDiagnostics(baseURL, apiKey, preferredModel);
+  return diag.result;
+}
+async function fetchModelContext(baseURL, apiKey, modelId, timeoutMs = 1e4) {
+  if (!modelId) return void 0;
+  const base = normalizeBaseURL(baseURL) ?? baseURL.replace(/\/+$/, "");
+  const key = cleanLlmValue(apiKey) ?? "";
+  try {
+    const resp = await doFetch(`${base}/models/${encodeURIComponent(modelId)}`, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${key}`, Accept: "application/json" },
+      signal: AbortSignal.timeout(Math.max(500, timeoutMs))
+    });
+    if (!resp.ok) return void 0;
+    const body = await resp.json();
+    const rec = body ?? {};
+    const inner = rec.data && typeof rec.data === "object" && !Array.isArray(rec.data) ? rec.data : rec;
+    return parseModelList({ data: [inner] }).meta[0]?.contextWindow;
+  } catch {
+    return void 0;
+  }
+}
+function extractError(body) {
+  const b = body ?? {};
+  const e = b.error ?? b;
+  const message = String(e.message ?? b.message ?? "").trim();
+  const code = typeof e.code === "string" ? e.code : typeof b.code === "string" ? b.code : void 0;
+  const requestId = typeof b.request_id === "string" ? b.request_id : void 0;
+  return {
+    message: message || "\u672A\u77E5\u9519\u8BEF",
+    code: code ? `${code}${requestId ? ` (request_id=${requestId})` : ""}` : void 0
+  };
+}
+async function probeModel(baseURL, apiKey, model) {
+  const base = normalizeBaseURL(baseURL) ?? baseURL.replace(/\/+$/, "");
+  const key = cleanLlmValue(apiKey) ?? "";
+  const started = Date.now();
+  try {
+    const resp = await doFetch(`${base}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${key}`
+      },
+      body: JSON.stringify({
+        model,
+        messages: [{ role: "user", content: "ping" }],
+        // 与 Provider 共用 isReasoningModel：o 系列 / gpt-5 只接受
+        // max_completion_tokens，传 max_tokens 会 400，把可用模型误判成不可用
+        ...isReasoningModel(model) ? { max_completion_tokens: 8 } : { max_tokens: 8 },
+        stream: false
+      }),
+      signal: AbortSignal.timeout(2e4)
+    });
+    const latencyMs = Date.now() - started;
+    if (resp.ok) return { ok: true, latencyMs };
+    let body = null;
+    try {
+      body = await resp.json();
+    } catch {
+    }
+    const { message, code } = extractError(body);
+    return {
+      ok: false,
+      error: `HTTP ${resp.status} ${message}`,
+      ...code ? { code } : {},
+      latencyMs
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err.message : String(err),
+      latencyMs: Date.now() - started
+    };
+  }
+}
+export {
+  describeModelFetchFailure,
+  fetchModelContext,
+  fetchModels,
+  fetchModelsWithDiagnostics,
+  isChatModel,
+  mergeModelMeta,
+  modelCapabilities,
+  modelContextWindow,
+  modelListCandidates,
+  normalizeModelMeta,
+  probeModel,
+  stripVersionSuffix
+};
+//# sourceMappingURL=models.js.map