@lov3kaizen/agentsea-embeddings 0.5.1

package/dist/chunk-NBHIRTJT.mjs

@@ -0,0 +1,895 @@
+import {
+  batch,
+  measureTime,
+  retry,
+  withConcurrency
+} from "./chunk-3KM32UQK.mjs";
+import {
+  EmbeddingModel
+} from "./chunk-QAITLJ2E.mjs";
+
+// 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);
+}
+
+export {
+  BaseProvider,
+  OpenAIProvider,
+  createOpenAIProvider,
+  CohereProvider,
+  createCohereProvider,
+  VoyageProvider,
+  createVoyageProvider,
+  LocalProvider,
+  createLocalProvider,
+  createMockProvider,
+  createRandomProvider,
+  HuggingFaceProvider,
+  createHuggingFaceProvider
+};