agentic-flow 2.0.1-alpha.9 → 2.0.2-alpha

package/dist/core/attention-native.js

@@ -1,273 +0,0 @@
-/**
- * Native Attention Wrappers
- *
- * Properly wraps @ruvector/attention native Rust implementations
- * with TypedArray conversions and proper error handling
- */
-import * as nativeAttention from '@ruvector/attention';
-/**
- * Convert regular array to Float32Array if needed
- */
-function toFloat32Array(input) {
-    if (input instanceof Float32Array) {
-        return input;
-    }
-    return new Float32Array(input);
-}
-/**
- * Convert Float32Array to regular array for JS compatibility
- */
-function toArray(input) {
-    return Array.from(input);
-}
-/**
- * Native Multi-Head Attention (uses Rust implementation)
- *
- * This wrapper properly converts between JavaScript arrays and TypedArrays
- * required by the native Rust implementation.
- */
-export class MultiHeadAttention {
-    nativeInstance;
-    hiddenDim;
-    numHeads;
-    constructor(config) {
-        this.hiddenDim = config.hiddenDim;
-        this.numHeads = config.numHeads || 8;
-        try {
-            // Create native Rust instance
-            this.nativeInstance = new nativeAttention.MultiHeadAttention(this.hiddenDim, this.numHeads);
-        }
-        catch (error) {
-            throw new Error(`Failed to initialize native MultiHeadAttention: ${error.message}`);
-        }
-    }
-    /**
-     * Forward pass using native Rust implementation
-     */
-    forward(query, key, value, mask) {
-        try {
-            // Convert to Float32Array for native code
-            const q = toFloat32Array(query);
-            const k = toFloat32Array(key);
-            const v = toFloat32Array(value);
-            const m = mask ? toFloat32Array(mask) : undefined;
-            // Call native compute method
-            const result = this.nativeInstance.compute(q, k, v, m);
-            // Convert result back to regular arrays
-            return {
-                output: toArray(result),
-                attentionWeights: [[]] // Native doesn't return weights separately
-            };
-        }
-        catch (error) {
-            throw new Error(`MultiHeadAttention forward failed: ${error.message}`);
-        }
-    }
-    /**
-     * Get dimensions
-     */
-    get dim() {
-        return this.nativeInstance.dim;
-    }
-    get headDim() {
-        return this.nativeInstance.headDim;
-    }
-}
-/**
- * Native Flash Attention (uses Rust implementation)
- *
- * Memory-efficient attention with tiling/chunking
- */
-export class FlashAttention {
-    nativeInstance;
-    hiddenDim;
-    constructor(config) {
-        this.hiddenDim = config.hiddenDim;
-        try {
-            this.nativeInstance = new nativeAttention.FlashAttention(this.hiddenDim);
-        }
-        catch (error) {
-            throw new Error(`Failed to initialize native FlashAttention: ${error.message}`);
-        }
-    }
-    /**
-     * Forward pass with batch support
-     */
-    forward(query, key, value, numHeads = 8) {
-        try {
-            // Convert batch to Float32Array
-            const q = query.map(toFloat32Array);
-            const k = key.map(toFloat32Array);
-            const v = value.map(toFloat32Array);
-            // Call native compute
-            const result = this.nativeInstance.compute(q, k, v, numHeads);
-            // Convert result back
-            return {
-                output: result.map((r) => toArray(r)),
-                attentionScores: [[]]
-            };
-        }
-        catch (error) {
-            throw new Error(`FlashAttention forward failed: ${error.message}`);
-        }
-    }
-}
-/**
- * Native Linear Attention (uses Rust implementation)
- *
- * O(n) complexity approximation of attention
- */
-export class LinearAttention {
-    nativeInstance;
-    hiddenDim;
-    constructor(config) {
-        this.hiddenDim = config.hiddenDim;
-        try {
-            // LinearAttention constructor: (hiddenDim, seqLen)
-            // We'll use hiddenDim for both since seqLen varies per forward call
-            this.nativeInstance = new nativeAttention.LinearAttention(this.hiddenDim, this.hiddenDim);
-        }
-        catch (error) {
-            throw new Error(`Failed to initialize native LinearAttention: ${error.message}`);
-        }
-    }
-    forward(query, key, value) {
-        try {
-            const q = query.map(toFloat32Array);
-            const k = key.map(toFloat32Array);
-            const v = value.map(toFloat32Array);
-            const result = this.nativeInstance.compute(q, k, v);
-            return {
-                output: result.map((r) => toArray(r))
-            };
-        }
-        catch (error) {
-            throw new Error(`LinearAttention forward failed: ${error.message}`);
-        }
-    }
-}
-/**
- * Native Hyperbolic Attention (uses Rust implementation)
- */
-export class HyperbolicAttention {
-    nativeInstance;
-    hiddenDim;
-    constructor(config) {
-        this.hiddenDim = config.hiddenDim;
-        try {
-            this.nativeInstance = new nativeAttention.HyperbolicAttention(this.hiddenDim);
-        }
-        catch (error) {
-            throw new Error(`Failed to initialize native HyperbolicAttention: ${error.message}`);
-        }
-    }
-    forward(query, key, value) {
-        try {
-            const q = toFloat32Array(query);
-            const k = toFloat32Array(key);
-            const v = toFloat32Array(value);
-            const result = this.nativeInstance.compute(q, k, v);
-            return {
-                output: toArray(result.output),
-                distance: result.distance
-            };
-        }
-        catch (error) {
-            throw new Error(`HyperbolicAttention forward failed: ${error.message}`);
-        }
-    }
-}
-/**
- * Native MoE Attention (uses Rust implementation)
- *
- * Mixture of Experts with top-k routing
- */
-export class MoEAttention {
-    nativeInstance;
-    hiddenDim;
-    numExperts;
-    constructor(config) {
-        this.hiddenDim = config.hiddenDim;
-        this.numExperts = config.numExperts || 4;
-        try {
-            // MoEAttention expects a MoEConfig object
-            this.nativeInstance = new nativeAttention.MoEAttention({
-                dim: this.hiddenDim,
-                numExperts: this.numExperts,
-                topK: config.topK || 2
-            });
-        }
-        catch (error) {
-            throw new Error(`Failed to initialize native MoEAttention: ${error.message}`);
-        }
-    }
-    forward(query, key, value, topK = 2) {
-        try {
-            const q = toFloat32Array(query);
-            const k = toFloat32Array(key);
-            const v = toFloat32Array(value);
-            const result = this.nativeInstance.compute(q, k, v, topK);
-            return {
-                output: toArray(result.output),
-                expertWeights: toArray(result.expertWeights)
-            };
-        }
-        catch (error) {
-            throw new Error(`MoEAttention forward failed: ${error.message}`);
-        }
-    }
-}
-/**
- * Scaled Dot-Product Attention (pure JavaScript, always works)
- */
-export function scaledDotProductAttention(query, key, value, mask) {
-    const dk = query.length;
-    // Compute attention scores: Q · K^T / sqrt(dk)
-    let score = 0;
-    for (let i = 0; i < dk; i++) {
-        score += query[i] * key[i];
-    }
-    score /= Math.sqrt(dk);
-    // Apply mask if provided
-    if (mask && mask[0] === 0) {
-        score = -Infinity;
-    }
-    // Softmax (single score version)
-    const expScore = Math.exp(score);
-    const weight = expScore;
-    // Weighted value
-    const output = value.map(v => v * weight);
-    return { output, weights: [weight] };
-}
-/**
- * Check if native attention is available
- */
-export function isNativeAttentionAvailable() {
-    try {
-        const test = new nativeAttention.MultiHeadAttention(128, 4);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Factory function to create appropriate attention module
- */
-export function createAttention(type, config) {
-    switch (type) {
-        case 'multi-head':
-            return new MultiHeadAttention(config);
-        case 'flash':
-            return new FlashAttention(config);
-        case 'linear':
-            return new LinearAttention(config);
-        case 'hyperbolic':
-            return new HyperbolicAttention(config);
-        case 'moe':
-            return new MoEAttention(config);
-        default:
-            return new MultiHeadAttention(config);
-    }
-}
-//# sourceMappingURL=attention-native.js.map

package/dist/core/attention-native.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"attention-native.js","sourceRoot":"","sources":["../../src/core/attention-native.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Native Attention Wrappers\n *\n * Properly wraps @ruvector/attention native Rust implementations\n * with TypedArray conversions and proper error handling\n */\n\nimport * as nativeAttention from '@ruvector/attention';\n\nexport interface AttentionConfig {\n  hiddenDim: number;\n  numHeads?: number;\n  dropoutRate?: number;\n  useFlash?: boolean;\n}\n\n/**\n * Convert regular array to Float32Array if needed\n */\nfunction toFloat32Array(input: number[] | Float32Array): Float32Array {\n  if (input instanceof Float32Array) {\n    return input;\n  }\n  return new Float32Array(input);\n}\n\n/**\n * Convert Float32Array to regular array for JS compatibility\n */\nfunction toArray(input: Float32Array): number[] {\n  return Array.from(input);\n}\n\n/**\n * Native Multi-Head Attention (uses Rust implementation)\n *\n * This wrapper properly converts between JavaScript arrays and TypedArrays\n * required by the native Rust implementation.\n */\nexport class MultiHeadAttention {\n  private nativeInstance: any;\n  private hiddenDim: number;\n  private numHeads: number;\n\n  constructor(config: AttentionConfig) {\n    this.hiddenDim = config.hiddenDim;\n    this.numHeads = config.numHeads || 8;\n\n    try {\n      // Create native Rust instance\n      this.nativeInstance = new nativeAttention.MultiHeadAttention(\n        this.hiddenDim,\n        this.numHeads\n      );\n    } catch (error: any) {\n      throw new Error(`Failed to initialize native MultiHeadAttention: ${error.message}`);\n    }\n  }\n\n  /**\n   * Forward pass using native Rust implementation\n   */\n  forward(\n    query: number[] | Float32Array,\n    key: number[] | Float32Array,\n    value: number[] | Float32Array,\n    mask?: number[] | Float32Array\n  ): { output: number[]; attentionWeights: number[][] } {\n    try {\n      // Convert to Float32Array for native code\n      const q = toFloat32Array(query);\n      const k = toFloat32Array(key);\n      const v = toFloat32Array(value);\n      const m = mask ? toFloat32Array(mask) : undefined;\n\n      // Call native compute method\n      const result = this.nativeInstance.compute(q, k, v, m);\n\n      // Convert result back to regular arrays\n      return {\n        output: toArray(result),\n        attentionWeights: [[]] // Native doesn't return weights separately\n      };\n    } catch (error: any) {\n      throw new Error(`MultiHeadAttention forward failed: ${error.message}`);\n    }\n  }\n\n  /**\n   * Get dimensions\n   */\n  get dim(): number {\n    return this.nativeInstance.dim;\n  }\n\n  get headDim(): number {\n    return this.nativeInstance.headDim;\n  }\n}\n\n/**\n * Native Flash Attention (uses Rust implementation)\n *\n * Memory-efficient attention with tiling/chunking\n */\nexport class FlashAttention {\n  private nativeInstance: any;\n  private hiddenDim: number;\n\n  constructor(config: AttentionConfig) {\n    this.hiddenDim = config.hiddenDim;\n\n    try {\n      this.nativeInstance = new nativeAttention.FlashAttention(this.hiddenDim);\n    } catch (error: any) {\n      throw new Error(`Failed to initialize native FlashAttention: ${error.message}`);\n    }\n  }\n\n  /**\n   * Forward pass with batch support\n   */\n  forward(\n    query: number[][] | Float32Array[],\n    key: number[][] | Float32Array[],\n    value: number[][] | Float32Array[],\n    numHeads: number = 8\n  ): { output: number[][]; attentionScores: number[][] } {\n    try {\n      // Convert batch to Float32Array\n      const q = query.map(toFloat32Array);\n      const k = key.map(toFloat32Array);\n      const v = value.map(toFloat32Array);\n\n      // Call native compute\n      const result = this.nativeInstance.compute(q, k, v, numHeads);\n\n      // Convert result back\n      return {\n        output: result.map((r: Float32Array) => toArray(r)),\n        attentionScores: [[]]\n      };\n    } catch (error: any) {\n      throw new Error(`FlashAttention forward failed: ${error.message}`);\n    }\n  }\n}\n\n/**\n * Native Linear Attention (uses Rust implementation)\n *\n * O(n) complexity approximation of attention\n */\nexport class LinearAttention {\n  private nativeInstance: any;\n  private hiddenDim: number;\n\n  constructor(config: AttentionConfig) {\n    this.hiddenDim = config.hiddenDim;\n\n    try {\n      // LinearAttention constructor: (hiddenDim, seqLen)\n      // We'll use hiddenDim for both since seqLen varies per forward call\n      this.nativeInstance = new nativeAttention.LinearAttention(\n        this.hiddenDim,\n        this.hiddenDim\n      );\n    } catch (error: any) {\n      throw new Error(`Failed to initialize native LinearAttention: ${error.message}`);\n    }\n  }\n\n  forward(\n    query: number[][] | Float32Array[],\n    key: number[][] | Float32Array[],\n    value: number[][] | Float32Array[]\n  ): { output: number[][] } {\n    try {\n      const q = query.map(toFloat32Array);\n      const k = key.map(toFloat32Array);\n      const v = value.map(toFloat32Array);\n\n      const result = this.nativeInstance.compute(q, k, v);\n\n      return {\n        output: result.map((r: Float32Array) => toArray(r))\n      };\n    } catch (error: any) {\n      throw new Error(`LinearAttention forward failed: ${error.message}`);\n    }\n  }\n}\n\n/**\n * Native Hyperbolic Attention (uses Rust implementation)\n */\nexport class HyperbolicAttention {\n  private nativeInstance: any;\n  private hiddenDim: number;\n\n  constructor(config: AttentionConfig) {\n    this.hiddenDim = config.hiddenDim;\n\n    try {\n      this.nativeInstance = new nativeAttention.HyperbolicAttention(this.hiddenDim);\n    } catch (error: any) {\n      throw new Error(`Failed to initialize native HyperbolicAttention: ${error.message}`);\n    }\n  }\n\n  forward(\n    query: number[] | Float32Array,\n    key: number[] | Float32Array,\n    value: number[] | Float32Array\n  ): { output: number[]; distance: number } {\n    try {\n      const q = toFloat32Array(query);\n      const k = toFloat32Array(key);\n      const v = toFloat32Array(value);\n\n      const result = this.nativeInstance.compute(q, k, v);\n\n      return {\n        output: toArray(result.output),\n        distance: result.distance\n      };\n    } catch (error: any) {\n      throw new Error(`HyperbolicAttention forward failed: ${error.message}`);\n    }\n  }\n}\n\n/**\n * Native MoE Attention (uses Rust implementation)\n *\n * Mixture of Experts with top-k routing\n */\nexport class MoEAttention {\n  private nativeInstance: any;\n  private hiddenDim: number;\n  private numExperts: number;\n\n  constructor(config: AttentionConfig & { numExperts?: number; topK?: number }) {\n    this.hiddenDim = config.hiddenDim;\n    this.numExperts = config.numExperts || 4;\n\n    try {\n      // MoEAttention expects a MoEConfig object\n      this.nativeInstance = new nativeAttention.MoEAttention({\n        dim: this.hiddenDim,\n        numExperts: this.numExperts,\n        topK: config.topK || 2\n      });\n    } catch (error: any) {\n      throw new Error(`Failed to initialize native MoEAttention: ${error.message}`);\n    }\n  }\n\n  forward(\n    query: number[] | Float32Array,\n    key: number[] | Float32Array,\n    value: number[] | Float32Array,\n    topK: number = 2\n  ): { output: number[]; expertWeights: number[] } {\n    try {\n      const q = toFloat32Array(query);\n      const k = toFloat32Array(key);\n      const v = toFloat32Array(value);\n\n      const result = this.nativeInstance.compute(q, k, v, topK);\n\n      return {\n        output: toArray(result.output),\n        expertWeights: toArray(result.expertWeights)\n      };\n    } catch (error: any) {\n      throw new Error(`MoEAttention forward failed: ${error.message}`);\n    }\n  }\n}\n\n/**\n * Scaled Dot-Product Attention (pure JavaScript, always works)\n */\nexport function scaledDotProductAttention(\n  query: number[],\n  key: number[],\n  value: number[],\n  mask?: number[]\n): { output: number[]; weights: number[] } {\n  const dk = query.length;\n\n  // Compute attention scores: Q · K^T / sqrt(dk)\n  let score = 0;\n  for (let i = 0; i < dk; i++) {\n    score += query[i] * key[i];\n  }\n  score /= Math.sqrt(dk);\n\n  // Apply mask if provided\n  if (mask && mask[0] === 0) {\n    score = -Infinity;\n  }\n\n  // Softmax (single score version)\n  const expScore = Math.exp(score);\n  const weight = expScore;\n\n  // Weighted value\n  const output = value.map(v => v * weight);\n\n  return { output, weights: [weight] };\n}\n\n/**\n * Check if native attention is available\n */\nexport function isNativeAttentionAvailable(): boolean {\n  try {\n    const test = new nativeAttention.MultiHeadAttention(128, 4);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Factory function to create appropriate attention module\n */\nexport function createAttention(\n  type: 'multi-head' | 'flash' | 'linear' | 'hyperbolic' | 'moe',\n  config: AttentionConfig\n): MultiHeadAttention | FlashAttention | LinearAttention | HyperbolicAttention | MoEAttention {\n  switch (type) {\n    case 'multi-head':\n      return new MultiHeadAttention(config);\n    case 'flash':\n      return new FlashAttention(config);\n    case 'linear':\n      return new LinearAttention(config);\n    case 'hyperbolic':\n      return new HyperbolicAttention(config);\n    case 'moe':\n      return new MoEAttention(config);\n    default:\n      return new MultiHeadAttention(config);\n  }\n}\n"]}

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