@lov3kaizen/agentsea-embeddings 0.5.1

package/dist/providers/index.js

@@ -0,0 +1,1235 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/providers/index.ts
+var providers_exports = {};
+__export(providers_exports, {
+  BaseProvider: () => BaseProvider,
+  CohereProvider: () => CohereProvider,
+  HuggingFaceProvider: () => HuggingFaceProvider,
+  LocalProvider: () => LocalProvider,
+  OpenAIProvider: () => OpenAIProvider,
+  VoyageProvider: () => VoyageProvider,
+  createCohereProvider: () => createCohereProvider,
+  createHuggingFaceProvider: () => createHuggingFaceProvider,
+  createLocalProvider: () => createLocalProvider,
+  createMockProvider: () => createMockProvider,
+  createOpenAIProvider: () => createOpenAIProvider,
+  createRandomProvider: () => createRandomProvider,
+  createVoyageProvider: () => createVoyageProvider
+});
+module.exports = __toCommonJS(providers_exports);
+
+// src/core/EmbeddingModel.ts
+var EmbeddingModel = class {
+  /**
+   * Get model dimensions
+   */
+  get dimensions() {
+    return this.info.dimensions;
+  }
+  /**
+   * Get max tokens
+   */
+  get maxTokens() {
+    return this.info.maxTokens;
+  }
+  /**
+   * Get max batch size
+   */
+  get maxBatchSize() {
+    return this.info.maxBatchSize;
+  }
+  /**
+   * Get model name
+   */
+  get name() {
+    return this.info.name;
+  }
+  /**
+   * Get provider name
+   */
+  get provider() {
+    return this.info.provider;
+  }
+  /**
+   * Count tokens in text (default implementation)
+   * Subclasses should override for accurate counting
+   */
+  countTokens(text) {
+    return Math.ceil(text.length / 4);
+  }
+  /**
+   * Check if text exceeds max tokens
+   */
+  exceedsMaxTokens(text) {
+    return this.countTokens(text) > this.maxTokens;
+  }
+  /**
+   * Truncate text to max tokens
+   */
+  truncateToMaxTokens(text) {
+    const tokens = this.countTokens(text);
+    if (tokens <= this.maxTokens) {
+      return text;
+    }
+    const ratio = this.maxTokens / tokens;
+    const targetLength = Math.floor(text.length * ratio * 0.95);
+    return text.slice(0, targetLength);
+  }
+  /**
+   * Calculate similarity between two vectors
+   */
+  static cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+      throw new Error(`Vector dimensions mismatch: ${a.length} vs ${b.length}`);
+    }
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+    const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+    if (magnitude === 0) {
+      return 0;
+    }
+    return dotProduct / magnitude;
+  }
+  /**
+   * Calculate Euclidean distance between two vectors
+   */
+  static euclideanDistance(a, b) {
+    if (a.length !== b.length) {
+      throw new Error(`Vector dimensions mismatch: ${a.length} vs ${b.length}`);
+    }
+    let sum = 0;
+    for (let i = 0; i < a.length; i++) {
+      const diff = a[i] - b[i];
+      sum += diff * diff;
+    }
+    return Math.sqrt(sum);
+  }
+  /**
+   * Calculate dot product of two vectors
+   */
+  static dotProduct(a, b) {
+    if (a.length !== b.length) {
+      throw new Error(`Vector dimensions mismatch: ${a.length} vs ${b.length}`);
+    }
+    let result = 0;
+    for (let i = 0; i < a.length; i++) {
+      result += a[i] * b[i];
+    }
+    return result;
+  }
+  /**
+   * Normalize a vector to unit length
+   */
+  static normalize(vector) {
+    let norm = 0;
+    for (let i = 0; i < vector.length; i++) {
+      norm += vector[i] * vector[i];
+    }
+    norm = Math.sqrt(norm);
+    if (norm === 0) {
+      return vector.slice();
+    }
+    return vector.map((v) => v / norm);
+  }
+  /**
+   * Average multiple vectors
+   */
+  static average(vectors) {
+    if (vectors.length === 0) {
+      throw new Error("Cannot average empty array of vectors");
+    }
+    const dimensions = vectors[0].length;
+    const result = new Array(dimensions).fill(0);
+    for (const vector of vectors) {
+      if (vector.length !== dimensions) {
+        throw new Error(
+          `Vector dimensions mismatch: expected ${dimensions}, got ${vector.length}`
+        );
+      }
+      for (let i = 0; i < dimensions; i++) {
+        result[i] += vector[i];
+      }
+    }
+    for (let i = 0; i < dimensions; i++) {
+      result[i] /= vectors.length;
+    }
+    return result;
+  }
+  /**
+   * Weighted average of vectors
+   */
+  static weightedAverage(vectors, weights) {
+    if (vectors.length === 0) {
+      throw new Error("Cannot average empty array of vectors");
+    }
+    if (vectors.length !== weights.length) {
+      throw new Error("Vectors and weights arrays must have same length");
+    }
+    const dimensions = vectors[0].length;
+    const result = new Array(dimensions).fill(0);
+    let totalWeight = 0;
+    for (let j = 0; j < vectors.length; j++) {
+      const vector = vectors[j];
+      const weight = weights[j];
+      totalWeight += weight;
+      if (vector.length !== dimensions) {
+        throw new Error(
+          `Vector dimensions mismatch: expected ${dimensions}, got ${vector.length}`
+        );
+      }
+      for (let i = 0; i < dimensions; i++) {
+        result[i] += vector[i] * weight;
+      }
+    }
+    if (totalWeight === 0) {
+      throw new Error("Total weight cannot be zero");
+    }
+    for (let i = 0; i < dimensions; i++) {
+      result[i] /= totalWeight;
+    }
+    return result;
+  }
+};
+var ModelRegistry = class {
+  models = /* @__PURE__ */ new Map();
+  defaultModel = null;
+  /**
+   * Register a model
+   */
+  register(model, isDefault = false) {
+    const key = `${model.provider}:${model.name}`;
+    this.models.set(key, model);
+    if (isDefault || this.defaultModel === null) {
+      this.defaultModel = key;
+    }
+  }
+  /**
+   * Get a model by provider and name
+   */
+  get(provider, name) {
+    return this.models.get(`${provider}:${name}`);
+  }
+  /**
+   * Get model by key
+   */
+  getByKey(key) {
+    return this.models.get(key);
+  }
+  /**
+   * Get the default model
+   */
+  getDefault() {
+    if (this.defaultModel === null) {
+      return void 0;
+    }
+    return this.models.get(this.defaultModel);
+  }
+  /**
+   * Set default model
+   */
+  setDefault(provider, name) {
+    const key = `${provider}:${name}`;
+    if (!this.models.has(key)) {
+      throw new Error(`Model ${key} not found in registry`);
+    }
+    this.defaultModel = key;
+  }
+  /**
+   * List all registered models
+   */
+  list() {
+    return Array.from(this.models.values()).map((m) => m.info);
+  }
+  /**
+   * Check if a model is registered
+   */
+  has(provider, name) {
+    return this.models.has(`${provider}:${name}`);
+  }
+  /**
+   * Remove a model
+   */
+  remove(provider, name) {
+    const key = `${provider}:${name}`;
+    if (this.defaultModel === key) {
+      this.defaultModel = null;
+    }
+    return this.models.delete(key);
+  }
+  /**
+   * Clear all models
+   */
+  clear() {
+    this.models.clear();
+    this.defaultModel = null;
+  }
+};
+var modelRegistry = new ModelRegistry();
+
+// src/core/utils.ts
+function batch(items, batchSize) {
+  const batches = [];
+  for (let i = 0; i < items.length; i += batchSize) {
+    batches.push(items.slice(i, i + batchSize));
+  }
+  return batches;
+}
+async function withConcurrency(items, fn, concurrency) {
+  const results = new Array(items.length);
+  let currentIndex = 0;
+  async function worker() {
+    while (currentIndex < items.length) {
+      const index = currentIndex++;
+      results[index] = await fn(items[index], index);
+    }
+  }
+  const workers = Array.from(
+    { length: Math.min(concurrency, items.length) },
+    () => worker()
+  );
+  await Promise.all(workers);
+  return results;
+}
+async function retry(fn, options = {}) {
+  const {
+    maxRetries = 3,
+    initialDelay = 1e3,
+    maxDelay = 3e4,
+    backoffMultiplier = 2,
+    retryCondition = () => true
+  } = options;
+  let lastError;
+  let delay = initialDelay;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt === maxRetries || !retryCondition(lastError)) {
+        throw lastError;
+      }
+      await sleep(delay);
+      delay = Math.min(delay * backoffMultiplier, maxDelay);
+    }
+  }
+  throw lastError;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function measureTime(fn) {
+  const start = performance.now();
+  const result = await fn();
+  const durationMs = performance.now() - start;
+  return { result, durationMs };
+}
+
+// src/providers/BaseProvider.ts
+var BaseProvider = class extends EmbeddingModel {
+  config;
+  metrics;
+  health;
+  latencies = [];
+  maxLatencySamples = 1e3;
+  constructor(config) {
+    super();
+    this.config = {
+      timeout: 3e4,
+      maxRetries: 3,
+      retryDelay: 1e3,
+      ...config
+    };
+    this.metrics = this.createInitialMetrics();
+    this.health = {
+      healthy: true,
+      latencyMs: 0,
+      lastCheck: Date.now()
+    };
+  }
+  createInitialMetrics() {
+    return {
+      provider: this.config.type,
+      totalRequests: 0,
+      successfulRequests: 0,
+      failedRequests: 0,
+      totalTokens: 0,
+      avgLatencyMs: 0,
+      p50LatencyMs: 0,
+      p95LatencyMs: 0,
+      p99LatencyMs: 0,
+      errorRate: 0,
+      rateLimitHits: 0,
+      estimatedCostUSD: 0
+    };
+  }
+  /**
+   * Generate embedding for a single text
+   */
+  async embed(text, options) {
+    const result = await this.embedBatch([text], options);
+    return result.results[0];
+  }
+  /**
+   * Generate embeddings for multiple texts
+   */
+  async embedBatch(texts, options) {
+    const startTime = performance.now();
+    const maxBatchSize = this.info.maxBatchSize;
+    const concurrency = options?.concurrency ?? 5;
+    const results = [];
+    let totalTokens = 0;
+    let failures = 0;
+    const batches = batch(texts, maxBatchSize);
+    const processBatch = async (batchTexts) => {
+      this.metrics.totalRequests++;
+      try {
+        const { result, durationMs } = await measureTime(
+          () => retry(() => this.doEmbed(batchTexts, options), {
+            maxRetries: this.config.maxRetries,
+            initialDelay: this.config.retryDelay,
+            retryCondition: (error) => this.isRetryable(error)
+          })
+        );
+        this.recordLatency(durationMs);
+        this.metrics.successfulRequests++;
+        this.metrics.totalTokens += result.tokenCount;
+        totalTokens += result.tokenCount;
+        return batchTexts.map((text, i) => ({
+          vector: result.vectors[i],
+          text,
+          tokenCount: Math.ceil(result.tokenCount / batchTexts.length),
+          cached: false,
+          model: this.info.name,
+          dimensions: this.info.dimensions,
+          latencyMs: durationMs / batchTexts.length
+        }));
+      } catch (error) {
+        this.metrics.failedRequests++;
+        this.health.healthy = false;
+        this.health.error = error.message;
+        if (options?.continueOnError) {
+          failures += batchTexts.length;
+          return [];
+        }
+        throw error;
+      }
+    };
+    const batchResults = await withConcurrency(
+      batches,
+      processBatch,
+      concurrency
+    );
+    for (const batchResult of batchResults) {
+      results.push(...batchResult);
+    }
+    const totalLatencyMs = performance.now() - startTime;
+    this.updateMetrics();
+    return {
+      results,
+      totalTokens,
+      totalLatencyMs,
+      cacheHits: 0,
+      cacheMisses: texts.length,
+      failures
+    };
+  }
+  /**
+   * Check if error is retryable
+   */
+  isRetryable(error) {
+    const message = error.message.toLowerCase();
+    return message.includes("rate limit") || message.includes("timeout") || message.includes("network") || message.includes("econnreset") || message.includes("502") || message.includes("503") || message.includes("504");
+  }
+  /**
+   * Record latency sample
+   */
+  recordLatency(latencyMs) {
+    this.latencies.push(latencyMs);
+    if (this.latencies.length > this.maxLatencySamples) {
+      this.latencies.shift();
+    }
+  }
+  /**
+   * Calculate percentile from latencies
+   */
+  calculatePercentile(p) {
+    if (this.latencies.length === 0) return 0;
+    const sorted = [...this.latencies].sort((a, b) => a - b);
+    const index = Math.ceil(p / 100 * sorted.length) - 1;
+    return sorted[Math.max(0, index)];
+  }
+  /**
+   * Update metrics
+   */
+  updateMetrics() {
+    const total = this.metrics.totalRequests;
+    if (total > 0) {
+      this.metrics.errorRate = this.metrics.failedRequests / total;
+      this.metrics.avgLatencyMs = this.latencies.reduce((a, b) => a + b, 0) / this.latencies.length || 0;
+      this.metrics.p50LatencyMs = this.calculatePercentile(50);
+      this.metrics.p95LatencyMs = this.calculatePercentile(95);
+      this.metrics.p99LatencyMs = this.calculatePercentile(99);
+    }
+  }
+  /**
+   * Get provider metrics
+   */
+  getMetrics() {
+    return { ...this.metrics };
+  }
+  /**
+   * Get provider health
+   */
+  getHealth() {
+    return { ...this.health };
+  }
+  /**
+   * Check provider health
+   */
+  async checkHealth() {
+    try {
+      const { durationMs } = await measureTime(
+        () => this.doEmbed(["health check"])
+      );
+      this.health = {
+        healthy: true,
+        latencyMs: durationMs,
+        lastCheck: Date.now()
+      };
+    } catch (error) {
+      this.health = {
+        healthy: false,
+        latencyMs: 0,
+        lastCheck: Date.now(),
+        error: error.message
+      };
+    }
+    return this.health;
+  }
+  /**
+   * Reset metrics
+   */
+  resetMetrics() {
+    this.metrics = this.createInitialMetrics();
+    this.latencies = [];
+  }
+};
+
+// src/providers/OpenAIProvider.ts
+var OPENAI_MODELS = {
+  "text-embedding-3-small": {
+    name: "text-embedding-3-small",
+    provider: "openai",
+    dimensions: 1536,
+    maxTokens: 8191,
+    maxBatchSize: 2048,
+    costPer1K: 2e-5,
+    description: "Smaller, faster, cheaper embedding model"
+  },
+  "text-embedding-3-large": {
+    name: "text-embedding-3-large",
+    provider: "openai",
+    dimensions: 3072,
+    maxTokens: 8191,
+    maxBatchSize: 2048,
+    costPer1K: 13e-5,
+    description: "Larger, more powerful embedding model"
+  },
+  "text-embedding-ada-002": {
+    name: "text-embedding-ada-002",
+    provider: "openai",
+    dimensions: 1536,
+    maxTokens: 8191,
+    maxBatchSize: 2048,
+    costPer1K: 1e-4,
+    description: "Legacy embedding model"
+  }
+};
+var OpenAIProvider = class extends BaseProvider {
+  modelInfo;
+  apiKey;
+  baseUrl;
+  organization;
+  constructor(config) {
+    super({ ...config, type: "openai" });
+    if (!config.apiKey) {
+      throw new Error("OpenAI API key is required");
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl ?? "https://api.openai.com/v1";
+    this.organization = config.organization;
+    const modelName = config.model ?? "text-embedding-3-small";
+    const modelConfig = OPENAI_MODELS[modelName];
+    if (!modelConfig) {
+      this.modelInfo = {
+        name: modelName,
+        provider: "openai",
+        dimensions: config.dimensions ?? 1536,
+        maxTokens: 8191,
+        maxBatchSize: 2048,
+        costPer1K: 1e-4
+      };
+    } else {
+      this.modelInfo = {
+        ...modelConfig,
+        // Allow dimension override for text-embedding-3 models
+        dimensions: config.dimensions ?? modelConfig.dimensions
+      };
+    }
+  }
+  get info() {
+    return this.modelInfo;
+  }
+  async doEmbed(texts, options) {
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`
+    };
+    if (this.organization) {
+      headers["OpenAI-Organization"] = this.organization;
+    }
+    const body = {
+      model: options?.model ?? this.modelInfo.name,
+      input: texts
+    };
+    if (this.modelInfo.name.startsWith("text-embedding-3")) {
+      const config2 = this.config;
+      if (config2.dimensions) {
+        body.dimensions = config2.dimensions;
+      }
+    }
+    const config = this.config;
+    if (config.encodingFormat) {
+      body.encoding_format = config.encodingFormat;
+    }
+    if (options?.user) {
+      body.user = options.user;
+    }
+    const response = await fetch(`${this.baseUrl}/embeddings`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal: this.config.timeout ? AbortSignal.timeout(this.config.timeout) : void 0
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: { message: response.statusText } }));
+      const errorMessage = error.error?.message ?? response.statusText;
+      if (response.status === 429) {
+        this.metrics.rateLimitHits++;
+      }
+      throw new Error(`OpenAI API error: ${errorMessage} (${response.status})`);
+    }
+    const data = await response.json();
+    const embeddings = data.data.sort((a, b) => a.index - b.index);
+    const vectors = embeddings.map((e) => e.embedding);
+    const tokenCount = data.usage?.total_tokens ?? 0;
+    this.metrics.estimatedCostUSD += tokenCount / 1e3 * (this.modelInfo.costPer1K ?? 0);
+    return { vectors, tokenCount };
+  }
+  /**
+   * Count tokens using tiktoken approximation
+   */
+  countTokens(text) {
+    const words = text.split(/\s+/);
+    let tokens = 0;
+    for (const word of words) {
+      tokens += Math.ceil(word.length / 4) + 1;
+    }
+    return Math.max(1, tokens);
+  }
+};
+function createOpenAIProvider(config) {
+  return new OpenAIProvider(config);
+}
+
+// src/providers/CohereProvider.ts
+var COHERE_MODELS = {
+  "embed-english-v3.0": {
+    name: "embed-english-v3.0",
+    provider: "cohere",
+    dimensions: 1024,
+    maxTokens: 512,
+    maxBatchSize: 96,
+    costPer1K: 1e-4,
+    description: "English embedding model v3"
+  },
+  "embed-multilingual-v3.0": {
+    name: "embed-multilingual-v3.0",
+    provider: "cohere",
+    dimensions: 1024,
+    maxTokens: 512,
+    maxBatchSize: 96,
+    costPer1K: 1e-4,
+    description: "Multilingual embedding model v3"
+  },
+  "embed-english-light-v3.0": {
+    name: "embed-english-light-v3.0",
+    provider: "cohere",
+    dimensions: 384,
+    maxTokens: 512,
+    maxBatchSize: 96,
+    costPer1K: 1e-4,
+    description: "Lightweight English embedding model v3"
+  },
+  "embed-multilingual-light-v3.0": {
+    name: "embed-multilingual-light-v3.0",
+    provider: "cohere",
+    dimensions: 384,
+    maxTokens: 512,
+    maxBatchSize: 96,
+    costPer1K: 1e-4,
+    description: "Lightweight multilingual embedding model v3"
+  },
+  "embed-english-v2.0": {
+    name: "embed-english-v2.0",
+    provider: "cohere",
+    dimensions: 4096,
+    maxTokens: 512,
+    maxBatchSize: 96,
+    costPer1K: 1e-4,
+    description: "Legacy English embedding model v2"
+  }
+};
+var CohereProvider = class extends BaseProvider {
+  modelInfo;
+  apiKey;
+  baseUrl;
+  inputType;
+  truncate;
+  constructor(config) {
+    super({ ...config, type: "cohere" });
+    if (!config.apiKey) {
+      throw new Error("Cohere API key is required");
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl ?? "https://api.cohere.ai/v1";
+    this.inputType = config.inputType ?? "search_document";
+    this.truncate = config.truncate ?? "END";
+    const modelName = config.model ?? "embed-english-v3.0";
+    const modelConfig = COHERE_MODELS[modelName];
+    if (!modelConfig) {
+      this.modelInfo = {
+        name: modelName,
+        provider: "cohere",
+        dimensions: 1024,
+        maxTokens: 512,
+        maxBatchSize: 96,
+        costPer1K: 1e-4
+      };
+    } else {
+      this.modelInfo = { ...modelConfig };
+    }
+  }
+  get info() {
+    return this.modelInfo;
+  }
+  async doEmbed(texts, options) {
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`,
+      "Request-Source": "agentsea-embeddings"
+    };
+    const body = {
+      model: options?.model ?? this.modelInfo.name,
+      texts,
+      input_type: this.inputType,
+      truncate: this.truncate
+    };
+    const response = await fetch(`${this.baseUrl}/embed`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal: this.config.timeout ? AbortSignal.timeout(this.config.timeout) : void 0
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: response.statusText }));
+      const errorMessage = error.message ?? response.statusText;
+      if (response.status === 429) {
+        this.metrics.rateLimitHits++;
+      }
+      throw new Error(`Cohere API error: ${errorMessage} (${response.status})`);
+    }
+    const data = await response.json();
+    const vectors = data.embeddings;
+    const tokenCount = texts.reduce(
+      (sum, text) => sum + this.countTokens(text),
+      0
+    );
+    this.metrics.estimatedCostUSD += tokenCount / 1e3 * (this.modelInfo.costPer1K ?? 0);
+    return { vectors, tokenCount };
+  }
+  /**
+   * Set input type for embeddings
+   */
+  setInputType(inputType) {
+    this.inputType = inputType;
+    return this;
+  }
+  /**
+   * Count tokens (approximation)
+   */
+  countTokens(text) {
+    return Math.ceil(text.length / 4);
+  }
+};
+function createCohereProvider(config) {
+  return new CohereProvider(config);
+}
+
+// src/providers/VoyageProvider.ts
+var VOYAGE_MODELS = {
+  "voyage-3": {
+    name: "voyage-3",
+    provider: "voyage",
+    dimensions: 1024,
+    maxTokens: 32e3,
+    maxBatchSize: 128,
+    costPer1K: 6e-5,
+    description: "Latest general-purpose embedding model"
+  },
+  "voyage-3-lite": {
+    name: "voyage-3-lite",
+    provider: "voyage",
+    dimensions: 512,
+    maxTokens: 32e3,
+    maxBatchSize: 128,
+    costPer1K: 2e-5,
+    description: "Lightweight general-purpose model"
+  },
+  "voyage-code-3": {
+    name: "voyage-code-3",
+    provider: "voyage",
+    dimensions: 1024,
+    maxTokens: 32e3,
+    maxBatchSize: 128,
+    costPer1K: 6e-5,
+    description: "Optimized for code retrieval"
+  },
+  "voyage-finance-2": {
+    name: "voyage-finance-2",
+    provider: "voyage",
+    dimensions: 1024,
+    maxTokens: 32e3,
+    maxBatchSize: 128,
+    costPer1K: 12e-5,
+    description: "Optimized for finance domain"
+  },
+  "voyage-law-2": {
+    name: "voyage-law-2",
+    provider: "voyage",
+    dimensions: 1024,
+    maxTokens: 32e3,
+    maxBatchSize: 128,
+    costPer1K: 12e-5,
+    description: "Optimized for legal domain"
+  },
+  "voyage-multilingual-2": {
+    name: "voyage-multilingual-2",
+    provider: "voyage",
+    dimensions: 1024,
+    maxTokens: 32e3,
+    maxBatchSize: 128,
+    costPer1K: 12e-5,
+    description: "Multilingual embedding model"
+  },
+  "voyage-2": {
+    name: "voyage-2",
+    provider: "voyage",
+    dimensions: 1024,
+    maxTokens: 4e3,
+    maxBatchSize: 128,
+    costPer1K: 1e-4,
+    description: "Previous generation model"
+  }
+};
+var VoyageProvider = class extends BaseProvider {
+  modelInfo;
+  apiKey;
+  baseUrl;
+  inputType;
+  truncation;
+  constructor(config) {
+    super({ ...config, type: "voyage" });
+    if (!config.apiKey) {
+      throw new Error("Voyage AI API key is required");
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl ?? "https://api.voyageai.com/v1";
+    this.inputType = config.inputType ?? "document";
+    this.truncation = config.truncation ?? true;
+    const modelName = config.model ?? "voyage-3";
+    const modelConfig = VOYAGE_MODELS[modelName];
+    if (!modelConfig) {
+      this.modelInfo = {
+        name: modelName,
+        provider: "voyage",
+        dimensions: 1024,
+        maxTokens: 32e3,
+        maxBatchSize: 128,
+        costPer1K: 1e-4
+      };
+    } else {
+      this.modelInfo = { ...modelConfig };
+    }
+  }
+  get info() {
+    return this.modelInfo;
+  }
+  async doEmbed(texts, options) {
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`
+    };
+    const body = {
+      model: options?.model ?? this.modelInfo.name,
+      input: texts,
+      input_type: this.inputType,
+      truncation: this.truncation
+    };
+    const response = await fetch(`${this.baseUrl}/embeddings`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal: this.config.timeout ? AbortSignal.timeout(this.config.timeout) : void 0
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ detail: response.statusText }));
+      const errorMessage = error.detail ?? response.statusText;
+      if (response.status === 429) {
+        this.metrics.rateLimitHits++;
+      }
+      throw new Error(
+        `Voyage AI API error: ${errorMessage} (${response.status})`
+      );
+    }
+    const data = await response.json();
+    const vectors = data.data.map((d) => d.embedding);
+    const tokenCount = data.usage?.total_tokens ?? texts.reduce((sum, text) => sum + this.countTokens(text), 0);
+    this.metrics.estimatedCostUSD += tokenCount / 1e3 * (this.modelInfo.costPer1K ?? 0);
+    return { vectors, tokenCount };
+  }
+  /**
+   * Set input type for embeddings
+   */
+  setInputType(inputType) {
+    this.inputType = inputType;
+    return this;
+  }
+  /**
+   * Count tokens (approximation)
+   */
+  countTokens(text) {
+    return Math.ceil(text.length / 4);
+  }
+};
+function createVoyageProvider(config) {
+  return new VoyageProvider(config);
+}
+
+// src/providers/LocalProvider.ts
+var LocalProvider = class extends BaseProvider {
+  modelInfo;
+  embedFn = null;
+  normalize;
+  batchSize;
+  constructor(config) {
+    super({ ...config, type: "local" });
+    if (!config.embedFn && !config.modelPath) {
+      throw new Error(
+        "Either embedFn or modelPath is required for local provider"
+      );
+    }
+    this.embedFn = config.embedFn ?? null;
+    this.normalize = config.normalize ?? true;
+    this.batchSize = config.batchSize ?? 32;
+    this.modelInfo = {
+      name: config.name ?? config.modelPath ?? "local-model",
+      provider: "local",
+      dimensions: config.dimensions,
+      maxTokens: config.maxTokens ?? 512,
+      maxBatchSize: config.maxBatchSize ?? 32,
+      costPer1K: 0,
+      // Local models have no API cost
+      description: "Local embedding model"
+    };
+  }
+  get info() {
+    return this.modelInfo;
+  }
+  async doEmbed(texts, options) {
+    if (!this.embedFn) {
+      throw new Error("No embedding function configured");
+    }
+    let vectors = await this.embedFn(texts, options);
+    if (this.normalize) {
+      vectors = vectors.map((v) => EmbeddingModel.normalize(v));
+    }
+    const tokenCount = texts.reduce(
+      (sum, text) => sum + this.countTokens(text),
+      0
+    );
+    return { vectors, tokenCount };
+  }
+  /**
+   * Set the embedding function
+   */
+  setEmbedFunction(fn) {
+    this.embedFn = fn;
+    return this;
+  }
+  /**
+   * Count tokens (simple approximation for local models)
+   */
+  countTokens(text) {
+    return text.split(/\s+/).length;
+  }
+};
+function createLocalProvider(config) {
+  return new LocalProvider(config);
+}
+function createMockProvider(config) {
+  const delay = config.delay ?? 10;
+  return new LocalProvider({
+    type: "local",
+    dimensions: config.dimensions,
+    name: config.name ?? "mock-model",
+    embedFn: (texts) => {
+      return new Promise((resolve) => setTimeout(resolve, delay)).then(() => {
+        return texts.map((text) => {
+          const hash = text.split("").reduce((acc, char) => {
+            return (acc << 5) - acc + char.charCodeAt(0);
+          }, 0);
+          const vector = [];
+          let seed = Math.abs(hash);
+          for (let i = 0; i < config.dimensions; i++) {
+            seed = seed * 1103515245 + 12345 & 2147483647;
+            vector.push(seed / 2147483647 * 2 - 1);
+          }
+          const norm = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
+          return vector.map((v) => v / norm);
+        });
+      });
+    }
+  });
+}
+function createRandomProvider(config) {
+  return new LocalProvider({
+    type: "local",
+    dimensions: config.dimensions,
+    name: config.name ?? "random-model",
+    embedFn: (texts) => {
+      return Promise.resolve(
+        texts.map(() => {
+          const vector = [];
+          for (let i = 0; i < config.dimensions; i++) {
+            vector.push(Math.random() * 2 - 1);
+          }
+          const norm = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
+          return vector.map((v) => v / norm);
+        })
+      );
+    }
+  });
+}
+
+// src/providers/HuggingFaceProvider.ts
+var HUGGINGFACE_MODELS = {
+  "sentence-transformers/all-MiniLM-L6-v2": {
+    dimensions: 384,
+    maxTokens: 256,
+    description: "Lightweight sentence transformer"
+  },
+  "sentence-transformers/all-mpnet-base-v2": {
+    dimensions: 768,
+    maxTokens: 384,
+    description: "High quality sentence transformer"
+  },
+  "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2": {
+    dimensions: 384,
+    maxTokens: 128,
+    description: "Multilingual sentence transformer"
+  },
+  "BAAI/bge-small-en-v1.5": {
+    dimensions: 384,
+    maxTokens: 512,
+    description: "BGE small English model"
+  },
+  "BAAI/bge-base-en-v1.5": {
+    dimensions: 768,
+    maxTokens: 512,
+    description: "BGE base English model"
+  },
+  "BAAI/bge-large-en-v1.5": {
+    dimensions: 1024,
+    maxTokens: 512,
+    description: "BGE large English model"
+  },
+  "thenlper/gte-small": {
+    dimensions: 384,
+    maxTokens: 512,
+    description: "GTE small model"
+  },
+  "thenlper/gte-base": {
+    dimensions: 768,
+    maxTokens: 512,
+    description: "GTE base model"
+  },
+  "thenlper/gte-large": {
+    dimensions: 1024,
+    maxTokens: 512,
+    description: "GTE large model"
+  },
+  "intfloat/e5-small-v2": {
+    dimensions: 384,
+    maxTokens: 512,
+    description: "E5 small v2 model"
+  },
+  "intfloat/e5-base-v2": {
+    dimensions: 768,
+    maxTokens: 512,
+    description: "E5 base v2 model"
+  },
+  "intfloat/e5-large-v2": {
+    dimensions: 1024,
+    maxTokens: 512,
+    description: "E5 large v2 model"
+  }
+};
+var HuggingFaceProvider = class extends BaseProvider {
+  modelInfo;
+  apiKey;
+  baseUrl;
+  waitForModel;
+  constructor(config) {
+    super({ ...config, type: "huggingface" });
+    if (!config.apiKey) {
+      throw new Error("HuggingFace API key is required");
+    }
+    this.apiKey = config.apiKey;
+    this.waitForModel = config.waitForModel ?? true;
+    const modelName = config.model ?? "sentence-transformers/all-MiniLM-L6-v2";
+    const knownConfig = HUGGINGFACE_MODELS[modelName];
+    this.baseUrl = config.baseUrl ?? `https://api-inference.huggingface.co/pipeline/feature-extraction/${modelName}`;
+    this.modelInfo = {
+      name: modelName,
+      provider: "huggingface",
+      dimensions: knownConfig?.dimensions ?? 768,
+      maxTokens: knownConfig?.maxTokens ?? 512,
+      maxBatchSize: 32,
+      // HF inference API handles batching
+      costPer1K: 0,
+      // Free tier available
+      description: knownConfig?.description ?? "HuggingFace model"
+    };
+  }
+  get info() {
+    return this.modelInfo;
+  }
+  async doEmbed(texts, _options) {
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`
+    };
+    const body = {
+      inputs: texts,
+      options: {
+        wait_for_model: this.waitForModel
+      }
+    };
+    const response = await fetch(this.baseUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal: this.config.timeout ? AbortSignal.timeout(this.config.timeout) : void 0
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: response.statusText }));
+      const errorMessage = error.error ?? response.statusText;
+      if (response.status === 429) {
+        this.metrics.rateLimitHits++;
+      }
+      throw new Error(
+        `HuggingFace API error: ${errorMessage} (${response.status})`
+      );
+    }
+    const data = await response.json();
+    let vectors;
+    if (Array.isArray(data) && Array.isArray(data[0])) {
+      if (typeof data[0][0] === "number") {
+        vectors = data;
+      } else {
+        vectors = data.map((tokenEmbeddings) => {
+          const dims = tokenEmbeddings[0]?.length ?? this.modelInfo.dimensions;
+          const mean = new Array(dims).fill(0);
+          for (const embedding of tokenEmbeddings) {
+            for (let i = 0; i < dims; i++) {
+              mean[i] += embedding[i];
+            }
+          }
+          return mean.map((v) => v / tokenEmbeddings.length);
+        });
+      }
+    } else {
+      vectors = [data];
+    }
+    const tokenCount = texts.reduce(
+      (sum, text) => sum + this.countTokens(text),
+      0
+    );
+    return { vectors, tokenCount };
+  }
+  /**
+   * Count tokens (approximation based on wordpiece)
+   */
+  countTokens(text) {
+    const words = text.split(/\s+/);
+    let tokens = 0;
+    for (const word of words) {
+      tokens += Math.ceil(word.length / 5) + 1;
+    }
+    return Math.max(1, tokens);
+  }
+};
+function createHuggingFaceProvider(config) {
+  return new HuggingFaceProvider(config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseProvider,
+  CohereProvider,
+  HuggingFaceProvider,
+  LocalProvider,
+  OpenAIProvider,
+  VoyageProvider,
+  createCohereProvider,
+  createHuggingFaceProvider,
+  createLocalProvider,
+  createMockProvider,
+  createOpenAIProvider,
+  createRandomProvider,
+  createVoyageProvider
+});