@zqagent/core 0.2.20 → 0.3.6

package/dist/internal/llmConfig.cjs

@@ -0,0 +1,561 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/llmConfig.ts
+var llmConfig_exports = {};
+__export(llmConfig_exports, {
+  autoProviderName: () => autoProviderName,
+  commonLegacyFiles: () => commonLegacyFiles,
+  decryptKey: () => decryptKey,
+  encryptKey: () => encryptKey,
+  fixStaleName: () => fixStaleName,
+  llmConfigFile: () => llmConfigFile,
+  newProviderId: () => newProviderId,
+  readLlmConfig: () => readLlmConfig,
+  writeLlmConfig: () => writeLlmConfig
+});
+module.exports = __toCommonJS(llmConfig_exports);
+var fs = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+var crypto = __toESM(require("crypto"), 1);
+
+// src/crypto/secrets.ts
+var secrets_exports = {};
+__reExport(secrets_exports, require("@zqagent/shared/secrets"));
+
+// src/providers/proxy.ts
+var import_node_fetch = __toESM(require("node-fetch"), 1);
+
+// ../../node_modules/.pnpm/socks-proxy-agent@9.0.0_supports-color@7.2.0/node_modules/socks-proxy-agent/dist/index.js
+var import_socks = require("socks");
+
+// ../../node_modules/.pnpm/agent-base@8.0.0/node_modules/agent-base/dist/index.js
+var net = __toESM(require("net"), 1);
+var http = __toESM(require("http"), 1);
+var import_https = require("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 import_https.Agent.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
+var import_debug = __toESM(require("debug"), 1);
+var dns = __toESM(require("dns"), 1);
+var net2 = __toESM(require("net"), 1);
+var tls = __toESM(require("tls"), 1);
+var import_url = require("url");
+var debug = (0, import_debug.default)("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 import_url.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 import_socks.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/models.ts
+var import_model_capabilities = require("@zqagent/shared/model-capabilities");
+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 = (0, import_model_capabilities.normalizeCapabilities)(rec.capabilities);
+    out.push({
+      id,
+      ...Number.isFinite(ctx) && ctx > 0 ? { contextWindow: ctx } : {},
+      ...capabilities ? { capabilities } : {}
+    });
+    if (out.length >= 500) break;
+  }
+  return out;
+}
+
+// src/paths.ts
+var os = __toESM(require("os"), 1);
+var path = __toESM(require("path"), 1);
+var APP_DIR_NAME = "zqagent";
+var IS_WINDOWS = process.platform === "win32";
+function homeDir() {
+  return process.env.HOME || process.env.USERPROFILE || os.homedir() || os.tmpdir();
+}
+function configDir() {
+  const base = process.env.XDG_CONFIG_HOME || (IS_WINDOWS ? process.env.APPDATA : void 0) || path.join(homeDir(), ".config");
+  return path.join(base, APP_DIR_NAME);
+}
+function stateDir() {
+  const base = process.env.XDG_STATE_HOME || (IS_WINDOWS ? process.env.LOCALAPPDATA : void 0) || path.join(homeDir(), ".local", "state");
+  return path.join(base, APP_DIR_NAME);
+}
+
+// src/llmConfig.ts
+var import_llm_presets = require("@zqagent/shared/llm-presets");
+function llmConfigFile() {
+  const override = process.env.ZQAGENT_LLM_CONFIG_FILE?.trim();
+  if (override) return override;
+  return path2.join(configDir(), "connections.json");
+}
+var keyCache = /* @__PURE__ */ new Map();
+function masterKeyFileFor(file) {
+  return path2.join(path2.dirname(file), "secret.key");
+}
+function getMasterKey(file) {
+  const keyFile = masterKeyFileFor(file);
+  let key = keyCache.get(keyFile);
+  if (!key) {
+    key = (0, secrets_exports.loadOrCreateMasterKey)(keyFile);
+    keyCache.set(keyFile, key);
+  }
+  return key;
+}
+function encryptKey(plain, file = llmConfigFile()) {
+  return (0, secrets_exports.encryptWithKey)(getMasterKey(file), plain);
+}
+function decryptKey(payload, file = llmConfigFile()) {
+  return (0, secrets_exports.decryptWithKey)(getMasterKey(file), payload);
+}
+function newProviderId() {
+  return crypto.randomBytes(8).toString("hex");
+}
+function normEffort(v) {
+  return v === "low" || v === "medium" || v === "high" ? v : null;
+}
+function normModelList(v) {
+  if (!Array.isArray(v)) return void 0;
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const x of v) {
+    const s = String(x ?? "").trim();
+    if (!s || seen.has(s)) continue;
+    seen.add(s);
+    out.push(s);
+    if (out.length >= 500) break;
+  }
+  return out.length ? out : void 0;
+}
+function guessTypeByBaseURL(baseURL) {
+  const u = baseURL.toLowerCase().replace(/\/+$/, "");
+  if (!u) return "custom";
+  for (const p of KNOWN_PRESETS) {
+    const b = p.baseURL.toLowerCase().replace(/\/+$/, "");
+    if (b && (u === b || u.startsWith(b))) return p.id;
+  }
+  return "custom";
+}
+var KNOWN_PRESETS = ["openai", "deepseek", "qwen", "zhipu", "moonshot", "xiaomi"].map(
+  (id) => ({ id, baseURL: (0, import_llm_presets.llmPreset)(id)?.baseURL ?? "" })
+);
+function parseEntry(o, file) {
+  if (!o || typeof o !== "object") return null;
+  const r = o;
+  const baseURL = typeof r.baseURL === "string" ? r.baseURL : "";
+  const model = typeof r.model === "string" ? r.model : "";
+  let type = String(r.type ?? r.provider ?? "").trim();
+  if (!type) type = guessTypeByBaseURL(baseURL);
+  let apiKeyEnc = typeof r.apiKeyEnc === "string" ? r.apiKeyEnc : "";
+  const plain = typeof r.apiKey === "string" ? r.apiKey.trim() : "";
+  if (!apiKeyEnc && plain) apiKeyEnc = encryptKey(plain, file);
+  if (!baseURL && !model && !apiKeyEnc && !type) return null;
+  const models = normModelList(r.models);
+  const nonChat = normModelList(r.nonChat);
+  const modelMeta = normalizeModelMeta(r.modelMeta);
+  const name = String(r.name ?? "").trim() || autoProviderName(type, model);
+  return {
+    id: typeof r.id === "string" && r.id ? r.id : newProviderId(),
+    name,
+    type,
+    baseURL,
+    model,
+    reasoningEffort: normEffort(r.reasoningEffort),
+    apiKeyEnc,
+    ...models ? { models } : {},
+    ...nonChat ? { nonChat } : {},
+    ...modelMeta ? { modelMeta } : {}
+  };
+}
+function autoProviderName(type, model) {
+  const name = (0, import_llm_presets.llmPreset)(type)?.name ?? type ?? "";
+  return model ? `${name} \xB7 ${model}` : name;
+}
+var PRESET_NAMES = new Set(
+  ["openai", "deepseek", "qwen", "zhipu", "moonshot", "xiaomi", "custom"].map(
+    (id) => (0, import_llm_presets.llmPreset)(id)?.name ?? ""
+  )
+);
+function fixStaleName(p) {
+  const label = (0, import_llm_presets.llmPreset)(p.type)?.name ?? p.type;
+  const fresh = autoProviderName(p.type, p.model);
+  if (p.name === fresh) return false;
+  const looksAuto = p.name === label || p.name.startsWith(`${label} \xB7 `) || PRESET_NAMES.has(p.name);
+  if (!looksAuto) return false;
+  p.name = fresh;
+  return true;
+}
+function emptyConfig() {
+  return { version: 3, activeId: null, providers: [] };
+}
+function normalize(f) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const p of f.providers) byId.set(p.id, p);
+  const providers = [...byId.values()];
+  const activeId = providers.some((p) => p.id === f.activeId) ? f.activeId : providers[0]?.id ?? null;
+  return { ...f, providers, activeId };
+}
+function readRaw(file, keyFile = file) {
+  if (!fs.existsSync(file)) return null;
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+  if (!raw || typeof raw !== "object") return null;
+  const o = raw;
+  if (Array.isArray(o.providers)) {
+    const providers = o.providers.map((x) => parseEntry(x, keyFile)).filter((p) => p !== null);
+    const activeId = typeof o.activeId === "string" ? o.activeId : typeof o.defaultProviderId === "string" ? o.defaultProviderId : null;
+    const migratedFrom = Array.isArray(o.migratedFrom) ? o.migratedFrom.filter((x) => typeof x === "string") : void 0;
+    return normalize({
+      version: 3,
+      activeId,
+      providers,
+      ...migratedFrom ? { migratedFrom } : {}
+    });
+  }
+  const single = parseEntry(o, keyFile);
+  if (single) return { version: 3, activeId: single.id, providers: [single] };
+  return null;
+}
+function mergeExternal(base, file, targetFile) {
+  const migrated = base.migratedFrom ?? [];
+  if (migrated.includes(file)) return { config: base, changed: false };
+  const ext = readRaw(file, targetFile);
+  if (!ext || ext.providers.length === 0) {
+    return { config: base, changed: false };
+  }
+  const have = new Set(base.providers.map((p) => p.id));
+  const added = ext.providers.filter((p) => !have.has(p.id));
+  const config = normalize({
+    ...base,
+    providers: [...base.providers, ...added],
+    activeId: base.activeId ?? ext.activeId,
+    migratedFrom: [...migrated, file]
+  });
+  return { config, changed: true };
+}
+function readLlmConfig(opts = {}) {
+  const file = opts.file ?? llmConfigFile();
+  let f = readRaw(file) ?? emptyConfig();
+  let changed = false;
+  if (f.providers.map(fixStaleName).some(Boolean)) changed = true;
+  for (const legacy of opts.legacyFiles ?? []) {
+    const r = mergeExternal(f, legacy, file);
+    f = r.config;
+    changed = changed || r.changed;
+  }
+  if (changed || !fs.existsSync(file)) writeLlmConfig(f, file);
+  return f;
+}
+function writeLlmConfig(f, file = llmConfigFile()) {
+  const next = normalize(f);
+  fs.mkdirSync(path2.dirname(file), { recursive: true, mode: 448 });
+  fs.writeFileSync(file, JSON.stringify(next, null, 2) + "\n", {
+    mode: 384,
+    encoding: "utf8"
+  });
+}
+function commonLegacyFiles() {
+  return [path2.join(stateDir(), "data", "node-llm.json")];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  autoProviderName,
+  commonLegacyFiles,
+  decryptKey,
+  encryptKey,
+  fixStaleName,
+  llmConfigFile,
+  newProviderId,
+  readLlmConfig,
+  writeLlmConfig
+});
+//# sourceMappingURL=llmConfig.cjs.map