agentic-flow 2.0.1 → 2.0.2-alpha

package/dist/core/embedding-service.d.ts

@@ -1,117 +0,0 @@
-/**
- * Production Embedding Service
- *
- * Replaces mock embeddings with real implementations:
- * 1. OpenAI Embeddings API (text-embedding-3-small/large)
- * 2. Local Transformers.js (runs in Node.js/browser)
- * 3. Custom ONNX models
- * 4. Fallback hash-based embeddings (for development)
- */
-import { EventEmitter } from 'events';
-export interface EmbeddingConfig {
-    provider: 'openai' | 'transformers' | 'onnx' | 'mock';
-    model?: string;
-    dimensions?: number;
-    apiKey?: string;
-    cacheSize?: number;
-}
-export interface EmbeddingResult {
-    embedding: number[];
-    usage?: {
-        promptTokens: number;
-        totalTokens: number;
-    };
-    latency: number;
-}
-/**
- * Base embedding service interface
- */
-export declare abstract class EmbeddingService extends EventEmitter {
-    protected config: EmbeddingConfig;
-    protected cache: Map<string, number[]>;
-    constructor(config: EmbeddingConfig);
-    abstract embed(text: string): Promise<EmbeddingResult>;
-    abstract embedBatch(texts: string[]): Promise<EmbeddingResult[]>;
-    /**
-     * Get cached embedding if available
-     */
-    protected getCached(text: string): number[] | null;
-    /**
-     * Cache embedding with LRU eviction
-     */
-    protected setCached(text: string, embedding: number[]): void;
-    /**
-     * Clear cache
-     */
-    clearCache(): void;
-}
-/**
- * OpenAI Embeddings Service
- *
- * Uses OpenAI's text-embedding-3-small (1536D) or text-embedding-3-large (3072D)
- * https://platform.openai.com/docs/guides/embeddings
- */
-export declare class OpenAIEmbeddingService extends EmbeddingService {
-    private apiKey;
-    private model;
-    private baseURL;
-    constructor(config: Omit<EmbeddingConfig, 'provider'> & {
-        apiKey: string;
-    });
-    embed(text: string): Promise<EmbeddingResult>;
-    embedBatch(texts: string[]): Promise<EmbeddingResult[]>;
-}
-/**
- * Transformers.js Local Embedding Service
- *
- * Runs locally without API calls using ONNX runtime
- * https://huggingface.co/docs/transformers.js
- */
-export declare class TransformersEmbeddingService extends EmbeddingService {
-    private pipeline;
-    private modelName;
-    constructor(config: Omit<EmbeddingConfig, 'provider'>);
-    initialize(): Promise<void>;
-    embed(text: string): Promise<EmbeddingResult>;
-    embedBatch(texts: string[]): Promise<EmbeddingResult[]>;
-}
-/**
- * Mock Embedding Service (for development/testing)
- *
- * Generates deterministic hash-based embeddings
- * Fast but not semantically meaningful
- */
-export declare class MockEmbeddingService extends EmbeddingService {
-    constructor(config?: Partial<EmbeddingConfig>);
-    embed(text: string): Promise<EmbeddingResult>;
-    embedBatch(texts: string[]): Promise<EmbeddingResult[]>;
-    private hashEmbedding;
-}
-/**
- * Factory function to create appropriate embedding service
- */
-export declare function createEmbeddingService(config: EmbeddingConfig): EmbeddingService;
-/**
- * Convenience function for quick embeddings
- */
-export declare function getEmbedding(text: string, config?: Partial<EmbeddingConfig>): Promise<number[]>;
-/**
- * Benchmark different embedding providers
- */
-export declare function benchmarkEmbeddings(testText?: string): Promise<{
-    mock: {
-        latency: number;
-        dimensions: number;
-    };
-    transformers?: {
-        latency: number;
-        dimensions: number;
-        error?: string;
-    };
-    openai?: {
-        latency: number;
-        dimensions: number;
-        error?: string;
-    };
-}>;
-//# sourceMappingURL=embedding-service.d.ts.map

package/dist/core/gnn-wrapper.d.ts

@@ -1,71 +0,0 @@
-/**
- * GNN Compatibility Wrapper
- *
- * Fixes API issues with @ruvector/gnn by:
- * 1. Auto-converting regular arrays to Float32Array
- * 2. Providing fallback implementations for broken functions
- * 3. Type-safe interface matching documentation
- */
-declare const gnn: any;
-export interface SearchResult {
-    indices: number[];
-    weights: number[];
-}
-export interface CompressionConfig {
-    levelType: 'none' | 'half' | 'pq8' | 'pq4' | 'binary';
-    scale?: number;
-    subvectors?: number;
-    centroids?: number;
-    outlierThreshold?: number;
-    threshold?: number;
-}
-/**
- * Fixed differentiableSearch that accepts regular arrays
- * Automatically converts to Float32Array internally
- */
-export declare function differentiableSearch(query: number[], candidateEmbeddings: number[][], k: number, temperature?: number): SearchResult;
-/**
- * Fallback hierarchicalForward using simple matrix multiplication
- * Since the native implementation is broken
- */
-export declare function hierarchicalForward(input: number[], weights: number[] | number[][], inputDim: number, outputDim: number): number[];
-/**
- * RuvectorLayer wrapper with fallback
- */
-export declare class RuvectorLayer {
-    private inputDim;
-    private outputDim;
-    private weights;
-    private activation;
-    constructor(inputDim: number, outputDim: number, activation?: 'relu' | 'tanh' | 'sigmoid' | 'none');
-    forward(input: number[]): number[];
-    private applyActivation;
-    getWeights(): number[][];
-    setWeights(weights: number[][]): void;
-}
-/**
- * TensorCompress wrapper with working compression levels
- */
-export declare class TensorCompress {
-    private config;
-    constructor(config: string | CompressionConfig);
-    compress(tensor: number[]): number[];
-    decompress(compressed: number[]): number[];
-    getCompressionRatio(): number;
-}
-/**
- * Get compression level configuration
- * Fixed version that returns proper config objects
- */
-export declare function getCompressionLevel(level: string): CompressionConfig;
-/**
- * Check if GNN native module is available and working
- */
-export declare function isGNNAvailable(): boolean;
-/**
- * Initialize GNN module (if needed)
- */
-export declare function initGNN(): void;
-export { gnn as gnnRaw };
-export type { SearchResult as GNNSearchResult };
-//# sourceMappingURL=gnn-wrapper.d.ts.map

package/dist/core/index.d.ts

@@ -1,50 +0,0 @@
-/**
- * Production-Ready Wrappers for Alpha Packages
- *
- * These wrappers provide stable, performant alternatives to broken @ruvector/* alpha APIs.
- * All wrappers have been tested and verified to work correctly.
- *
- * Performance improvements:
- * - GNN wrapper: 11-22x speedup with auto Float32Array conversion
- * - AgentDB Fast: 50-200x faster than CLI (10-50ms vs 2,350ms)
- * - Attention fallbacks: All modules working (native completely broken)
- * - Embedding service: 3 production providers (OpenAI, Transformers.js, Mock)
- *
- * Usage: Import from this module instead of @ruvector/* packages:
- *
- * @example
- * ```typescript
- * // GNN operations
- * import { differentiableSearch, RuvectorLayer } from 'agentdb/wrappers';
- *
- * // AgentDB operations
- * import { createFastAgentDB } from 'agentdb/wrappers';
- *
- * // Attention mechanisms
- * import { MultiHeadAttention, FlashAttention } from 'agentdb/wrappers';
- *
- * // Embeddings
- * import { createEmbeddingService } from 'agentdb/wrappers';
- * ```
- */
-export { differentiableSearch, hierarchicalForward, RuvectorLayer, TensorCompress, getCompressionLevel, type SearchResult, type CompressionConfig, } from './gnn-wrapper.js';
-export { AgentDBFast, createFastAgentDB, type Episode, type Pattern, type EpisodeSearchOptions, } from './agentdb-fast.js';
-export { MultiHeadAttention as NativeMultiHeadAttention, FlashAttention as NativeFlashAttention, LinearAttention as NativeLinearAttention, HyperbolicAttention as NativeHyperbolicAttention, MoEAttention as NativeMoEAttention, scaledDotProductAttention, isNativeAttentionAvailable, createAttention as createNativeAttention, } from './attention-native.js';
-export { MultiHeadAttention as FallbackMultiHeadAttention, FlashAttention as FallbackFlashAttention, LinearAttention as FallbackLinearAttention, HyperbolicAttention as FallbackHyperbolicAttention, MoEAttention as FallbackMoEAttention, type AttentionConfig, } from './attention-fallbacks.js';
-export { MultiHeadAttention, FlashAttention, LinearAttention, HyperbolicAttention, MoEAttention, } from './attention-native.js';
-export { EmbeddingService, OpenAIEmbeddingService, TransformersEmbeddingService, MockEmbeddingService, createEmbeddingService, getEmbedding, benchmarkEmbeddings, type EmbeddingConfig, type EmbeddingResult, } from './embedding-service.js';
-/**
- * Migration helper: Check if native packages should be used
- *
- * Returns false for alpha packages (use wrappers instead)
- */
-export declare function shouldUseNativePackage(packageName: string): boolean;
-/**
- * Get performance comparison for a wrapper
- */
-export declare function getWrapperPerformance(wrapper: string): {
-    speedup: string;
-    latency: string;
-    status: 'verified' | 'fallback' | 'unavailable';
-};
-//# sourceMappingURL=index.d.ts.map

package/dist/core/long-running-agent.d.ts

@@ -1,92 +0,0 @@
-/**
- * Long-Running Agent with Provider Fallback
- *
- * Demonstrates how to use ProviderManager for resilient, cost-optimized agents
- * that can run for hours or days with automatic provider switching.
- */
-import { ProviderConfig, FallbackStrategy } from './provider-manager.js';
-export interface LongRunningAgentConfig {
-    agentName: string;
-    providers: ProviderConfig[];
-    fallbackStrategy?: FallbackStrategy;
-    checkpointInterval?: number;
-    maxRuntime?: number;
-    costBudget?: number;
-    performanceTarget?: number;
-}
-export interface AgentCheckpoint {
-    timestamp: Date;
-    taskProgress: number;
-    currentProvider: string;
-    totalCost: number;
-    totalTokens: number;
-    completedTasks: number;
-    failedTasks: number;
-    state: Record<string, any>;
-}
-export declare class LongRunningAgent {
-    private providerManager;
-    private config;
-    private startTime;
-    private checkpoints;
-    private currentState;
-    private isRunning;
-    private checkpointInterval?;
-    constructor(config: LongRunningAgentConfig);
-    /**
-     * Start the agent with automatic checkpointing
-     */
-    start(): Promise<void>;
-    /**
-     * Execute a task with automatic provider fallback
-     */
-    executeTask<T>(task: {
-        name: string;
-        complexity: 'simple' | 'medium' | 'complex';
-        estimatedTokens?: number;
-        execute: (provider: string) => Promise<T>;
-    }): Promise<T>;
-    /**
-     * Save checkpoint of current state
-     */
-    private saveCheckpoint;
-    /**
-     * Calculate task progress (override in subclass)
-     */
-    protected calculateProgress(): number;
-    /**
-     * Get current status
-     */
-    getStatus(): {
-        isRunning: boolean;
-        runtime: number;
-        completedTasks: number;
-        failedTasks: number;
-        totalCost: number;
-        totalTokens: number;
-        providers: any[];
-        lastCheckpoint?: AgentCheckpoint;
-    };
-    /**
-     * Get detailed metrics
-     */
-    getMetrics(): {
-        providers: import("./provider-manager.js").ProviderMetrics[];
-        health: import("./provider-manager.js").ProviderHealth[];
-        costs: {
-            total: number;
-            byProvider: Record<import("./provider-manager.js").ProviderType, number>;
-            totalTokens: number;
-        };
-        checkpoints: AgentCheckpoint[];
-    };
-    /**
-     * Restore from checkpoint
-     */
-    restoreFromCheckpoint(checkpoint: AgentCheckpoint): void;
-    /**
-     * Stop the agent
-     */
-    stop(): Promise<void>;
-}
-//# sourceMappingURL=long-running-agent.d.ts.map

package/dist/core/provider-manager.d.ts

@@ -1,145 +0,0 @@
-/**
- * Provider Manager - Intelligent LLM Provider Fallback & Dynamic Switching
- *
- * Features:
- * - Automatic failover between providers
- * - Health monitoring and circuit breaking
- * - Cost-based optimization
- * - Performance tracking
- * - Rate limit handling
- * - Provider quality scoring
- */
-export type ProviderType = 'anthropic' | 'gemini' | 'openrouter' | 'onnx';
-export interface ProviderConfig {
-    name: ProviderType;
-    apiKey?: string;
-    baseUrl?: string;
-    priority: number;
-    maxRetries: number;
-    timeout: number;
-    costPerToken: number;
-    enabled: boolean;
-    healthCheckInterval?: number;
-}
-export interface ProviderHealth {
-    provider: ProviderType;
-    isHealthy: boolean;
-    lastChecked: Date;
-    consecutiveFailures: number;
-    averageLatency: number;
-    successRate: number;
-    errorRate: number;
-    circuitBreakerOpen: boolean;
-}
-export interface ProviderMetrics {
-    provider: ProviderType;
-    totalRequests: number;
-    successfulRequests: number;
-    failedRequests: number;
-    totalTokens: number;
-    totalCost: number;
-    averageLatency: number;
-    lastUsed: Date;
-}
-export interface FallbackStrategy {
-    type: 'priority' | 'cost-optimized' | 'performance-optimized' | 'round-robin';
-    maxFailures: number;
-    recoveryTime: number;
-    retryBackoff: 'linear' | 'exponential';
-    costThreshold?: number;
-    latencyThreshold?: number;
-}
-export declare class ProviderManager {
-    private providers;
-    private health;
-    private metrics;
-    private strategy;
-    private currentProvider;
-    private healthCheckIntervals;
-    constructor(providers: ProviderConfig[], strategy?: FallbackStrategy);
-    /**
-     * Initialize provider configurations
-     */
-    private initializeProviders;
-    /**
-     * Start health check monitoring for all providers
-     */
-    private startHealthChecks;
-    /**
-     * Perform health check on a provider
-     */
-    private performHealthCheck;
-    /**
-     * Select the best provider based on strategy
-     */
-    selectProvider(taskComplexity?: 'simple' | 'medium' | 'complex', estimatedTokens?: number): Promise<ProviderType>;
-    /**
-     * Get list of healthy, available providers
-     */
-    private getAvailableProviders;
-    /**
-     * Select provider by priority
-     */
-    private selectByPriority;
-    /**
-     * Select provider by cost optimization
-     */
-    private selectByCost;
-    /**
-     * Select provider by performance (latency + success rate)
-     */
-    private selectByPerformance;
-    /**
-     * Select provider using round-robin
-     */
-    private selectRoundRobin;
-    /**
-     * Execute request with automatic fallback
-     */
-    executeWithFallback<T>(requestFn: (provider: ProviderType) => Promise<T>, taskComplexity?: 'simple' | 'medium' | 'complex', estimatedTokens?: number): Promise<{
-        result: T;
-        provider: ProviderType;
-        attempts: number;
-    }>;
-    /**
-     * Execute request with retry logic
-     */
-    private executeWithRetry;
-    /**
-     * Calculate backoff delay
-     */
-    private calculateBackoffDelay;
-    /**
-     * Check if error is retryable
-     */
-    private isRetryableError;
-    /**
-     * Record successful request
-     */
-    private recordSuccess;
-    /**
-     * Record failed request
-     */
-    private recordFailure;
-    /**
-     * Get current metrics for all providers
-     */
-    getMetrics(): ProviderMetrics[];
-    /**
-     * Get health status for all providers
-     */
-    getHealth(): ProviderHealth[];
-    /**
-     * Get cost summary
-     */
-    getCostSummary(): {
-        total: number;
-        byProvider: Record<ProviderType, number>;
-        totalTokens: number;
-    };
-    /**
-     * Cleanup and stop health checks
-     */
-    destroy(): void;
-}
-//# sourceMappingURL=provider-manager.d.ts.map

package/dist/embeddings/index.d.ts

@@ -1,17 +0,0 @@
-/**
- * Embeddings Module
- *
- * Optimized embedding generation for agentic-flow with:
- * - ONNX model download and caching
- * - LRU embedding cache (256 entries)
- * - SIMD-friendly vector operations
- * - Multiple model support
- * - Neural Embedding Substrate (synthetic nervous system)
- */
-export * from './optimized-embedder.js';
-export * from './neural-substrate.js';
-export { OptimizedEmbedder, getOptimizedEmbedder, downloadModel, listAvailableModels, initEmbeddings, cosineSimilarity, euclideanDistance, normalizeVector, DEFAULT_CONFIG } from './optimized-embedder.js';
-export { NeuralSubstrate, getNeuralSubstrate, SemanticDriftDetector, MemoryPhysics, EmbeddingStateMachine, SwarmCoordinator, CoherenceMonitor } from './neural-substrate.js';
-export type { EmbedderConfig, DownloadProgress } from './optimized-embedder.js';
-export type { DriftResult, MemoryEntry, AgentState, CoherenceResult, SubstrateHealth } from './neural-substrate.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/embeddings/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/embeddings/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AAGtC,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EACpB,aAAa,EACb,mBAAmB,EACnB,cAAc,EACd,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,cAAc,EACf,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,qBAAqB,EACrB,aAAa,EACb,qBAAqB,EACrB,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,uBAAuB,CAAC;AAG/B,YAAY,EACV,cAAc,EACd,gBAAgB,EACjB,MAAM,yBAAyB,CAAC;AAEjC,YAAY,EACV,WAAW,EACX,WAAW,EACX,UAAU,EACV,eAAe,EACf,eAAe,EAChB,MAAM,uBAAuB,CAAC"}

package/dist/embeddings/index.js

@@ -1,17 +0,0 @@
-/**
- * Embeddings Module
- *
- * Optimized embedding generation for agentic-flow with:
- * - ONNX model download and caching
- * - LRU embedding cache (256 entries)
- * - SIMD-friendly vector operations
- * - Multiple model support
- * - Neural Embedding Substrate (synthetic nervous system)
- */
-export * from './optimized-embedder.js';
-export * from './neural-substrate.js';
-// Re-export key functions
-export { OptimizedEmbedder, getOptimizedEmbedder, downloadModel, listAvailableModels, initEmbeddings, cosineSimilarity, euclideanDistance, normalizeVector, DEFAULT_CONFIG } from './optimized-embedder.js';
-// Re-export Neural Substrate
-export { NeuralSubstrate, getNeuralSubstrate, SemanticDriftDetector, MemoryPhysics, EmbeddingStateMachine, SwarmCoordinator, CoherenceMonitor } from './neural-substrate.js';
-//# sourceMappingURL=index.js.map

package/dist/embeddings/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/embeddings/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AAEtC,0BAA0B;AAC1B,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EACpB,aAAa,EACb,mBAAmB,EACnB,cAAc,EACd,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,cAAc,EACf,MAAM,yBAAyB,CAAC;AAEjC,6BAA6B;AAC7B,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,qBAAqB,EACrB,aAAa,EACb,qBAAqB,EACrB,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,uBAAuB,CAAC","sourcesContent":["/**\n * Embeddings Module\n *\n * Optimized embedding generation for agentic-flow with:\n * - ONNX model download and caching\n * - LRU embedding cache (256 entries)\n * - SIMD-friendly vector operations\n * - Multiple model support\n * - Neural Embedding Substrate (synthetic nervous system)\n */\n\nexport * from './optimized-embedder.js';\nexport * from './neural-substrate.js';\n\n// Re-export key functions\nexport {\n  OptimizedEmbedder,\n  getOptimizedEmbedder,\n  downloadModel,\n  listAvailableModels,\n  initEmbeddings,\n  cosineSimilarity,\n  euclideanDistance,\n  normalizeVector,\n  DEFAULT_CONFIG\n} from './optimized-embedder.js';\n\n// Re-export Neural Substrate\nexport {\n  NeuralSubstrate,\n  getNeuralSubstrate,\n  SemanticDriftDetector,\n  MemoryPhysics,\n  EmbeddingStateMachine,\n  SwarmCoordinator,\n  CoherenceMonitor\n} from './neural-substrate.js';\n\n// Re-export types\nexport type {\n  EmbedderConfig,\n  DownloadProgress\n} from './optimized-embedder.js';\n\nexport type {\n  DriftResult,\n  MemoryEntry,\n  AgentState,\n  CoherenceResult,\n  SubstrateHealth\n} from './neural-substrate.js';\n"]}