llmjs2 1.7.1 → 2.0.1

package/dist/index.mjs

@@ -0,0 +1,1211 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/dotenv/lib/main.js
+var require_main = __commonJS({
+  "node_modules/dotenv/lib/main.js"(exports, module) {
+    "use strict";
+    var fs3 = __require("fs");
+    var path2 = __require("path");
+    var os = __require("os");
+    var crypto = __require("crypto");
+    var TIPS = [
+      "\u25C8 encrypted .env [www.dotenvx.com]",
+      "\u25C8 secrets for agents [www.dotenvx.com]",
+      "\u2301 auth for agents [www.vestauth.com]",
+      "\u2318 custom filepath { path: '/custom/path/.env' }",
+      "\u2318 enable debugging { debug: true }",
+      "\u2318 override existing { override: true }",
+      "\u2318 suppress logs { quiet: true }",
+      "\u2318 multiple files { path: ['.env.local', '.env'] }"
+    ];
+    function _getRandomTip() {
+      return TIPS[Math.floor(Math.random() * TIPS.length)];
+    }
+    function parseBoolean(value) {
+      if (typeof value === "string") {
+        return !["false", "0", "no", "off", ""].includes(value.toLowerCase());
+      }
+      return Boolean(value);
+    }
+    function supportsAnsi() {
+      return process.stdout.isTTY;
+    }
+    function dim(text) {
+      return supportsAnsi() ? `\x1B[2m${text}\x1B[0m` : text;
+    }
+    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+    function parse(src) {
+      const obj = {};
+      let lines = src.toString();
+      lines = lines.replace(/\r\n?/mg, "\n");
+      let match;
+      while ((match = LINE.exec(lines)) != null) {
+        const key = match[1];
+        let value = match[2] || "";
+        value = value.trim();
+        const maybeQuote = value[0];
+        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+        if (maybeQuote === '"') {
+          value = value.replace(/\\n/g, "\n");
+          value = value.replace(/\\r/g, "\r");
+        }
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _parseVault(options) {
+      options = options || {};
+      const vaultPath = _vaultPath(options);
+      options.path = vaultPath;
+      const result = DotenvModule.configDotenv(options);
+      if (!result.parsed) {
+        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+        err.code = "MISSING_DATA";
+        throw err;
+      }
+      const keys = _dotenvKey(options).split(",");
+      const length = keys.length;
+      let decrypted;
+      for (let i = 0; i < length; i++) {
+        try {
+          const key = keys[i].trim();
+          const attrs = _instructions(result, key);
+          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+          break;
+        } catch (error) {
+          if (i + 1 >= length) {
+            throw error;
+          }
+        }
+      }
+      return DotenvModule.parse(decrypted);
+    }
+    function _warn(message) {
+      console.error(`\u26A0 ${message}`);
+    }
+    function _debug(message) {
+      console.log(`\u2506 ${message}`);
+    }
+    function _log(message) {
+      console.log(`\u25C7 ${message}`);
+    }
+    function _dotenvKey(options) {
+      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+        return options.DOTENV_KEY;
+      }
+      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+        return process.env.DOTENV_KEY;
+      }
+      return "";
+    }
+    function _instructions(result, dotenvKey) {
+      let uri;
+      try {
+        uri = new URL(dotenvKey);
+      } catch (error) {
+        if (error.code === "ERR_INVALID_URL") {
+          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        }
+        throw error;
+      }
+      const key = uri.password;
+      if (!key) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environment = uri.searchParams.get("environment");
+      if (!environment) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+      const ciphertext = result.parsed[environmentKey];
+      if (!ciphertext) {
+        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+        throw err;
+      }
+      return { ciphertext, key };
+    }
+    function _vaultPath(options) {
+      let possibleVaultPath = null;
+      if (options && options.path && options.path.length > 0) {
+        if (Array.isArray(options.path)) {
+          for (const filepath of options.path) {
+            if (fs3.existsSync(filepath)) {
+              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+            }
+          }
+        } else {
+          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+        }
+      } else {
+        possibleVaultPath = path2.resolve(process.cwd(), ".env.vault");
+      }
+      if (fs3.existsSync(possibleVaultPath)) {
+        return possibleVaultPath;
+      }
+      return null;
+    }
+    function _resolveHome(envPath) {
+      return envPath[0] === "~" ? path2.join(os.homedir(), envPath.slice(1)) : envPath;
+    }
+    function _configVault(options) {
+      const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
+      const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
+      if (debug || !quiet) {
+        _log("loading env from encrypted .env.vault");
+      }
+      const parsed = DotenvModule._parseVault(options);
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsed, options);
+      return { parsed };
+    }
+    function configDotenv(options) {
+      const dotenvPath = path2.resolve(process.cwd(), ".env");
+      let encoding = "utf8";
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
+      let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
+      if (options && options.encoding) {
+        encoding = options.encoding;
+      } else {
+        if (debug) {
+          _debug("no encoding is specified (UTF-8 is used by default)");
+        }
+      }
+      let optionPaths = [dotenvPath];
+      if (options && options.path) {
+        if (!Array.isArray(options.path)) {
+          optionPaths = [_resolveHome(options.path)];
+        } else {
+          optionPaths = [];
+          for (const filepath of options.path) {
+            optionPaths.push(_resolveHome(filepath));
+          }
+        }
+      }
+      let lastError;
+      const parsedAll = {};
+      for (const path3 of optionPaths) {
+        try {
+          const parsed = DotenvModule.parse(fs3.readFileSync(path3, { encoding }));
+          DotenvModule.populate(parsedAll, parsed, options);
+        } catch (e) {
+          if (debug) {
+            _debug(`failed to load ${path3} ${e.message}`);
+          }
+          lastError = e;
+        }
+      }
+      const populated = DotenvModule.populate(processEnv, parsedAll, options);
+      debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+      quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+      if (debug || !quiet) {
+        const keysCount = Object.keys(populated).length;
+        const shortPaths = [];
+        for (const filePath of optionPaths) {
+          try {
+            const relative = path2.relative(process.cwd(), filePath);
+            shortPaths.push(relative);
+          } catch (e) {
+            if (debug) {
+              _debug(`failed to load ${filePath} ${e.message}`);
+            }
+            lastError = e;
+          }
+        }
+        _log(`injected env (${keysCount}) from ${shortPaths.join(",")} ${dim(`// tip: ${_getRandomTip()}`)}`);
+      }
+      if (lastError) {
+        return { parsed: parsedAll, error: lastError };
+      } else {
+        return { parsed: parsedAll };
+      }
+    }
+    function config(options) {
+      if (_dotenvKey(options).length === 0) {
+        return DotenvModule.configDotenv(options);
+      }
+      const vaultPath = _vaultPath(options);
+      if (!vaultPath) {
+        _warn(`you set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}`);
+        return DotenvModule.configDotenv(options);
+      }
+      return DotenvModule._configVault(options);
+    }
+    function decrypt(encrypted, keyStr) {
+      const key = Buffer.from(keyStr.slice(-64), "hex");
+      let ciphertext = Buffer.from(encrypted, "base64");
+      const nonce = ciphertext.subarray(0, 12);
+      const authTag = ciphertext.subarray(-16);
+      ciphertext = ciphertext.subarray(12, -16);
+      try {
+        const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+        aesgcm.setAuthTag(authTag);
+        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+      } catch (error) {
+        const isRange = error instanceof RangeError;
+        const invalidKeyLength = error.message === "Invalid key length";
+        const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+        if (isRange || invalidKeyLength) {
+          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        } else if (decryptionFailed) {
+          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+          err.code = "DECRYPTION_FAILED";
+          throw err;
+        } else {
+          throw error;
+        }
+      }
+    }
+    function populate(processEnv, parsed, options = {}) {
+      const debug = Boolean(options && options.debug);
+      const override = Boolean(options && options.override);
+      const populated = {};
+      if (typeof parsed !== "object") {
+        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+        err.code = "OBJECT_REQUIRED";
+        throw err;
+      }
+      for (const key of Object.keys(parsed)) {
+        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+          if (override === true) {
+            processEnv[key] = parsed[key];
+            populated[key] = parsed[key];
+          }
+          if (debug) {
+            if (override === true) {
+              _debug(`"${key}" is already defined and WAS overwritten`);
+            } else {
+              _debug(`"${key}" is already defined and was NOT overwritten`);
+            }
+          }
+        } else {
+          processEnv[key] = parsed[key];
+          populated[key] = parsed[key];
+        }
+      }
+      return populated;
+    }
+    var DotenvModule = {
+      configDotenv,
+      _configVault,
+      _parseVault,
+      config,
+      decrypt,
+      parse,
+      populate
+    };
+    module.exports.configDotenv = DotenvModule.configDotenv;
+    module.exports._configVault = DotenvModule._configVault;
+    module.exports._parseVault = DotenvModule._parseVault;
+    module.exports.config = DotenvModule.config;
+    module.exports.decrypt = DotenvModule.decrypt;
+    module.exports.parse = DotenvModule.parse;
+    module.exports.populate = DotenvModule.populate;
+    module.exports = DotenvModule;
+  }
+});
+
+// src/config.ts
+function getConfig() {
+  return {
+    openai: {
+      apiKey: process.env.OPENAI_API_KEY,
+      baseUrl: process.env.OPENAI_BASE_URL || "https://api.openai.com/v1",
+      defaultModel: process.env.OPENAI_DEFAULT_MODEL || "gpt-3.5-turbo"
+    },
+    openrouter: {
+      apiKey: process.env.OPEN_ROUTER_API_KEY,
+      baseUrl: process.env.OPEN_ROUTER_BASE_URL || "https://openrouter.ai/api/v1/chat/completions",
+      defaultModel: process.env.OPEN_ROUTER_DEFAULT_MODEL || "openrouter/free"
+    },
+    ollama: {
+      apiKey: process.env.OLLAMA_API_KEY,
+      baseUrl: process.env.OLLAMA_BASE_URL || "http://localhost:1234",
+      defaultModel: process.env.OLLAMA_DEFAULT_MODEL || "gemma4:31b-cloud"
+    },
+    bigmodel: {
+      apiKey: process.env.BIGMODEL_API_KEY,
+      baseUrl: process.env.BIGMODEL_BASE_URL || "https://open.bigmodel.cn/api/paas/v4/chat/completions",
+      defaultModel: process.env.BIGMODEL_DEFAULT_MODEL || "glm-4.7-flash"
+    }
+  };
+}
+
+// src/tools.ts
+function convertToOpenAITools(tools) {
+  if (!tools || tools.length === 0) {
+    return void 0;
+  }
+  return tools.map((tool) => {
+    const properties = {};
+    const required = [];
+    for (const [paramName, paramDef] of Object.entries(tool.parameters)) {
+      properties[paramName] = {
+        type: paramDef.type,
+        description: paramDef.description
+      };
+      if (paramDef.required) {
+        required.push(paramName);
+      }
+    }
+    return {
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: {
+          type: "object",
+          properties,
+          required: required.length > 0 ? required : void 0
+        }
+      }
+    };
+  });
+}
+function convertToOllamaTools(tools) {
+  return convertToOpenAITools(tools);
+}
+
+// src/logger.ts
+import pino from "pino";
+var currentVerboseLevel = "none";
+var getPinoLevel = (level) => {
+  switch (level) {
+    case "debug":
+      return "debug";
+    case "info":
+      return "info";
+    case "none":
+    default:
+      return "silent";
+  }
+};
+var logger = pino({
+  level: getPinoLevel(currentVerboseLevel),
+  transport: process.env.NODE_ENV !== "production" ? {
+    target: "pino-pretty",
+    options: {
+      colorize: true,
+      translateTime: "SYS:standard"
+    }
+  } : void 0
+});
+function verbose(level) {
+  currentVerboseLevel = level;
+  logger.level = getPinoLevel(level);
+}
+
+// src/utils.ts
+function formatMessages(messages) {
+  return messages.map((msg) => {
+    if (msg.images && msg.images.length > 0) {
+      const content = [{ type: "text", text: msg.content }];
+      for (const image of msg.images) {
+        content.push({
+          type: "image_url",
+          image_url: { url: `data:image/jpeg;base64,${image}` }
+        });
+      }
+      return {
+        ...msg,
+        content,
+        images: void 0
+      };
+    }
+    return msg;
+  });
+}
+async function fetchWithRetry(url, options = {}) {
+  const { timeout = 3e4, retries = 2, retryDelay = 1e3, ...fetchOptions } = options;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    const controller = new AbortController();
+    const id = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await fetch(url, {
+        ...fetchOptions,
+        signal: controller.signal
+      });
+      clearTimeout(id);
+      if (!response.ok) {
+        const isTransient = response.status >= 500 || response.status === 429;
+        if (isTransient && attempt < retries) {
+          logger.warn(
+            {
+              url,
+              status: response.status,
+              attempt: attempt + 1,
+              method: fetchOptions.method,
+              body: fetchOptions.body
+            },
+            "Transient error, retrying..."
+          );
+          await new Promise((res) => setTimeout(res, retryDelay * Math.pow(2, attempt)));
+          continue;
+        }
+      }
+      return response;
+    } catch (error) {
+      clearTimeout(id);
+      const isAbort = error.name === "AbortError";
+      if ((isAbort || error.message.includes("fetch failed")) && attempt < retries) {
+        logger.warn(
+          {
+            url,
+            error: error.message,
+            attempt: attempt + 1,
+            method: fetchOptions.method,
+            body: fetchOptions.body
+          },
+          "Network error or timeout, retrying..."
+        );
+        await new Promise((res) => setTimeout(res, retryDelay * Math.pow(2, attempt)));
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw new Error(`Fetch failed after ${retries} retries`);
+}
+
+// src/providers/openai.ts
+async function openaiCompletion(options, config, modelName) {
+  const apiKey = options.apiKey || config.openai.apiKey;
+  const baseUrl = options.baseUrl || options.host || config.openai.baseUrl || "https://api.openai.com/v1";
+  if (!apiKey) {
+    throw new Error("OpenAI API key is required");
+  }
+  const normalizedBaseUrl = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  const url = normalizedBaseUrl.endsWith("/chat/completions") ? normalizedBaseUrl : `${normalizedBaseUrl}/chat/completions`;
+  const tools = convertToOpenAITools(options.tools);
+  const messages = formatMessages(options.messages);
+  const body = {
+    model: modelName,
+    messages
+  };
+  if (tools) {
+    body.tools = tools;
+  }
+  logger.debug({ url, body, provider: "openai" }, "Sending request to OpenAI");
+  const response = await fetchWithRetry(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(body)
+  });
+  const rawText = await response.text();
+  logger.debug({ response: rawText, provider: "openai" }, "Received raw response from OpenAI");
+  if (!response.ok) {
+    logger.error(
+      { url, model: modelName, body, provider: "openai" },
+      "OpenAI request failed"
+    );
+    throw new Error(`OpenAI API error (${response.status}): ${rawText}`);
+  }
+  const data = JSON.parse(rawText);
+  return data;
+}
+
+// src/providers/openrouter.ts
+async function openrouterCompletion(options, config, modelName) {
+  const apiKey = options.apiKey || config.openrouter.apiKey;
+  const baseUrl = options.baseUrl || options.host || config.openrouter.baseUrl || "https://openrouter.ai/api/v1/chat/completions";
+  if (!apiKey) {
+    throw new Error("OpenRouter API key is required");
+  }
+  const url = baseUrl;
+  const tools = convertToOpenAITools(options.tools);
+  const messages = formatMessages(options.messages);
+  const body = {
+    model: modelName,
+    messages
+  };
+  if (tools) {
+    body.tools = tools;
+  }
+  logger.debug({ url, body, provider: "openrouter" }, "Sending request to OpenRouter");
+  const response = await fetchWithRetry(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`,
+      "HTTP-Referer": "https://github.com/llmjs2",
+      // Required by OpenRouter
+      "X-Title": "llmjs2"
+      // Optional but recommended by OpenRouter
+    },
+    body: JSON.stringify(body)
+  });
+  const rawText = await response.text();
+  logger.debug({ response: rawText, provider: "openrouter" }, "Received raw response from OpenRouter");
+  if (!response.ok) {
+    logger.error(
+      { url, model: modelName, body, provider: "openrouter" },
+      "OpenRouter request failed"
+    );
+    throw new Error(`OpenRouter API error (${response.status}): ${rawText}`);
+  }
+  const data = JSON.parse(rawText);
+  return data;
+}
+
+// src/providers/ollama.ts
+async function ollamaCompletion(options, config, modelName) {
+  const baseUrl = options.baseUrl || options.host || config.ollama.baseUrl || "http://localhost:11434";
+  const apiKey = options.apiKey || config.ollama.apiKey;
+  const normalizedBaseUrl = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  const url = normalizedBaseUrl.endsWith("/api/chat") ? normalizedBaseUrl : `${normalizedBaseUrl}/api/chat`;
+  const tools = convertToOllamaTools(options.tools);
+  const body = {
+    model: modelName,
+    messages: options.messages,
+    stream: false
+    // Ensure we get a single response object
+  };
+  if (tools) {
+    body.tools = tools;
+  }
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (apiKey) {
+    headers["Authorization"] = `Bearer ${apiKey}`;
+  }
+  logger.debug({ url, body, provider: "ollama" }, "Sending request to Ollama");
+  const response = await fetchWithRetry(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body)
+  });
+  const rawText = await response.text();
+  logger.debug({ response: rawText, provider: "ollama" }, "Received raw response from Ollama");
+  if (!response.ok) {
+    logger.error(
+      { url, model: modelName, body, provider: "ollama" },
+      "Ollama request failed"
+    );
+    throw new Error(`Ollama API error (${response.status}): ${rawText}`);
+  }
+  const data = JSON.parse(rawText);
+  const normalizedResponse = {
+    id: `ollama-${Date.now()}`,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1e3),
+    model: data.model,
+    choices: [
+      {
+        index: 0,
+        message: data.message,
+        finish_reason: data.done ? "stop" : "length"
+      }
+    ],
+    usage: {
+      prompt_tokens: data.prompt_eval_count || 0,
+      completion_tokens: data.eval_count || 0,
+      total_tokens: (data.prompt_eval_count || 0) + (data.eval_count || 0)
+    }
+  };
+  return normalizedResponse;
+}
+
+// src/providers/bigmodel.ts
+async function bigmodelCompletion(options, config, modelName) {
+  const apiKey = options.apiKey || config.bigmodel.apiKey;
+  const baseUrl = options.baseUrl || options.host || config.bigmodel.baseUrl || "https://open.bigmodel.cn/api/paas/v4/chat/completions";
+  if (!apiKey) {
+    throw new Error("BigModel API key is required");
+  }
+  const url = baseUrl;
+  const messages = formatMessages(options.messages);
+  const body = {
+    model: modelName,
+    messages
+  };
+  const anyOpts = options;
+  if (anyOpts.thinking !== void 0) body.thinking = anyOpts.thinking;
+  if (anyOpts.max_tokens !== void 0) body.max_tokens = anyOpts.max_tokens;
+  if (anyOpts.temperature !== void 0) body.temperature = anyOpts.temperature;
+  logger.debug({ url, body, provider: "bigmodel" }, "Sending request to BigModel");
+  const response = await fetchWithRetry(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(body)
+  });
+  const rawText = await response.text();
+  logger.debug({ response: rawText, provider: "bigmodel" }, "Received raw response from BigModel");
+  if (!response.ok) {
+    logger.error(
+      { url, model: modelName, body, provider: "bigmodel" },
+      "BigModel request failed"
+    );
+    throw new Error(`BigModel API error (${response.status}): ${rawText}`);
+  }
+  const data = JSON.parse(rawText);
+  return data;
+}
+
+// src/completion.ts
+try {
+  const dotenv = require_main();
+  if (dotenv && dotenv.config) {
+    dotenv.config();
+  }
+} catch (e) {
+}
+async function completion(promptOrOptions) {
+  const config = getConfig();
+  logger.debug({ inputType: typeof promptOrOptions }, "completion() called");
+  let options;
+  const selectedProvider = config.openai.apiKey ? "openai" : config.openrouter.apiKey ? "openrouter" : config.bigmodel.apiKey ? "bigmodel" : config.ollama.apiKey ? "ollama" : null;
+  const getProviderModel = (provider2) => {
+    switch (provider2) {
+      case "openai":
+        return process.env.OPENAI_DEFAULT_MODEL || config.openai.defaultModel || "gpt-4o-mini";
+      case "openrouter":
+        return process.env.OPEN_ROUTER_DEFAULT_MODEL || config.openrouter.defaultModel || "openai/gpt-4o-mini";
+      case "bigmodel":
+        return process.env.BIGMODEL_DEFAULT_MODEL || config.bigmodel.defaultModel || "glm-4.7-flash";
+      case "ollama":
+        return process.env.OLLAMA_DEFAULT_MODEL || config.ollama.defaultModel || "llama3.2";
+      default:
+        throw new Error(`Unsupported provider: ${provider2}`);
+    }
+  };
+  const resolveModel = (explicitModel) => {
+    if (explicitModel) {
+      return explicitModel;
+    }
+    if (process.env.LLM_DEFAULT_MODEL) {
+      return process.env.LLM_DEFAULT_MODEL;
+    }
+    if (!selectedProvider) {
+      throw new Error(
+        "No model specified. Set LLM_DEFAULT_MODEL / provider default model env, provide `model` in options, or configure one of OPENAI_API_KEY / OPEN_ROUTER_API_KEY / BIGMODEL_API_KEY / OLLAMA_API_KEY."
+      );
+    }
+    return `${selectedProvider}/${getProviderModel(selectedProvider)}`;
+  };
+  if (typeof promptOrOptions === "string") {
+    options = {
+      model: resolveModel(),
+      messages: [{ role: "user", content: promptOrOptions }]
+    };
+  } else {
+    options = {
+      ...promptOrOptions,
+      model: resolveModel(promptOrOptions.model)
+    };
+  }
+  if (!options.model) {
+    throw new Error('No model specified. Provide `model` in options (format: "provider/model_name") or set LLM_DEFAULT_MODEL.');
+  }
+  const firstSlashIndex = options.model.indexOf("/");
+  if (firstSlashIndex === -1) {
+    throw new Error('Invalid model format. Expected "provider/model_name"');
+  }
+  const provider = options.model.substring(0, firstSlashIndex);
+  const modelName = options.model.substring(firstSlashIndex + 1);
+  logger.info({ provider, model: modelName }, "Dispatching completion request");
+  let response;
+  switch (provider) {
+    case "openai":
+      response = await openaiCompletion(options, config, modelName);
+      break;
+    case "openrouter":
+      response = await openrouterCompletion(options, config, modelName);
+      break;
+    case "bigmodel":
+      response = await bigmodelCompletion(options, config, modelName);
+      break;
+    case "ollama":
+      response = await ollamaCompletion(options, config, modelName);
+      break;
+    default:
+      throw new Error(`Unsupported provider: ${provider}`);
+  }
+  if (typeof promptOrOptions === "string") {
+    const text = response.choices?.[0]?.message?.content || response.message?.content || "";
+    logger.debug({ provider, model: modelName, responseType: "text" }, "completion() finished");
+    return text;
+  }
+  logger.debug({ provider, model: modelName, responseType: "object" }, "completion() finished");
+  return response;
+}
+
+// src/router.ts
+import fs from "fs";
+import path from "path";
+import { randomUUID } from "crypto";
+function resolveEnvPlaceholders(input) {
+  return input.replace(/\$\{([A-Z0-9_]+)\}/gi, (_match, name) => {
+    return process.env[name] ?? "";
+  });
+}
+function parseConfigFile(filePath) {
+  const resolvedPath = path.resolve(process.cwd(), filePath);
+  const ext = path.extname(resolvedPath).toLowerCase();
+  if (ext === ".json") {
+    const content = fs.readFileSync(resolvedPath, "utf8");
+    const interpolated = resolveEnvPlaceholders(content);
+    return JSON.parse(interpolated);
+  }
+  if (ext === ".js" || ext === ".cjs") {
+    const loaded = __require(resolvedPath);
+    return loaded?.default ?? loaded;
+  }
+  throw new Error(`Unsupported router config file extension: ${ext}`);
+}
+function validateModelFormat(model, routeName) {
+  if (!model || model.indexOf("/") === -1) {
+    const suffix = routeName ? ` in route ${routeName}` : "";
+    throw new Error(`Invalid model format${suffix}: expected provider/model_name`);
+  }
+}
+function validateConfig(config) {
+  const routing = config.routing ?? "default";
+  if (!["random", "sequential", "default"].includes(routing)) {
+    throw new Error(`Invalid routing strategy: ${routing}`);
+  }
+  if (!Array.isArray(config.model_list) || config.model_list.length === 0) {
+    throw new Error("model_list must contain at least one route");
+  }
+  config.model_list.forEach((entry) => {
+    if (!entry.model_name) {
+      throw new Error("Each route must include model_name");
+    }
+    if (!entry.llm_params || !entry.llm_params.model) {
+      throw new Error(`Each route must include llm_params.model (route: ${entry.model_name})`);
+    }
+    validateModelFormat(entry.llm_params.model, entry.model_name);
+  });
+  if (config.guardrails && !Array.isArray(config.guardrails)) {
+    throw new Error("guardrails must be an array when provided");
+  }
+  if (Array.isArray(config.guardrails)) {
+    const names = /* @__PURE__ */ new Set();
+    config.guardrails.forEach((guardrail, index) => {
+      if (!guardrail || typeof guardrail !== "object") {
+        throw new Error(`Invalid guardrail at index ${index}`);
+      }
+      if (!guardrail.name || typeof guardrail.name !== "string") {
+        throw new Error(`Each guardrail must include a non-empty name (index: ${index})`);
+      }
+      if (names.has(guardrail.name)) {
+        throw new Error(`Duplicate guardrail name: ${guardrail.name}`);
+      }
+      names.add(guardrail.name);
+      if (guardrail.mode !== "pre_call" && guardrail.mode !== "post_call") {
+        throw new Error(`Invalid guardrail mode for ${guardrail.name}: ${guardrail.mode}`);
+      }
+      const codeType = typeof guardrail.code;
+      if (codeType !== "string" && codeType !== "function") {
+        throw new Error(`Guardrail ${guardrail.name} must provide code as a string or function`);
+      }
+      if (guardrail.timeout_ms !== void 0) {
+        if (!Number.isFinite(guardrail.timeout_ms) || guardrail.timeout_ms <= 0) {
+          throw new Error(`Guardrail ${guardrail.name} has invalid timeout_ms: expected a positive number`);
+        }
+      }
+    });
+  }
+  return {
+    ...config,
+    routing
+  };
+}
+function compileGuardrail(guardrail) {
+  const timeoutMs = guardrail.timeout_ms;
+  if (typeof guardrail.code === "function") {
+    return {
+      name: guardrail.name,
+      mode: guardrail.mode,
+      timeoutMs,
+      handler: guardrail.code
+    };
+  }
+  try {
+    const fn = new Function(`return (${guardrail.code});`)();
+    if (typeof fn !== "function") {
+      throw new Error("compiled value is not a function");
+    }
+    return {
+      name: guardrail.name,
+      mode: guardrail.mode,
+      timeoutMs,
+      handler: fn
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`GuardrailCompileError [${guardrail.name}] (${guardrail.mode}): ${message}`);
+  }
+}
+function createProcessId() {
+  try {
+    return randomUUID();
+  } catch (_error) {
+    return `${Date.now()}-${Math.floor(Math.random() * 1e5)}`;
+  }
+}
+async function runGuardrail(guardrail, processId, payload) {
+  const execute = Promise.resolve().then(() => guardrail.handler(processId, payload));
+  try {
+    if (!guardrail.timeoutMs) {
+      return await execute;
+    }
+    const timeout = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`GuardrailTimeoutError [${guardrail.name}] (${guardrail.mode}): exceeded ${guardrail.timeoutMs}ms`));
+      }, guardrail.timeoutMs);
+    });
+    return await Promise.race([execute, timeout]);
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("GuardrailTimeoutError")) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`GuardrailRuntimeError [${guardrail.name}] (${guardrail.mode}): ${message}`);
+  }
+}
+function validatePreCallOutput(output, guardrailName) {
+  if (!output || typeof output !== "object") {
+    throw new Error(`GuardrailValidationError [${guardrailName}] (pre_call): expected object output`);
+  }
+  if (typeof output.model !== "string" || !output.model) {
+    throw new Error(`GuardrailValidationError [${guardrailName}] (pre_call): expected non-empty model`);
+  }
+  if (!Array.isArray(output.messages)) {
+    throw new Error(`GuardrailValidationError [${guardrailName}] (pre_call): expected messages array`);
+  }
+}
+function router(configOrPath) {
+  const rawConfig = typeof configOrPath === "string" ? parseConfigFile(configOrPath) : configOrPath;
+  const config = validateConfig(rawConfig);
+  const compiledGuardrails = (config.guardrails ?? []).filter((guardrail) => guardrail.enabled !== false).map(compileGuardrail);
+  const preCallGuardrails = compiledGuardrails.filter((guardrail) => guardrail.mode === "pre_call");
+  const postCallGuardrails = compiledGuardrails.filter((guardrail) => guardrail.mode === "post_call");
+  let sequentialIndex = 0;
+  const pickRoute = () => {
+    if (config.routing === "sequential") {
+      const index = sequentialIndex % config.model_list.length;
+      sequentialIndex += 1;
+      return config.model_list[index];
+    }
+    const randomIndex = Math.floor(Math.random() * config.model_list.length);
+    return config.model_list[randomIndex];
+  };
+  return {
+    async completion(options) {
+      const processId = createProcessId();
+      const route = pickRoute();
+      const params = route.llm_params;
+      const merged = {
+        ...options,
+        ...params,
+        messages: options.messages,
+        model: options.model || params.model,
+        apiKey: options.apiKey || params.api_key || params.apiKey,
+        baseUrl: options.baseUrl || params.api_base || params.baseUrl
+      };
+      let preCallPayload = {
+        model: merged.model,
+        messages: merged.messages,
+        tools: merged.tools,
+        metadata: {
+          route_name: route.model_name,
+          routing: config.routing
+        }
+      };
+      for (const guardrail of preCallGuardrails) {
+        const output = await runGuardrail(guardrail, processId, preCallPayload);
+        validatePreCallOutput(output, guardrail.name);
+        preCallPayload = output;
+      }
+      merged.model = preCallPayload.model;
+      merged.messages = preCallPayload.messages;
+      merged.tools = preCallPayload.tools;
+      validateModelFormat(merged.model, route.model_name);
+      const response = await completion(merged);
+      let postCallPayload = response;
+      for (const guardrail of postCallGuardrails) {
+        postCallPayload = await runGuardrail(guardrail, processId, postCallPayload);
+      }
+      return postCallPayload;
+    }
+  };
+}
+
+// src/memory.ts
+var memory_exports = {};
+__export(memory_exports, {
+  fileMemory: () => fileMemory,
+  inMemory: () => inMemory
+});
+import * as fs2 from "fs/promises";
+function createMemoryView(store) {
+  const getThreadMessages = (resourceId, threadId) => {
+    return (store.get(resourceId) || []).filter((message) => message.threadId === threadId);
+  };
+  const projectMessages = (messages, limit) => {
+    const visibleMessages = limit === void 0 ? messages : messages.slice(-limit);
+    return visibleMessages.map(({ role, content }) => ({ role, content }));
+  };
+  return {
+    async save(resourceId, threadId, role, content) {
+      const messages = store.get(resourceId) ?? [];
+      messages.push({ role, content, threadId });
+      store.set(resourceId, messages);
+    },
+    async list(resourceId, threadId, limit) {
+      return projectMessages(getThreadMessages(resourceId, threadId), limit);
+    },
+    async search(resourceId, query) {
+      const normalizedQuery = query.toLowerCase();
+      const messages = store.get(resourceId) || [];
+      return messages.filter((message) => message.content.toLowerCase().includes(normalizedQuery)).map(({ content, threadId }) => ({ content, threadId }));
+    },
+    async clear(resourceId, threadId) {
+      if (!store.has(resourceId)) {
+        return;
+      }
+      const remainingMessages = (store.get(resourceId) || []).filter((message) => message.threadId !== threadId);
+      store.set(resourceId, remainingMessages);
+    }
+  };
+}
+function inMemory() {
+  return createMemoryView(/* @__PURE__ */ new Map());
+}
+function fileMemory(config) {
+  const { path: path2 } = config;
+  async function readData() {
+    try {
+      const data = await fs2.readFile(path2, "utf-8");
+      return JSON.parse(data);
+    } catch (e) {
+      if (e?.code === "ENOENT") {
+        return {};
+      }
+      throw e;
+    }
+  }
+  async function writeData(data) {
+    await fs2.writeFile(path2, JSON.stringify(data, null, 2), "utf-8");
+  }
+  return {
+    async save(resourceId, threadId, role, content) {
+      const data = await readData();
+      const messages = data[resourceId] ?? [];
+      messages.push({ role, content, threadId });
+      data[resourceId] = messages;
+      await writeData(data);
+    },
+    async list(resourceId, threadId, limit) {
+      const data = await readData();
+      const messages = (data[resourceId] || []).filter((message) => message.threadId === threadId);
+      const visibleMessages = limit === void 0 ? messages : messages.slice(-limit);
+      return visibleMessages.map(({ role, content }) => ({ role, content }));
+    },
+    async search(resourceId, query) {
+      const data = await readData();
+      const normalizedQuery = query.toLowerCase();
+      const messages = data[resourceId] || [];
+      return messages.filter((message) => message.content.toLowerCase().includes(normalizedQuery)).map(({ content, threadId }) => ({ content, threadId }));
+    },
+    async clear(resourceId, threadId) {
+      const data = await readData();
+      if (!data[resourceId]) {
+        return;
+      }
+      data[resourceId] = data[resourceId].filter((message) => message.threadId !== threadId);
+      await writeData(data);
+    }
+  };
+}
+
+// src/agent.ts
+var Agent = class {
+  constructor(config) {
+    this.config = config;
+    if (!config.instruction) throw new Error("MissingInstructionError: instruction field is required.");
+    if (!config.route) throw new Error("MissingRouteError: route is required.");
+  }
+  config;
+  async generate(request) {
+    let userPrompt;
+    let memoryReq;
+    let userMessageContent;
+    let userImages = [];
+    if (typeof request === "string") {
+      userPrompt = request;
+      userMessageContent = userPrompt;
+    } else {
+      if (!request.userPrompt) throw new Error("MissingUserPromptError: Object form of generate() requires userPrompt.");
+      userPrompt = request.userPrompt;
+      memoryReq = request.memory;
+      let textPrompt = userPrompt;
+      if (request.attachments && request.attachments.length > 0) {
+        const { markitdown } = await import("any-markdown");
+        const results = await markitdown(request.attachments);
+        const textAttachments = [];
+        const resultsArray = Array.isArray(results) ? results : [results];
+        for (const result of resultsArray) {
+          if ("error" in result && result.error) {
+            logger.warn(
+              { code: result.code, message: result.message },
+              "Failed to process attachment"
+            );
+          } else if (result.type === "image") {
+            let base64Data = result.base64;
+            if (base64Data.startsWith("data:")) {
+              base64Data = base64Data.split(",")[1];
+            }
+            userImages.push(base64Data);
+          } else {
+            textAttachments.push(result.markdown);
+          }
+        }
+        if (textAttachments.length > 0) {
+          for (const attachmentText of textAttachments) {
+            textPrompt += `
+
+=== Attachment Start ===
+${attachmentText}
+=== Attachment End ===`;
+          }
+        }
+      }
+      userMessageContent = textPrompt;
+    }
+    const messages = [
+      { role: "system", content: this.config.instruction }
+    ];
+    if (this.config.memory && memoryReq) {
+      const useSession = memoryReq.session ?? this.config.session;
+      const useRelevance = memoryReq.relevance ?? this.config.relevance;
+      if (useSession) {
+        const history = await this.config.memory.list(memoryReq.resourceId, memoryReq.threadId);
+        for (const msg of history) {
+          messages.push({ role: msg.role, content: msg.content });
+        }
+      }
+      if (useRelevance) {
+        const relevant = await this.config.memory.search(memoryReq.resourceId, userPrompt);
+        if (relevant.length > 0) {
+          messages.push({ role: "system", content: `Relevant past messages:
+${relevant.map((r) => r.content).join("\n")}` });
+        }
+      }
+    }
+    const userMessage = { role: "user", content: userMessageContent };
+    if (userImages.length > 0) {
+      userMessage.images = userImages;
+    }
+    messages.push(userMessage);
+    const tools = this.config.tools;
+    const toolMap = /* @__PURE__ */ new Map();
+    if (tools) {
+      for (const t of tools) {
+        toolMap.set(t.name, t);
+      }
+    }
+    const toolCallsLog = [];
+    let finalContent = "";
+    while (true) {
+      const response = await this.config.route.completion({ messages, tools });
+      const toolCalls = response.choices?.[0]?.message?.tool_calls || response.message?.tool_calls || response.tool_calls;
+      if (toolCalls && toolCalls.length > 0) {
+        messages.push({
+          role: "assistant",
+          content: response.choices?.[0]?.message?.content || response.message?.content || response.content || "",
+          tool_calls: toolCalls
+        });
+        for (const tc of toolCalls) {
+          const tool = toolMap.get(tc.function.name);
+          let resultStr = "";
+          if (tool) {
+            try {
+              const params = typeof tc.function.arguments === "string" ? JSON.parse(tc.function.arguments) : tc.function.arguments;
+              resultStr = await tool.execute(params);
+              toolCallsLog.push({
+                name: tc.function.name,
+                parameters: params,
+                result: resultStr
+              });
+            } catch (e) {
+              console.error(`[Agent] Error executing tool ${tc.function.name}:`, e);
+              resultStr = `ToolExecutionError: ${e.message}`;
+            }
+          } else {
+            console.error(`[Agent] Tool not found: ${tc.function.name}`);
+            resultStr = `ToolExecutionError: Tool ${tc.function.name} not found`;
+          }
+          messages.push({
+            role: "tool",
+            content: resultStr,
+            tool_call_id: tc.id
+          });
+        }
+      } else {
+        finalContent = response.choices?.[0]?.message?.content || response.message?.content || response.content || "";
+        break;
+      }
+    }
+    if (this.config.memory && memoryReq) {
+      await this.config.memory.save(memoryReq.resourceId, memoryReq.threadId, "user", userPrompt);
+      await this.config.memory.save(memoryReq.resourceId, memoryReq.threadId, "assistant", finalContent);
+    }
+    if (toolCallsLog.length > 0) {
+      return {
+        content: finalContent,
+        toolCalls: toolCallsLog
+      };
+    }
+    return finalContent;
+  }
+};
+function createAgent(config) {
+  return new Agent(config);
+}
+export {
+  Agent,
+  memory_exports as Memory,
+  completion,
+  createAgent,
+  fileMemory,
+  inMemory,
+  router,
+  verbose
+};