@lov3kaizen/agentsea-embeddings 0.5.1

package/dist/chunk-QAITLJ2E.mjs

@@ -0,0 +1,259 @@
+// 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();
+
+export {
+  EmbeddingModel,
+  ModelRegistry,
+  modelRegistry
+};