@soulcraft/brainy 2.12.0 → 2.14.0

package/dist/utils/hybridModelManager.js

@@ -1,25 +1,25 @@
 /**
  * Hybrid Model Manager - BEST OF BOTH WORLDS
  *
- * Combines:
+ * NOW A WRAPPER AROUND SingletonModelManager
+ * Maintained for backward compatibility
+ *
+ * Previously combined:
  * 1. Multi-source downloading strategy (GitHub → CDN → Hugging Face)
  * 2. Singleton pattern preventing multiple ONNX model loads
  * 3. Environment-specific optimizations
  * 4. Graceful fallbacks and error handling
+ *
+ * Now delegates all operations to SingletonModelManager for true unification
  */
-import { TransformerEmbedding } from './embedding.js';
-import { existsSync } from 'fs';
-import { join } from 'path';
+import { singletonModelManager, getUnifiedEmbeddingFunction } from '../embeddings/SingletonModelManager.js';
 /**
- * Global singleton model manager - PREVENTS MULTIPLE MODEL LOADS
+ * HybridModelManager - Now a wrapper around SingletonModelManager
+ * Maintained for backward compatibility
  */
 class HybridModelManager {
     constructor() {
-        this.primaryModel = null;
-        this.modelPromise = null;
-        this.isInitialized = false;
-        // Smart model path detection
-        this.modelsPath = this.getModelsPath();
+        console.log('🔄 HybridModelManager now delegates to SingletonModelManager');
     }
     static getInstance() {
         if (!HybridModelManager.instance) {
@@ -28,207 +28,42 @@ class HybridModelManager {
         return HybridModelManager.instance;
     }
     /**
-     * Get the primary embedding model - LOADS ONCE, REUSES FOREVER
+     * Get the primary embedding model - delegates to SingletonModelManager
      */
     async getPrimaryModel() {
-        // If already initialized, return immediately
-        if (this.primaryModel && this.isInitialized) {
-            return this.primaryModel;
-        }
-        // If initialization is in progress, wait for it
-        if (this.modelPromise) {
-            return await this.modelPromise;
-        }
-        // Start initialization with multi-source strategy
-        this.modelPromise = this.initializePrimaryModel();
-        return await this.modelPromise;
-    }
-    /**
-     * Smart model path detection
-     */
-    getModelsPath() {
-        const paths = [
-            process.env.BRAINY_MODELS_PATH,
-            './models',
-            './node_modules/@soulcraft/brainy/models',
-            join(process.cwd(), 'models')
-        ];
-        // Find first existing path or use default
-        for (const path of paths) {
-            if (path && existsSync(path)) {
-                return path;
-            }
-        }
-        return join(process.cwd(), 'models');
-    }
-    /**
-     * Initialize with BEST OF BOTH: Multi-source + Singleton
-     */
-    async initializePrimaryModel() {
-        try {
-            // Environment detection for optimal configuration
-            const isTest = globalThis.__BRAINY_TEST_ENV__ || process.env.NODE_ENV === 'test';
-            const isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';
-            const isServerless = typeof process !== 'undefined' && (process.env.VERCEL ||
-                process.env.NETLIFY ||
-                process.env.AWS_LAMBDA_FUNCTION_NAME ||
-                process.env.FUNCTIONS_WORKER_RUNTIME);
-            const isDocker = typeof process !== 'undefined' && (process.env.DOCKER_CONTAINER ||
-                process.env.KUBERNETES_SERVICE_HOST);
-            // Respect BRAINY_ALLOW_REMOTE_MODELS environment variable first
-            let forceLocalOnly = false;
-            if (process.env.BRAINY_ALLOW_REMOTE_MODELS !== undefined) {
-                forceLocalOnly = process.env.BRAINY_ALLOW_REMOTE_MODELS !== 'true';
-            }
-            // Smart configuration based on environment
-            let options = {
-                verbose: !isTest && !isServerless,
-                precision: 'fp32', // Use clearer precision parameter
-                device: 'cpu'
-            };
-            // Environment-specific optimizations
-            if (isBrowser) {
-                options = {
-                    ...options,
-                    localFilesOnly: forceLocalOnly || false, // Respect environment variable
-                    precision: 'fp32',
-                    device: 'cpu',
-                    verbose: false
-                };
-            }
-            else if (isServerless) {
-                options = {
-                    ...options,
-                    localFilesOnly: forceLocalOnly || true, // Default true for serverless, but respect env
-                    precision: 'fp32',
-                    device: 'cpu',
-                    verbose: false
-                };
-            }
-            else if (isDocker) {
-                options = {
-                    ...options,
-                    localFilesOnly: forceLocalOnly || true, // Default true for docker, but respect env
-                    precision: 'fp32',
-                    device: 'auto',
-                    verbose: false
-                };
-            }
-            else if (isTest) {
-                // CRITICAL FOR TESTS: Allow remote downloads but be smart about it
-                options = {
-                    ...options,
-                    localFilesOnly: forceLocalOnly || false, // Respect environment variable for tests
-                    precision: 'fp32',
-                    device: 'cpu',
-                    verbose: false
-                };
-            }
-            else {
-                options = {
-                    ...options,
-                    localFilesOnly: forceLocalOnly || false, // Respect environment variable for default node
-                    precision: 'fp32',
-                    device: 'auto',
-                    verbose: true
-                };
-            }
-            const environmentName = isBrowser ? 'browser' :
-                isServerless ? 'serverless' :
-                    isDocker ? 'container' :
-                        isTest ? 'test' : 'node';
-            if (options.verbose) {
-                console.log(`🧠 Initializing hybrid model manager (${environmentName} mode)...`);
-            }
-            // MULTI-SOURCE STRATEGY: Try local first, then remote fallbacks
-            this.primaryModel = await this.createModelWithFallbacks(options, environmentName);
-            this.isInitialized = true;
-            this.modelPromise = null; // Clear the promise
-            if (options.verbose) {
-                console.log(`✅ Hybrid model manager initialized successfully`);
-            }
-            return this.primaryModel;
-        }
-        catch (error) {
-            this.modelPromise = null; // Clear failed promise
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            const environmentInfo = typeof window !== 'undefined' ? 'browser' :
-                typeof process !== 'undefined' ? `node (${process.version})` : 'unknown';
-            throw new Error(`Failed to initialize hybrid model manager in ${environmentInfo} environment: ${errorMessage}. ` +
-                `This is critical for all Brainy operations.`);
-        }
+        // Delegate to SingletonModelManager
+        return await singletonModelManager.getModel();
     }
     /**
-     * Create model with multi-source fallback strategy
-     */
-    async createModelWithFallbacks(options, environmentName) {
-        const attempts = [
-            // 1. Try with current configuration (may use local cache)
-            { ...options, localFilesOnly: false, source: 'primary' },
-            // 2. If that fails, explicitly allow remote with verbose logging
-            { ...options, localFilesOnly: false, verbose: true, source: 'fallback-verbose' },
-            // 3. Last resort: basic configuration
-            { verbose: false, precision: 'fp32', device: 'cpu', localFilesOnly: false, source: 'last-resort' }
-        ];
-        let lastError = null;
-        for (const attemptOptions of attempts) {
-            try {
-                const { source, ...modelOptions } = attemptOptions;
-                if (attemptOptions.verbose) {
-                    console.log(`🔄 Attempting model load (${source})...`);
-                }
-                const model = new TransformerEmbedding(modelOptions);
-                await model.init();
-                if (attemptOptions.verbose) {
-                    console.log(`✅ Model loaded successfully with ${source} strategy`);
-                }
-                return model;
-            }
-            catch (error) {
-                lastError = error instanceof Error ? error : new Error(String(error));
-                if (attemptOptions.verbose) {
-                    console.log(`❌ Failed ${attemptOptions.source} strategy:`, lastError.message);
-                }
-                // Continue to next attempt
-            }
-        }
-        // All attempts failed
-        throw new Error(`All model loading strategies failed in ${environmentName} environment. ` +
-            `Last error: ${lastError?.message}. ` +
-            `Check network connectivity or ensure models are available locally.`);
-    }
-    /**
-     * Get embedding function that reuses the singleton model
+     * Get embedding function - delegates to SingletonModelManager
      */
     async getEmbeddingFunction() {
-        const model = await this.getPrimaryModel();
-        return async (data) => {
-            return await model.embed(data);
-        };
+        return await getUnifiedEmbeddingFunction();
     }
     /**
-     * Check if model is ready (loaded and initialized)
+     * Check if model is ready - delegates to SingletonModelManager
      */
     isModelReady() {
-        return this.isInitialized && this.primaryModel !== null;
+        return singletonModelManager.isInitialized();
     }
     /**
-     * Force model reload (for testing or recovery)
+     * Force model reload - not supported with SingletonModelManager
      */
     async reloadModel() {
-        this.primaryModel = null;
-        this.isInitialized = false;
-        this.modelPromise = null;
+        console.warn('⚠️ Model reload not supported with SingletonModelManager');
+        console.log('ℹ️ Singleton model persists for consistency');
+        // Just ensure model is initialized
         await this.getPrimaryModel();
     }
     /**
-     * Get model status for debugging
+     * Get model status - delegates to SingletonModelManager
      */
     getModelStatus() {
+        const isReady = singletonModelManager.isInitialized();
         return {
-            loaded: this.primaryModel !== null,
-            ready: this.isInitialized,
-            modelType: 'HybridModelManager (Multi-source + Singleton)'
+            loaded: isReady,
+            ready: isReady,
+            modelType: 'SingletonModelManager (Unified model instance)'
         };
     }
 }
@@ -236,24 +71,25 @@ HybridModelManager.instance = null;
 // Export singleton instance
 export const hybridModelManager = HybridModelManager.getInstance();
 /**
- * Get the hybrid singleton embedding function - USE THIS EVERYWHERE!
+ * Get the hybrid singleton embedding function - Now delegates to SingletonModelManager
+ * Maintained for backward compatibility
  */
 export async function getHybridEmbeddingFunction() {
-    return await hybridModelManager.getEmbeddingFunction();
+    return await getUnifiedEmbeddingFunction();
 }
 /**
- * Optimized hybrid embedding function that uses multi-source + singleton
+ * Hybrid embedding function - Now delegates to SingletonModelManager
+ * Maintained for backward compatibility
  */
 export const hybridEmbeddingFunction = async (data) => {
-    const embeddingFn = await getHybridEmbeddingFunction();
-    return await embeddingFn(data);
+    return await singletonModelManager.embed(data);
 };
 /**
- * Preload model for tests or production - CALL THIS ONCE AT START
+ * Preload model for tests or production - Now delegates to SingletonModelManager
  */
 export async function preloadHybridModel() {
-    console.log('🚀 Preloading hybrid model...');
-    await hybridModelManager.getPrimaryModel();
-    console.log('✅ Hybrid model preloaded and ready!');
+    console.log('🚀 Preloading model via SingletonModelManager...');
+    await singletonModelManager.getModel();
+    console.log('✅ Singleton model preloaded and ready!');
 }
 //# sourceMappingURL=hybridModelManager.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soulcraft/brainy",
-  "version": "2.12.0",
+  "version": "2.14.0",
   "description": "Universal Knowledge Protocol™ - World's first Triple Intelligence database unifying vector, graph, and document search in one API. 31 nouns × 40 verbs for infinite expressiveness.",
   "main": "dist/index.js",
   "module": "dist/index.js",