@soulcraft/brainy 6.5.0 → 6.6.0

package/dist/utils/embedding.d.ts

@@ -1,60 +1,37 @@
 /**
- * Embedding functions for converting data to vectors using Transformers.js
- * Complete rewrite to eliminate TensorFlow.js and use ONNX-based models
+ * Embedding functions for converting data to vectors
+ *
+ * Uses direct ONNX WASM for universal compatibility.
+ * No transformers.js dependency - clean, production-grade implementation.
  */
 import { EmbeddingFunction, EmbeddingModel, Vector } from '../coreTypes.js';
 /**
- * Detect the best available GPU device for the current environment
- */
-export declare function detectBestDevice(): Promise<'cpu' | 'webgpu' | 'cuda'>;
-/**
- * Resolve device string to actual device configuration
- */
-export declare function resolveDevice(device?: string): Promise<string>;
-/**
- * Transformers.js Sentence Encoder embedding model
- * Uses ONNX Runtime for fast, offline embeddings with smaller models
- * Default model: all-MiniLM-L6-v2 (384 dimensions, ~90MB)
+ * TransformerEmbedding options (kept for backward compatibility)
  */
 export interface TransformerEmbeddingOptions {
-    /** Model name/path to use - defaults to all-MiniLM-L6-v2 */
+    /** Model name - only all-MiniLM-L6-v2 is supported */
     model?: string;
     /** Whether to enable verbose logging */
     verbose?: boolean;
-    /** Custom cache directory for models */
+    /** Custom cache directory - ignored (model is bundled) */
     cacheDir?: string;
-    /** Force local files only (no downloads) */
+    /** Force local files only - ignored (model is bundled) */
     localFilesOnly?: boolean;
-    /** Model precision: 'q8' = 75% smaller quantized model, 'fp32' = full precision (default) */
+    /** Model precision - always q8 */
     precision?: 'fp32' | 'q8';
-    /** Device to run inference on - 'auto' detects best available */
+    /** Device - always WASM */
     device?: 'auto' | 'cpu' | 'webgpu' | 'cuda' | 'gpu';
 }
+/**
+ * TransformerEmbedding - Sentence embeddings using WASM ONNX
+ *
+ * This class delegates all work to EmbeddingManager which uses
+ * the direct ONNX WASM engine. Kept for backward compatibility.
+ */
 export declare class TransformerEmbedding implements EmbeddingModel {
-    private extractor;
     private initialized;
     private verbose;
-    private options;
-    /**
-     * Create a new TransformerEmbedding instance
-     */
     constructor(options?: TransformerEmbeddingOptions);
-    /**
-     * Get the default cache directory for models
-     */
-    private getDefaultCacheDir;
-    /**
-     * Check if we're running in a test environment
-     */
-    private isTestEnvironment;
-    /**
-     * Log message only if verbose mode is enabled
-     */
-    private logger;
-    /**
-     * Generate mock embeddings for unit tests
-     */
-    private getMockEmbedding;
     /**
      * Initialize the embedding model
      */
@@ -64,45 +41,51 @@ export declare class TransformerEmbedding implements EmbeddingModel {
      */
     embed(data: string | string[]): Promise<Vector>;
     /**
-     * Dispose of the model and free resources
+     * Get the embedding function
      */
-    dispose(): Promise<void>;
+    getEmbeddingFunction(): EmbeddingFunction;
     /**
-     * Get the dimension of embeddings produced by this model
+     * Check if initialized
      */
-    getDimension(): number;
+    isInitialized(): boolean;
     /**
-     * Check if the model is initialized
+     * Dispose resources (no-op for WASM engine)
      */
-    isInitialized(): boolean;
+    dispose(): Promise<void>;
 }
-export declare const UniversalSentenceEncoder: typeof TransformerEmbedding;
 /**
- * Create a new embedding model instance
+ * Create a simple embedding function using the default TransformerEmbedding
+ * This is the recommended way to create an embedding function for Brainy
  */
-export declare function createEmbeddingModel(options?: TransformerEmbeddingOptions): EmbeddingModel;
+export declare function createEmbeddingFunction(options?: TransformerEmbeddingOptions): EmbeddingFunction;
 /**
- * Default embedding function using the unified EmbeddingManager
- * Simple, clean, reliable - no more layers of indirection
+ * Create a TransformerEmbedding instance (backward compatibility)
+ */
+export declare function createTransformerEmbedding(options?: TransformerEmbeddingOptions): TransformerEmbedding;
+/**
+ * Convenience function to detect best device (always returns 'wasm')
+ */
+export declare function detectBestDevice(): Promise<'cpu' | 'webgpu' | 'cuda' | 'wasm'>;
+/**
+ * Resolve device string (always returns 'wasm')
+ */
+export declare function resolveDevice(_device?: string): Promise<string>;
+/**
+ * Default embedding function (backward compatibility)
  */
 export declare const defaultEmbeddingFunction: EmbeddingFunction;
 /**
- * Create an embedding function with custom options
- * NOTE: Options are validated but the singleton EmbeddingManager is always used
+ * UniversalSentenceEncoder alias (backward compatibility)
  */
-export declare function createEmbeddingFunction(options?: TransformerEmbeddingOptions): EmbeddingFunction;
+export declare const UniversalSentenceEncoder: typeof TransformerEmbedding;
 /**
- * Batch embedding function for processing multiple texts efficiently
+ * Batch embed function (backward compatibility)
  */
-export declare function batchEmbed(texts: string[], options?: TransformerEmbeddingOptions): Promise<Vector[]>;
+export declare function batchEmbed(texts: string[]): Promise<Vector[]>;
 /**
- * Embedding functions for specific model types
+ * Embedding functions registry (backward compatibility)
  */
 export declare const embeddingFunctions: {
-    /** Default lightweight model (all-MiniLM-L6-v2, 384 dimensions) */
-    default: EmbeddingFunction;
-    /** Create custom embedding function */
-    create: typeof createEmbeddingFunction;
-    /** Batch processing */
-    batch: typeof batchEmbed;
+    transformer: typeof createEmbeddingFunction;
+    default: typeof createEmbeddingFunction;
 };