agentic-flow 2.0.7 → 3.0.0-alpha.2

package/dist/utils/lazy-auth.js

@@ -0,0 +1,311 @@
+/**
+ * Lazy Authentication with Session Caching
+ * Reduces auth overhead by 5-10% through session caching and lazy validation
+ * Phase 3 Optimization
+ */
+/**
+ * Lazy Authentication Manager
+ * Caches validated sessions to avoid repeated authentication overhead
+ */
+export class LazyAuthManager {
+    config;
+    sessions = new Map();
+    stats;
+    cleanupTimer;
+    validationQueue = new Set();
+    constructor(config) {
+        this.config = {
+            enabled: config.enabled,
+            ttl: config.ttl || 3600000, // 1 hour default
+            maxSessions: config.maxSessions || 1000,
+            checkInterval: config.checkInterval || 60000 // 1 minute
+        };
+        this.stats = {
+            totalValidations: 0,
+            cacheHits: 0,
+            cacheMisses: 0,
+            sessionsActive: 0,
+            sessionsCleaned: 0,
+            avgValidationTime: 0
+        };
+        if (this.config.enabled) {
+            this.startCleanupTimer();
+        }
+    }
+    /**
+     * Authenticate a token (lazy validation)
+     */
+    async authenticate(token, validateFn) {
+        if (!this.config.enabled) {
+            // No caching, always validate
+            const userId = await validateFn(token);
+            return this.createSession(token, userId, true);
+        }
+        // Check cache first
+        const cached = this.sessions.get(token);
+        if (cached && !this.isExpired(cached)) {
+            this.stats.cacheHits++;
+            cached.lastAccessedAt = Date.now();
+            return cached;
+        }
+        this.stats.cacheMisses++;
+        // Lazy validation: check if already being validated
+        if (this.validationQueue.has(token)) {
+            // Wait for ongoing validation
+            return this.waitForValidation(token);
+        }
+        // Perform validation
+        return this.validateAndCache(token, validateFn);
+    }
+    /**
+     * Validate token and cache the session
+     */
+    async validateAndCache(token, validateFn) {
+        this.validationQueue.add(token);
+        try {
+            const startTime = Date.now();
+            const userId = await validateFn(token);
+            const validationTime = Date.now() - startTime;
+            // Update average validation time
+            this.updateAvgValidationTime(validationTime);
+            this.stats.totalValidations++;
+            // Create and cache session
+            const session = this.createSession(token, userId, true);
+            this.cacheSession(session);
+            return session;
+        }
+        catch (error) {
+            return null;
+        }
+        finally {
+            this.validationQueue.delete(token);
+        }
+    }
+    /**
+     * Wait for ongoing validation
+     */
+    async waitForValidation(token) {
+        // Poll for validation completion (max 5 seconds)
+        const maxAttempts = 50;
+        let attempts = 0;
+        while (this.validationQueue.has(token) && attempts < maxAttempts) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+            attempts++;
+        }
+        // Check cache after validation
+        const session = this.sessions.get(token);
+        return session && !this.isExpired(session) ? session : null;
+    }
+    /**
+     * Create a session object
+     */
+    createSession(token, userId, validated) {
+        const now = Date.now();
+        return {
+            token,
+            userId,
+            validated,
+            createdAt: now,
+            lastAccessedAt: now,
+            expiresAt: now + this.config.ttl
+        };
+    }
+    /**
+     * Cache a session
+     */
+    cacheSession(session) {
+        // Check max sessions limit
+        if (this.sessions.size >= this.config.maxSessions) {
+            this.evictOldest();
+        }
+        this.sessions.set(session.token, session);
+        this.stats.sessionsActive = this.sessions.size;
+    }
+    /**
+     * Check if session is expired
+     */
+    isExpired(session) {
+        return Date.now() > session.expiresAt;
+    }
+    /**
+     * Evict oldest session (LRU)
+     */
+    evictOldest() {
+        let oldest = null;
+        let oldestToken = null;
+        for (const [token, session] of this.sessions) {
+            if (!oldest || session.lastAccessedAt < oldest.lastAccessedAt) {
+                oldest = session;
+                oldestToken = token;
+            }
+        }
+        if (oldestToken) {
+            this.sessions.delete(oldestToken);
+            this.stats.sessionsCleaned++;
+        }
+    }
+    /**
+     * Update average validation time
+     */
+    updateAvgValidationTime(newTime) {
+        const total = this.stats.totalValidations;
+        const currentAvg = this.stats.avgValidationTime;
+        this.stats.avgValidationTime = (currentAvg * total + newTime) / (total + 1);
+    }
+    /**
+     * Start cleanup timer for expired sessions
+     */
+    startCleanupTimer() {
+        this.cleanupTimer = setInterval(() => {
+            this.cleanup();
+        }, this.config.checkInterval);
+    }
+    /**
+     * Clean up expired sessions
+     */
+    cleanup() {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [token, session] of this.sessions) {
+            if (now > session.expiresAt) {
+                this.sessions.delete(token);
+                cleaned++;
+            }
+        }
+        this.stats.sessionsCleaned += cleaned;
+        this.stats.sessionsActive = this.sessions.size;
+    }
+    /**
+     * Invalidate a session
+     */
+    invalidate(token) {
+        return this.sessions.delete(token);
+    }
+    /**
+     * Invalidate all sessions for a user
+     */
+    invalidateUser(userId) {
+        let count = 0;
+        for (const [token, session] of this.sessions) {
+            if (session.userId === userId) {
+                this.sessions.delete(token);
+                count++;
+            }
+        }
+        return count;
+    }
+    /**
+     * Get session if exists and valid
+     */
+    getSession(token) {
+        const session = this.sessions.get(token);
+        if (!session || this.isExpired(session)) {
+            return null;
+        }
+        session.lastAccessedAt = Date.now();
+        return session;
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Get cache hit rate
+     */
+    getCacheHitRate() {
+        const total = this.stats.cacheHits + this.stats.cacheMisses;
+        return total > 0 ? (this.stats.cacheHits / total) * 100 : 0;
+    }
+    /**
+     * Reset statistics
+     */
+    resetStats() {
+        this.stats = {
+            totalValidations: 0,
+            cacheHits: 0,
+            cacheMisses: 0,
+            sessionsActive: this.sessions.size,
+            sessionsCleaned: 0,
+            avgValidationTime: 0
+        };
+    }
+    /**
+     * Clear all sessions
+     */
+    clear() {
+        this.sessions.clear();
+        this.stats.sessionsActive = 0;
+    }
+    /**
+     * Destroy manager and cleanup
+     */
+    destroy() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+        }
+        this.clear();
+    }
+}
+/**
+ * Token-based authentication helper
+ */
+export class TokenAuth {
+    authManager;
+    validateFn;
+    constructor(authManager, validateFn) {
+        this.authManager = authManager;
+        this.validateFn = validateFn;
+    }
+    /**
+     * Authenticate a request
+     */
+    async authenticate(authHeader) {
+        // Extract token from header
+        const token = this.extractToken(authHeader);
+        if (!token) {
+            return null;
+        }
+        return this.authManager.authenticate(token, this.validateFn);
+    }
+    /**
+     * Extract token from Authorization header
+     */
+    extractToken(authHeader) {
+        if (!authHeader) {
+            return null;
+        }
+        // Support "Bearer <token>" and raw token
+        if (authHeader.startsWith('Bearer ')) {
+            return authHeader.substring(7);
+        }
+        return authHeader;
+    }
+    /**
+     * Invalidate token
+     */
+    invalidate(token) {
+        return this.authManager.invalidate(token);
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        return this.authManager.getStats();
+    }
+}
+/**
+ * Calculate auth overhead reduction
+ */
+export function calculateAuthSavings(stats) {
+    const hitRate = stats.cacheHits / (stats.cacheHits + stats.cacheMisses);
+    const savingsPercentage = hitRate * 100;
+    const avgSavedTime = stats.avgValidationTime * hitRate;
+    const totalSavedTime = stats.avgValidationTime * stats.cacheHits;
+    return {
+        savingsPercentage,
+        avgSavedTime,
+        totalSavedTime
+    };
+}

package/dist/utils/model-cache.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Global Model Cache
+ *
+ * Caches loaded models in memory to avoid repeated initialization overhead.
+ * Supports ONNX embeddings, transformers.js pipelines, and other heavy models.
+ */
+interface CacheStats {
+    models: number;
+    totalSize: number;
+    size?: number;
+    totalHits: number;
+    totalMisses: number;
+    hits: number;
+    misses: number;
+    hitRate: number;
+}
+declare class ModelCache {
+    private cache;
+    private maxSize;
+    private totalHits;
+    private totalMisses;
+    constructor(maxSizeMB?: number);
+    /**
+     * Get a cached model or load it
+     */
+    getOrLoad<T>(key: string, loader: () => Promise<T>, sizeEstimate?: number): Promise<T>;
+    /**
+     * Check if model is cached
+     */
+    has(key: string): boolean;
+    /**
+     * Get cached model without loading
+     */
+    get<T>(key: string): T | undefined;
+    /**
+     * Manually cache a model
+     */
+    set(key: string, model: any, sizeEstimate?: number): void;
+    /**
+     * Remove a model from cache
+     */
+    delete(key: string): boolean;
+    /**
+     * Clear all cached models
+     */
+    clear(): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): CacheStats;
+    /**
+     * Evict least recently used models if cache is full
+     */
+    private evictIfNeeded;
+}
+export declare const modelCache: ModelCache;
+export declare function getCachedOnnxEmbedder(): Promise<any>;
+export declare function getCachedTransformersPipeline(task?: string, model?: string): Promise<any>;
+export declare function getCachedRuvectorCore(): Promise<any>;
+export {};
+//# sourceMappingURL=model-cache.d.ts.map

package/dist/utils/model-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-cache.d.ts","sourceRoot":"","sources":["../../src/utils/model-cache.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAUH,UAAU,UAAU;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,cAAM,UAAU;IACd,OAAO,CAAC,KAAK,CAAkC;IAC/C,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,WAAW,CAAK;gBAEZ,SAAS,GAAE,MAAY;IAInC;;OAEG;IACG,SAAS,CAAC,CAAC,EACf,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACxB,YAAY,GAAE,MAAyB,GACtC,OAAO,CAAC,CAAC,CAAC;IA4Bb;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB;;OAEG;IACH,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAUlC;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,YAAY,GAAE,MAAyB,GAAG,IAAI;IAW3E;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAI5B;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,QAAQ,IAAI,UAAU;IAoBtB;;OAEG;IACH,OAAO,CAAC,aAAa;CAuBtB;AAGD,eAAO,MAAM,UAAU,YAAmB,CAAC;AAG3C,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,GAAG,CAAC,CAgC1D;AAED,wBAAsB,6BAA6B,CACjD,IAAI,GAAE,MAA6B,EACnC,KAAK,GAAE,MAAkC,GACxC,OAAO,CAAC,GAAG,CAAC,CASd;AAED,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,GAAG,CAAC,CAS1D"}

package/dist/utils/model-cache.js

@@ -0,0 +1,176 @@
+/**
+ * Global Model Cache
+ *
+ * Caches loaded models in memory to avoid repeated initialization overhead.
+ * Supports ONNX embeddings, transformers.js pipelines, and other heavy models.
+ */
+class ModelCache {
+    cache = new Map();
+    maxSize; // Max cache size in bytes
+    totalHits = 0;
+    totalMisses = 0;
+    constructor(maxSizeMB = 512) {
+        this.maxSize = maxSizeMB * 1024 * 1024;
+    }
+    /**
+     * Get a cached model or load it
+     */
+    async getOrLoad(key, loader, sizeEstimate = 50 * 1024 * 1024 // Default 50MB estimate
+    ) {
+        const cached = this.cache.get(key);
+        if (cached) {
+            cached.lastUsed = Date.now();
+            cached.useCount++;
+            this.totalHits++;
+            return cached.model;
+        }
+        this.totalMisses++;
+        // Evict if needed
+        this.evictIfNeeded(sizeEstimate);
+        // Load model
+        const model = await loader();
+        this.cache.set(key, {
+            model,
+            loadedAt: Date.now(),
+            lastUsed: Date.now(),
+            useCount: 1,
+            sizeEstimate
+        });
+        return model;
+    }
+    /**
+     * Check if model is cached
+     */
+    has(key) {
+        return this.cache.has(key);
+    }
+    /**
+     * Get cached model without loading
+     */
+    get(key) {
+        const cached = this.cache.get(key);
+        if (cached) {
+            cached.lastUsed = Date.now();
+            cached.useCount++;
+            return cached.model;
+        }
+        return undefined;
+    }
+    /**
+     * Manually cache a model
+     */
+    set(key, model, sizeEstimate = 50 * 1024 * 1024) {
+        this.evictIfNeeded(sizeEstimate);
+        this.cache.set(key, {
+            model,
+            loadedAt: Date.now(),
+            lastUsed: Date.now(),
+            useCount: 1,
+            sizeEstimate
+        });
+    }
+    /**
+     * Remove a model from cache
+     */
+    delete(key) {
+        return this.cache.delete(key);
+    }
+    /**
+     * Clear all cached models
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        let totalSize = 0;
+        for (const cached of this.cache.values()) {
+            totalSize += cached.sizeEstimate;
+        }
+        const hits = this.totalHits;
+        const misses = this.totalMisses;
+        const total = hits + misses;
+        return {
+            models: this.cache.size,
+            totalSize,
+            size: this.cache.size,
+            totalHits: hits,
+            totalMisses: misses,
+            hits,
+            misses,
+            hitRate: total > 0 ? hits / total : 0
+        };
+    }
+    /**
+     * Evict least recently used models if cache is full
+     */
+    evictIfNeeded(newSize) {
+        let currentSize = 0;
+        for (const cached of this.cache.values()) {
+            currentSize += cached.sizeEstimate;
+        }
+        if (currentSize + newSize <= this.maxSize) {
+            return;
+        }
+        // Sort by last used time (LRU)
+        const entries = Array.from(this.cache.entries())
+            .sort((a, b) => a[1].lastUsed - b[1].lastUsed);
+        // Evict until we have space
+        for (const [key, cached] of entries) {
+            if (currentSize + newSize <= this.maxSize) {
+                break;
+            }
+            this.cache.delete(key);
+            currentSize -= cached.sizeEstimate;
+        }
+    }
+}
+// Global singleton
+export const modelCache = new ModelCache();
+// Convenience functions
+export async function getCachedOnnxEmbedder() {
+    return modelCache.getOrLoad('onnx-embeddings', async () => {
+        // Suppress experimental warning for WASM
+        const originalEmit = process.emit;
+        // @ts-ignore
+        process.emit = function (name, data, ...args) {
+            if (name === 'warning' && typeof data === 'object' &&
+                data.name === 'ExperimentalWarning' &&
+                data.message?.includes('Import')) {
+                return false;
+            }
+            // @ts-ignore
+            return originalEmit.apply(process, [name, data, ...args]);
+        };
+        try {
+            const onnxModule = await import('ruvector-onnx-embeddings-wasm');
+            const EmbedderClass = onnxModule.OnnxEmbeddings || onnxModule.default;
+            if (EmbedderClass) {
+                const embedder = new EmbedderClass();
+                await embedder.initialize?.();
+                return embedder;
+            }
+        }
+        finally {
+            process.emit = originalEmit;
+        }
+        return null;
+    }, 100 * 1024 * 1024 // 100MB estimate for ONNX model
+    );
+}
+export async function getCachedTransformersPipeline(task = 'feature-extraction', model = 'Xenova/all-MiniLM-L6-v2') {
+    return modelCache.getOrLoad(`transformers:${task}:${model}`, async () => {
+        const { pipeline } = await import('@xenova/transformers');
+        return pipeline(task, model);
+    }, 200 * 1024 * 1024 // 200MB estimate for transformers model
+    );
+}
+export async function getCachedRuvectorCore() {
+    return modelCache.getOrLoad('ruvector-core', async () => {
+        const ruvector = await import('ruvector');
+        return ruvector;
+    }, 50 * 1024 * 1024);
+}
+//# sourceMappingURL=model-cache.js.map

package/dist/utils/model-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-cache.js","sourceRoot":"","sources":["../../src/utils/model-cache.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Global Model Cache\n *\n * Caches loaded models in memory to avoid repeated initialization overhead.\n * Supports ONNX embeddings, transformers.js pipelines, and other heavy models.\n */\n\ninterface CachedModel {\n  model: any;\n  loadedAt: number;\n  lastUsed: number;\n  useCount: number;\n  sizeEstimate: number; // bytes\n}\n\ninterface CacheStats {\n  models: number;\n  totalSize: number;\n  size?: number;\n  totalHits: number;\n  totalMisses: number;\n  hits: number;\n  misses: number;\n  hitRate: number;\n}\n\nclass ModelCache {\n  private cache = new Map<string, CachedModel>();\n  private maxSize: number; // Max cache size in bytes\n  private totalHits = 0;\n  private totalMisses = 0;\n\n  constructor(maxSizeMB: number = 512) {\n    this.maxSize = maxSizeMB * 1024 * 1024;\n  }\n\n  /**\n   * Get a cached model or load it\n   */\n  async getOrLoad<T>(\n    key: string,\n    loader: () => Promise<T>,\n    sizeEstimate: number = 50 * 1024 * 1024 // Default 50MB estimate\n  ): Promise<T> {\n    const cached = this.cache.get(key);\n    if (cached) {\n      cached.lastUsed = Date.now();\n      cached.useCount++;\n      this.totalHits++;\n      return cached.model as T;\n    }\n\n    this.totalMisses++;\n\n    // Evict if needed\n    this.evictIfNeeded(sizeEstimate);\n\n    // Load model\n    const model = await loader();\n\n    this.cache.set(key, {\n      model,\n      loadedAt: Date.now(),\n      lastUsed: Date.now(),\n      useCount: 1,\n      sizeEstimate\n    });\n\n    return model;\n  }\n\n  /**\n   * Check if model is cached\n   */\n  has(key: string): boolean {\n    return this.cache.has(key);\n  }\n\n  /**\n   * Get cached model without loading\n   */\n  get<T>(key: string): T | undefined {\n    const cached = this.cache.get(key);\n    if (cached) {\n      cached.lastUsed = Date.now();\n      cached.useCount++;\n      return cached.model as T;\n    }\n    return undefined;\n  }\n\n  /**\n   * Manually cache a model\n   */\n  set(key: string, model: any, sizeEstimate: number = 50 * 1024 * 1024): void {\n    this.evictIfNeeded(sizeEstimate);\n    this.cache.set(key, {\n      model,\n      loadedAt: Date.now(),\n      lastUsed: Date.now(),\n      useCount: 1,\n      sizeEstimate\n    });\n  }\n\n  /**\n   * Remove a model from cache\n   */\n  delete(key: string): boolean {\n    return this.cache.delete(key);\n  }\n\n  /**\n   * Clear all cached models\n   */\n  clear(): void {\n    this.cache.clear();\n  }\n\n  /**\n   * Get cache statistics\n   */\n  getStats(): CacheStats {\n    let totalSize = 0;\n    for (const cached of this.cache.values()) {\n      totalSize += cached.sizeEstimate;\n    }\n    const hits = this.totalHits;\n    const misses = this.totalMisses;\n    const total = hits + misses;\n    return {\n      models: this.cache.size,\n      totalSize,\n      size: this.cache.size,\n      totalHits: hits,\n      totalMisses: misses,\n      hits,\n      misses,\n      hitRate: total > 0 ? hits / total : 0\n    };\n  }\n\n  /**\n   * Evict least recently used models if cache is full\n   */\n  private evictIfNeeded(newSize: number): void {\n    let currentSize = 0;\n    for (const cached of this.cache.values()) {\n      currentSize += cached.sizeEstimate;\n    }\n\n    if (currentSize + newSize <= this.maxSize) {\n      return;\n    }\n\n    // Sort by last used time (LRU)\n    const entries = Array.from(this.cache.entries())\n      .sort((a, b) => a[1].lastUsed - b[1].lastUsed);\n\n    // Evict until we have space\n    for (const [key, cached] of entries) {\n      if (currentSize + newSize <= this.maxSize) {\n        break;\n      }\n      this.cache.delete(key);\n      currentSize -= cached.sizeEstimate;\n    }\n  }\n}\n\n// Global singleton\nexport const modelCache = new ModelCache();\n\n// Convenience functions\nexport async function getCachedOnnxEmbedder(): Promise<any> {\n  return modelCache.getOrLoad(\n    'onnx-embeddings',\n    async () => {\n      // Suppress experimental warning for WASM\n      const originalEmit = process.emit;\n      // @ts-ignore\n      process.emit = function (name, data, ...args) {\n        if (name === 'warning' && typeof data === 'object' &&\n            (data as any).name === 'ExperimentalWarning' &&\n            (data as any).message?.includes('Import')) {\n          return false;\n        }\n        // @ts-ignore\n        return originalEmit.apply(process, [name, data, ...args]);\n      };\n\n      try {\n        const onnxModule = await import('ruvector-onnx-embeddings-wasm') as any;\n        const EmbedderClass = onnxModule.OnnxEmbeddings || onnxModule.default;\n        if (EmbedderClass) {\n          const embedder = new EmbedderClass();\n          await embedder.initialize?.();\n          return embedder;\n        }\n      } finally {\n        process.emit = originalEmit;\n      }\n      return null;\n    },\n    100 * 1024 * 1024 // 100MB estimate for ONNX model\n  );\n}\n\nexport async function getCachedTransformersPipeline(\n  task: string = 'feature-extraction',\n  model: string = 'Xenova/all-MiniLM-L6-v2'\n): Promise<any> {\n  return modelCache.getOrLoad(\n    `transformers:${task}:${model}`,\n    async () => {\n      const { pipeline } = await import('@xenova/transformers');\n      return pipeline(task as any, model);\n    },\n    200 * 1024 * 1024 // 200MB estimate for transformers model\n  );\n}\n\nexport async function getCachedRuvectorCore(): Promise<any> {\n  return modelCache.getOrLoad(\n    'ruvector-core',\n    async () => {\n      const ruvector = await import('ruvector');\n      return ruvector;\n    },\n    50 * 1024 * 1024\n  );\n}\n"]}