vecbox 0.1.0

package/dist/index.cjs

@@ -0,0 +1,917 @@
+"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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __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);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  EmbeddingFactory: () => EmbeddingFactory,
+  EmbeddingProvider: () => EmbeddingProvider,
+  LIB_INFO: () => LIB_INFO,
+  VERSION: () => VERSION,
+  autoEmbed: () => autoEmbed,
+  createProvider: () => createProvider,
+  embed: () => embed,
+  getSupportedProviders: () => getSupportedProviders,
+  getVersion: () => getVersion
+});
+module.exports = __toCommonJS(index_exports);
+
+// main.ts
+var dotenv = __toESM(require("dotenv"), 1);
+
+// src/providers/openai.ts
+var import_openai = __toESM(require("openai"), 1);
+
+// src/providers/base/EmbeddingProvider.ts
+var EmbeddingProvider = class {
+  constructor(config2) {
+    __publicField(this, "config");
+    this.config = config2;
+  }
+  getModel() {
+    return this.config.model || "default";
+  }
+  async readInput(input) {
+    if (input.text) {
+      return input.text;
+    }
+    if (input.filePath) {
+      const fs = await import("fs/promises");
+      return await fs.readFile(input.filePath, "utf-8");
+    }
+    throw new Error("Either text or filePath must be provided");
+  }
+};
+
+// src/util/logger.ts
+var _Logger = class _Logger {
+  constructor(moduleName = "embedbox", level = 1 /* INFO */) {
+    __publicField(this, "currentLevel");
+    __publicField(this, "moduleName");
+    this.moduleName = moduleName;
+    this.currentLevel = level;
+  }
+  static getInstance(moduleName, level) {
+    if (!_Logger.instance) {
+      _Logger.instance = new _Logger(moduleName || "embedbox", level);
+    }
+    return _Logger.instance;
+  }
+  setLevel(level) {
+    this.currentLevel = level;
+  }
+  getLevel() {
+    return this.currentLevel;
+  }
+  formatMessage(level, message) {
+    const levelName = _Logger.LEVEL_NAMES[level];
+    const color = _Logger.COLORS[levelName];
+    const reset = _Logger.COLORS.RESET;
+    return `${color}[${levelName}(${this.moduleName})]${reset} ${message}
+
+`;
+  }
+  log(level, message) {
+    if (level < this.currentLevel) {
+      return;
+    }
+    const formattedMessage = this.formatMessage(level, message);
+    process.stdout.write(formattedMessage);
+  }
+  debug(message) {
+    this.log(0 /* DEBUG */, message);
+  }
+  info(message) {
+    this.log(1 /* INFO */, message);
+  }
+  warn(message) {
+    this.log(2 /* WARN */, message);
+  }
+  error(message) {
+    this.log(3 /* ERROR */, message);
+  }
+  // Static methods for quick access
+  static debug(message, moduleName) {
+    const logger9 = new _Logger(moduleName || "embedbox");
+    logger9.debug(message);
+  }
+  static info(message, moduleName) {
+    const logger9 = new _Logger(moduleName || "embedbox");
+    logger9.info(message);
+  }
+  static warn(message, moduleName) {
+    const logger9 = new _Logger(moduleName || "embedbox");
+    logger9.warn(message);
+  }
+  static error(message, moduleName) {
+    const logger9 = new _Logger(moduleName || "embedbox");
+    logger9.error(message);
+  }
+  // Method to create a logger instance for a specific module
+  static createModuleLogger(moduleName, level) {
+    return new _Logger(`embedbox:${moduleName}`, level);
+  }
+};
+__publicField(_Logger, "instance");
+// ANSI color codes - simplified for better readability
+__publicField(_Logger, "COLORS", {
+  RESET: "\x1B[0m",
+  DEBUG: "\x1B[36m",
+  // Cyan
+  INFO: "\x1B[32m",
+  // Green  
+  WARN: "\x1B[33m",
+  // Yellow
+  ERROR: "\x1B[31m"
+  // Red
+});
+__publicField(_Logger, "LEVEL_NAMES", {
+  [0 /* DEBUG */]: "DEBUG",
+  [1 /* INFO */]: "INFO",
+  [2 /* WARN */]: "WARN",
+  [3 /* ERROR */]: "ERROR"
+});
+var Logger = _Logger;
+var logger = Logger.getInstance();
+
+// src/providers/openai.ts
+var logger2 = Logger.createModuleLogger("openai");
+var OpenAIProvider = class extends EmbeddingProvider {
+  constructor(config2) {
+    super(config2);
+    __publicField(this, "client");
+    if (!config2.apiKey) {
+      throw new Error("OpenAI API key is required");
+    }
+    this.client = new import_openai.default({
+      apiKey: config2.apiKey,
+      baseURL: config2.baseUrl,
+      timeout: config2.timeout || 3e4
+    });
+    logger2.info("OpenAI provider initialized");
+  }
+  async embed(input) {
+    try {
+      const text = await this.readInput(input);
+      logger2.debug(`Embedding text with model: ${this.getModel()}`);
+      const response = await this.client.embeddings.create({
+        model: this.getModel(),
+        input: text
+      });
+      const embedding = response.data[0];
+      if (!embedding) {
+        throw new Error("No embedding returned from OpenAI API");
+      }
+      return {
+        embedding: embedding.embedding || [],
+        dimensions: embedding.embedding?.length || 0,
+        model: response.model,
+        provider: "openai",
+        usage: response.usage ? {
+          promptTokens: response.usage.prompt_tokens,
+          totalTokens: response.usage.total_tokens
+        } : void 0
+      };
+    } catch (error) {
+      logger2.error(`OpenAI embedding failed: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
+    }
+  }
+  async embedBatch(inputs) {
+    try {
+      const texts = await Promise.all(inputs.map((input) => this.readInput(input)));
+      logger2.debug(`Batch embedding ${texts.length} texts with model: ${this.getModel()}`);
+      const response = await this.client.embeddings.create({
+        model: this.getModel(),
+        input: texts
+      });
+      const embeddings = response.data.map((item) => item.embedding);
+      return {
+        embeddings,
+        dimensions: embeddings[0]?.length || 0,
+        model: response.model,
+        provider: "openai",
+        usage: response.usage ? {
+          promptTokens: response.usage.prompt_tokens,
+          totalTokens: response.usage.total_tokens
+        } : void 0
+      };
+    } catch (error) {
+      logger2.error(`OpenAI batch embedding failed: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
+    }
+  }
+  getDimensions() {
+    const model = this.getModel();
+    if (model.includes("text-embedding-3-large")) return 3072;
+    if (model.includes("text-embedding-3-small")) return 1536;
+    if (model.includes("text-embedding-ada-002")) return 1536;
+    return 1536;
+  }
+  getProviderName() {
+    return "OpenAI";
+  }
+  async isReady() {
+    try {
+      await this.client.models.list();
+      return true;
+    } catch (error) {
+      logger2.error(`OpenAI readiness check failed: ${error instanceof Error ? error.message : String(error)}`);
+      return false;
+    }
+  }
+};
+
+// src/providers/gemini.ts
+var import_generative_ai = require("@google/generative-ai");
+var logger3 = Logger.createModuleLogger("gemini");
+var GeminiProvider = class extends EmbeddingProvider {
+  constructor(config2) {
+    super(config2);
+    __publicField(this, "client");
+    if (!config2.apiKey) {
+      throw new Error("Google API key is required");
+    }
+    this.client = new import_generative_ai.GoogleGenerativeAI(config2.apiKey);
+    logger3.info("Gemini provider initialized");
+  }
+  async embed(input) {
+    try {
+      const text = await this.readInput(input);
+      logger3.debug(`Embedding text with model: ${this.getModel()}`);
+      const model = this.client.getGenerativeModel({
+        model: this.getModel()
+      });
+      const result = await model.embedContent(text);
+      const embedding = result.embedding;
+      return {
+        embedding: embedding.values,
+        dimensions: embedding.values.length,
+        model: this.getModel(),
+        provider: "gemini"
+      };
+    } catch (error) {
+      logger3.error(`Gemini embedding failed: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
+    }
+  }
+  async embedBatch(inputs) {
+    try {
+      const texts = await Promise.all(inputs.map((input) => this.readInput(input)));
+      logger3.debug(`Batch embedding ${texts.length} texts with model: ${this.getModel()}`);
+      const model = this.client.getGenerativeModel({
+        model: this.getModel()
+      });
+      const results = await Promise.all(
+        texts.map((text) => model.embedContent(text))
+      );
+      const embeddings = results.map((result) => result.embedding.values);
+      return {
+        embeddings,
+        dimensions: embeddings[0]?.length || 0,
+        model: this.getModel(),
+        provider: "gemini"
+      };
+    } catch (error) {
+      logger3.error(`Gemini batch embedding failed: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
+    }
+  }
+  getDimensions() {
+    const model = this.getModel();
+    if (model.includes("gemini-embedding-001")) return 768;
+    if (model.includes("text-embedding-004")) return 768;
+    if (model.includes("embedding-001")) return 768;
+    if (model.includes("multimodalembedding")) return 768;
+    return 768;
+  }
+  getProviderName() {
+    return "Google Gemini";
+  }
+  getModel() {
+    return this.config.model || "gemini-embedding-001";
+  }
+  async isReady() {
+    try {
+      const model = this.client.getGenerativeModel({
+        model: this.getModel()
+      });
+      await model.embedContent("test");
+      return true;
+    } catch (error) {
+      logger3.error(`Gemini readiness check failed: ${error instanceof Error ? error.message : String(error)}`);
+      return false;
+    }
+  }
+};
+
+// src/providers/claude.ts
+var import_sdk = __toESM(require("@anthropic-ai/sdk"), 1);
+var logger4 = Logger.createModuleLogger("claude");
+var ClaudeProvider = class extends EmbeddingProvider {
+  constructor(config2) {
+    super(config2);
+    __publicField(this, "client");
+    if (!config2.apiKey) {
+      throw new Error("Anthropic API key is required");
+    }
+    this.client = new import_sdk.default({
+      apiKey: config2.apiKey,
+      baseURL: config2.baseUrl,
+      timeout: config2.timeout || 3e4
+    });
+    logger4.info("Claude provider initialized");
+  }
+  async embed() {
+    try {
+      logger4.debug(`Embedding text with model: ${this.getModel()}`);
+      throw new Error("Claude embeddings API not yet available. Please use another provider.");
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error instanceof Error ? error.message : String(error) : "Unknown error";
+      logger4.error(`Claude embedding failed: ${errorMessage}`);
+      throw error;
+    }
+  }
+  async embedBatch() {
+    try {
+      throw new Error("Claude embeddings API not yet available. Please use another provider.");
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error instanceof Error ? error.message : String(error) : "Unknown error";
+      logger4.error(`Claude batch embedding failed: ${errorMessage}`);
+      throw error;
+    }
+  }
+  getDimensions() {
+    return 0;
+  }
+  getProviderName() {
+    return "Anthropic Claude";
+  }
+  async isReady() {
+    try {
+      await this.client.messages.create({
+        model: "claude-3-haiku-20240307",
+        max_tokens: 10,
+        messages: [{ role: "user", content: "test" }]
+      });
+      return true;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error instanceof Error ? error.message : String(error) : "Unknown error";
+      logger4.error(`Claude readiness check failed: ${errorMessage}`);
+      return false;
+    }
+  }
+};
+
+// src/providers/mistral.ts
+var import_mistralai = require("@mistralai/mistralai");
+var logger5 = Logger.createModuleLogger("mistral");
+var MistralProvider = class extends EmbeddingProvider {
+  constructor(config2) {
+    super(config2);
+    __publicField(this, "client");
+    if (!config2.apiKey) {
+      throw new Error("Mistral API key is required");
+    }
+    this.client = new import_mistralai.Mistral({
+      apiKey: config2.apiKey,
+      serverURL: config2.baseUrl,
+      timeoutMs: config2.timeout || 3e4
+    });
+    logger5.info("Mistral provider initialized");
+  }
+  async embed(input) {
+    try {
+      const text = await this.readInput(input);
+      logger5.debug(`Embedding text with model: ${this.getModel()}`);
+      const response = await this.client.embeddings.create({
+        model: this.getModel(),
+        inputs: [text]
+      });
+      const embedding = response.data[0];
+      if (!embedding) {
+        throw new Error("No embedding returned from Mistral API");
+      }
+      return {
+        embedding: embedding.embedding || [],
+        dimensions: embedding.embedding?.length || 0,
+        model: response.model,
+        provider: "mistral",
+        usage: response.usage?.promptTokens && response.usage?.totalTokens ? {
+          promptTokens: response.usage.promptTokens,
+          totalTokens: response.usage.totalTokens
+        } : void 0
+      };
+    } catch (error) {
+      logger5.error(`Mistral embedding failed: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
+    }
+  }
+  async embedBatch(inputs) {
+    try {
+      const texts = await Promise.all(inputs.map((input) => this.readInput(input)));
+      logger5.debug(`Batch embedding ${texts.length} texts with model: ${this.getModel()}`);
+      const response = await this.client.embeddings.create({
+        model: this.getModel(),
+        inputs: texts
+      });
+      const embeddings = response.data.map((item) => {
+        if (!item.embedding) throw new Error("No embedding returned from Mistral API");
+        return item.embedding;
+      });
+      return {
+        embeddings,
+        dimensions: embeddings[0]?.length || 0,
+        model: response.model,
+        provider: "mistral",
+        usage: response.usage?.promptTokens && response.usage?.totalTokens ? {
+          promptTokens: response.usage.promptTokens,
+          totalTokens: response.usage.totalTokens
+        } : void 0
+      };
+    } catch (error) {
+      logger5.error(`Mistral batch embedding failed: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
+    }
+  }
+  getDimensions() {
+    const model = this.getModel();
+    if (model.includes("mistral-embed")) return 1024;
+    return 1024;
+  }
+  getProviderName() {
+    return "Mistral AI";
+  }
+  async isReady() {
+    try {
+      const response = await this.client.embeddings.create({
+        model: this.getModel(),
+        inputs: ["test"]
+      });
+      return response.data.length > 0;
+    } catch (error) {
+      logger5.error(`Mistral readiness check failed: ${error instanceof Error ? error.message : String(error)}`);
+      return false;
+    }
+  }
+};
+
+// src/providers/deepseek.ts
+var import_deepseek = require("deepseek");
+var logger6 = Logger.createModuleLogger("deepseek");
+var DeepSeekProvider = class extends EmbeddingProvider {
+  constructor(config2) {
+    super(config2);
+    __publicField(this, "client");
+    if (!config2.apiKey) {
+      throw new Error("DeepSeek API key is required");
+    }
+    const clientOptions = {
+      apiKey: config2.apiKey,
+      timeout: config2.timeout || 3e4
+    };
+    if (config2.baseUrl) {
+      clientOptions.baseURL = config2.baseUrl;
+    }
+    this.client = new import_deepseek.DeepSeek(clientOptions);
+    logger6.info("DeepSeek provider initialized");
+  }
+  async embed(input) {
+    try {
+      const text = await this.readInput(input);
+      logger6.debug(`Embedding text with model: ${this.getModel()}`);
+      const response = await this.client.embeddings.create({
+        model: this.getModel(),
+        input: text
+      });
+      const embedding = response.data[0];
+      if (!embedding) {
+        throw new Error("No embedding returned from DeepSeek API");
+      }
+      return {
+        embedding: embedding.embedding || [],
+        dimensions: embedding.embedding?.length || 0,
+        model: embedding.model || this.getModel(),
+        provider: "deepseek",
+        usage: response.usage ? {
+          promptTokens: response.usage.prompt_tokens,
+          totalTokens: response.usage.total_tokens
+        } : void 0
+      };
+    } catch (error) {
+      logger6.error(`DeepSeek embedding failed: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
+    }
+  }
+  async embedBatch(inputs) {
+    try {
+      const texts = await Promise.all(inputs.map((input) => this.readInput(input)));
+      logger6.debug(`Batch embedding ${texts.length} texts with model: ${this.getModel()}`);
+      const response = await this.client.embeddings.create({
+        model: this.getModel(),
+        input: texts
+      });
+      const embeddings = response.data.map((item) => item.embedding);
+      return {
+        embeddings,
+        dimensions: embeddings[0]?.length || 0,
+        model: response.model,
+        provider: "deepseek",
+        usage: response.usage ? {
+          promptTokens: response.usage.prompt_tokens,
+          totalTokens: response.usage.total_tokens
+        } : void 0
+      };
+    } catch (error) {
+      logger6.error(`DeepSeek batch embedding failed: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
+    }
+  }
+  getDimensions() {
+    const model = this.getModel();
+    if (model.includes("deepseek-chat")) return 4096;
+    return 4096;
+  }
+  getProviderName() {
+    return "DeepSeek";
+  }
+  async isReady() {
+    try {
+      await this.client.embeddings.create({
+        model: this.getModel(),
+        input: "test"
+      });
+      return true;
+    } catch (error) {
+      logger6.error(`DeepSeek readiness check failed: ${error instanceof Error ? error.message : String(error)}`);
+      return false;
+    }
+  }
+};
+
+// src/providers/llamacpp.ts
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var http = __toESM(require("http"), 1);
+var LlamaCppProvider = class extends EmbeddingProvider {
+  constructor(config2) {
+    super({ ...config2, provider: "llamacpp" });
+    __publicField(this, "llamaPath");
+    __publicField(this, "modelPath");
+    this.modelPath = config2.model || "nomic-embed-text-v1.5.Q4_K_M.gguf";
+    this.llamaPath = config2.llamaPath || "./llama.cpp/build/bin/llama-embedding";
+    logger.info(`Llama.cpp provider initialized with model: ${this.modelPath}`);
+  }
+  // Public API methods
+  getProviderName() {
+    return "Llama.cpp";
+  }
+  getDimensions() {
+    const model = this.getModel();
+    if (model.includes("nomic-embed-text-v1.5")) return 768;
+    if (model.includes("nomic-embed-text-v1")) return 768;
+    if (model.includes("all-MiniLM-L6-v2")) return 384;
+    if (model.includes("bge-base")) return 768;
+    if (model.includes("bert-base")) return 768;
+    return 768;
+  }
+  async isReady() {
+    try {
+      await (0, import_promises.access)(this.llamaPath, import_promises.constants.F_OK);
+      await (0, import_promises.access)(this.llamaPath, import_promises.constants.X_OK);
+      const modelPath = await this.getModelPath();
+      await (0, import_promises.access)(modelPath, import_promises.constants.F_OK);
+      logger.debug("Llama.cpp provider is ready");
+      return true;
+    } catch (error) {
+      logger.error(`Llama.cpp readiness check failed: ${error instanceof Error ? error.message : String(error)}`);
+      return false;
+    }
+  }
+  async embed(input) {
+    try {
+      logger.debug(`Embedding text with llama.cpp: ${this.getModel()}`);
+      const text = await this.readInput(input);
+      if (!text.trim()) {
+        throw new Error("Text input cannot be empty");
+      }
+      const requestBody = {
+        input: text,
+        model: await this.getModelPath(),
+        pooling: "mean",
+        normalize: 2
+      };
+      const result = await this.executeLlamaEmbedding([JSON.stringify(requestBody)]);
+      const embedding = this.parseRawOutput(result.stdout);
+      return {
+        embedding,
+        dimensions: embedding.length,
+        model: this.getModel(),
+        provider: "llamacpp"
+      };
+    } catch (error) {
+      logger.error(`Llama.cpp embedding failed: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
+    }
+  }
+  async embedBatch(inputs) {
+    try {
+      logger.debug(`Batch embedding ${inputs.length} texts with llama.cpp`);
+      const texts = [];
+      for (const input of inputs) {
+        const text = await this.readInput(input);
+        if (text.trim()) {
+          texts.push(text);
+        }
+      }
+      if (texts.length === 0) {
+        throw new Error("No valid texts to embed");
+      }
+      const modelPath = await this.getModelPath();
+      const requests = inputs.map((input) => ({
+        input: input.text || "",
+        model: modelPath,
+        pooling: "mean",
+        normalize: 2
+      }));
+      const embeddings = [];
+      for (const request2 of requests) {
+        const result = await this.executeLlamaEmbedding([JSON.stringify(request2)]);
+        const embedding = this.parseRawOutput(result.stdout);
+        embeddings.push(embedding);
+      }
+      return {
+        embeddings,
+        dimensions: embeddings[0]?.length || 0,
+        model: this.getModel(),
+        provider: "llamacpp"
+      };
+    } catch (error) {
+      logger.error(`Llama.cpp batch embedding failed: ${error instanceof Error ? error.message : String(error)}`);
+      throw error;
+    }
+  }
+  // Protected methods
+  getModel() {
+    return this.modelPath;
+  }
+  // Private helper methods
+  async getModelPath() {
+    const possiblePaths = [
+      this.modelPath,
+      // As provided
+      (0, import_path.join)("./llama.cpp/models", this.modelPath),
+      // In llama.cpp/models
+      (0, import_path.join)("./llama.cpp", this.modelPath),
+      // In llama.cpp root
+      this.modelPath
+      // Fallback
+    ];
+    for (const path of possiblePaths) {
+      try {
+        await (0, import_promises.access)(path, import_promises.constants.F_OK);
+        return (0, import_path.resolve)(path);
+      } catch {
+        continue;
+      }
+    }
+    throw new Error(`Model file not found: ${this.modelPath}`);
+  }
+  async executeLlamaEmbedding(args) {
+    return new Promise((resolve2, reject) => {
+      const port = 8080;
+      let requestBody;
+      try {
+        requestBody = JSON.parse(args[0] || "{}");
+      } catch {
+        reject(new Error("Invalid request body for HTTP API"));
+        return;
+      }
+      const postData = JSON.stringify(requestBody);
+      const options = {
+        hostname: "localhost",
+        port,
+        path: "/embedding",
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(postData)
+        }
+      };
+      const req = http.request(options, (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          if (res.statusCode === 200) {
+            resolve2({ stdout: data, stderr: "" });
+          } else {
+            reject(new Error(`HTTP ${res.statusCode}: ${data}`));
+          }
+        });
+      });
+      req.on("error", (error) => {
+        reject(new Error(`Failed to connect to llama.cpp server: ${error instanceof Error ? error.message : String(error)}`));
+      });
+      req.write(postData);
+      req.end();
+    });
+  }
+  parseRawOutput(output) {
+    try {
+      const response = JSON.parse(output);
+      logger.debug(`PARSE DEBUG: Response type: ${typeof response}`);
+      logger.debug(`PARSE DEBUG: Is Array: ${Array.isArray(response)}`);
+      if (Array.isArray(response) && response.length > 0) {
+        const first = response[0];
+        if (first && first.embedding && Array.isArray(first.embedding)) {
+          const emb = first.embedding;
+          if (Array.isArray(emb[0])) {
+            const flat = emb[0];
+            logger.debug(`Parsed ${flat.length} dimensions (nested)`);
+            return flat;
+          }
+          logger.debug(`Parsed ${emb.length} dimensions (direct)`);
+          return emb;
+        }
+      }
+      if (response.embedding && Array.isArray(response.embedding)) {
+        const emb = response.embedding;
+        if (Array.isArray(emb[0])) {
+          return emb[0];
+        }
+        return emb;
+      }
+      if (Array.isArray(response) && typeof response[0] === "number") {
+        logger.debug(`Parsed ${response.length} dimensions (flat array)`);
+        return response;
+      }
+      throw new Error(`Unexpected format: ${JSON.stringify(Object.keys(response))}`);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error instanceof Error ? error.message : String(error) : "Unknown error";
+      throw new Error(`Parse failed: ${errorMessage}`, { cause: error });
+    }
+  }
+  parseArrayOutput(output) {
+    const arrayPattern = /\[([^\]]+)\]/g;
+    const matches = [...output.matchAll(arrayPattern)];
+    if (matches.length === 0) {
+      throw new Error("No array embeddings found in output");
+    }
+    const embeddings = matches.map((match) => {
+      const values = match[1]?.split(",").map((v) => v.trim()) || [];
+      return values.map((v) => parseFloat(v)).filter((v) => !isNaN(v));
+    }).filter((embedding) => embedding.length > 0);
+    return embeddings;
+  }
+};
+
+// src/factory/EmbeddingFactory.ts
+var logger7 = Logger.createModuleLogger("factory");
+var EmbeddingFactory = class {
+  static create(config2) {
+    logger7.info(`Creating provider: ${config2.provider}`);
+    const ProviderClass = this.providers.get(config2.provider);
+    if (!ProviderClass) {
+      throw new Error(`Unsupported provider: ${config2.provider}`);
+    }
+    return new ProviderClass(config2);
+  }
+  static getSupportedProviders() {
+    return Array.from(this.providers.keys());
+  }
+};
+__publicField(EmbeddingFactory, "providers", /* @__PURE__ */ new Map([
+  ["openai", OpenAIProvider],
+  ["gemini", GeminiProvider],
+  ["claude", ClaudeProvider],
+  ["mistral", MistralProvider],
+  ["deepseek", DeepSeekProvider],
+  ["llamacpp", LlamaCppProvider]
+  // Local embeddings with llama.cpp
+]));
+
+// main.ts
+dotenv.config();
+var logger8 = Logger.createModuleLogger("main");
+async function embed(config2, input) {
+  try {
+    logger8.info(`Starting embedding with provider: ${config2.provider}`);
+    const provider = EmbeddingFactory.create(config2);
+    const isReady = await provider.isReady();
+    if (!isReady) {
+      throw new Error(`Provider ${config2.provider} is not ready`);
+    }
+    if (Array.isArray(input)) {
+      logger8.debug(`Processing batch of ${input.length} items`);
+      return await provider.embedBatch(input);
+    } else {
+      logger8.debug(`Processing single item`);
+      return await provider.embed(input);
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger8.error(`Embedding failed: ${errorMessage}`);
+    throw error;
+  }
+}
+async function autoEmbed(input) {
+  logger8.info("Auto-detecting best provider...");
+  const providers = [
+    { provider: "llamacpp", model: "nomic-embed-text-v1.5.Q4_K_M.gguf" },
+    // Local & free (llama.cpp)
+    { provider: "openai", model: "text-embedding-3-small", apiKey: process.env.OPENAI_API_KEY || void 0 },
+    { provider: "gemini", model: "gemini-embedding-001", apiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY || void 0 },
+    { provider: "mistral", model: "mistral-embed", apiKey: process.env.MISTRAL_API_KEY || void 0 },
+    { provider: "deepseek", model: "deepseek-chat", apiKey: process.env.DEEPSEEK_API_KEY || void 0 }
+  ];
+  for (const config2 of providers) {
+    try {
+      if (config2.provider === "llamacpp" || config2.apiKey) {
+        logger8.info(`Trying provider: ${config2.provider}`);
+        const cleanConfig = {
+          provider: config2.provider,
+          model: config2.model
+        };
+        if (config2.apiKey) {
+          cleanConfig.apiKey = config2.apiKey;
+        }
+        return await embed(cleanConfig, input);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger8.warn(`Provider ${config2.provider} failed: ${errorMessage}`);
+      continue;
+    }
+  }
+  throw new Error("No available embedding provider found");
+}
+function getSupportedProviders() {
+  return EmbeddingFactory.getSupportedProviders();
+}
+function createProvider(config2) {
+  return EmbeddingFactory.create(config2);
+}
+
+// index.ts
+var VERSION = "1.0.0";
+function getVersion() {
+  return VERSION;
+}
+var LIB_INFO = {
+  name: "embedbox",
+  version: VERSION,
+  description: "A minimal and powerful embedding library",
+  homepage: "https://embedbox.dev",
+  repository: "https://github.com/embedbox/embedbox.git",
+  supportedProviders: [
+    "openai",
+    "gemini",
+    "claude",
+    "mistral",
+    "deepseek",
+    "llamacpp"
+  ]
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EmbeddingFactory,
+  EmbeddingProvider,
+  LIB_INFO,
+  VERSION,
+  autoEmbed,
+  createProvider,
+  embed,
+  getSupportedProviders,
+  getVersion
+});
+//# sourceMappingURL=index.cjs.map