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

package/dist/routing/SemanticRouter.d.ts

@@ -1,164 +0,0 @@
-/**
- * Semantic Router - HNSW-Powered Intent Matching
- *
- * Integrates @ruvector/router for sub-10ms semantic routing.
- *
- * Features:
- * - HNSW (Hierarchical Navigable Small World) index
- * - Intent classification for 66+ agents
- * - Sub-10ms routing latency
- * - Automatic intent embedding and indexing
- * - Multi-intent detection
- *
- * Performance:
- * - <10ms routing time
- * - >85% routing accuracy
- * - Support for 66+ agent types
- * - O(log N) search complexity
- */
-import type { EmbeddingService } from 'agentdb';
-export interface AgentIntent {
-    /** Agent type identifier */
-    agentType: string;
-    /** Natural language description of agent capabilities */
-    description: string;
-    /** Example tasks for this agent */
-    examples: string[];
-    /** Agent specialty tags */
-    tags: string[];
-}
-export interface RoutingResult {
-    /** Primary agent selection */
-    primaryAgent: string;
-    /** Confidence score (0-1) */
-    confidence: number;
-    /** Secondary agent suggestions */
-    alternatives: Array<{
-        agentType: string;
-        confidence: number;
-    }>;
-    /** Matched intent descriptions */
-    matchedIntents: string[];
-    /** Routing metrics */
-    metrics: {
-        routingTimeMs: number;
-        embeddingTimeMs: number;
-        searchTimeMs: number;
-        candidatesEvaluated: number;
-    };
-}
-export interface MultiIntentResult {
-    /** Detected intents in order of confidence */
-    intents: Array<{
-        agentType: string;
-        confidence: number;
-        matchedText: string;
-    }>;
-    /** Whether task requires multiple agents */
-    requiresMultiAgent: boolean;
-    /** Suggested execution order */
-    executionOrder: string[];
-}
-/**
- * Semantic Router
- *
- * Provides intent-based agent routing:
- * 1. Register agent intents with descriptions
- * 2. Build HNSW index for fast semantic search
- * 3. Route tasks to agents based on intent similarity
- * 4. Support multi-intent detection for complex tasks
- */
-export declare class SemanticRouter {
-    private embedder;
-    private agentIntents;
-    private intentEmbeddings;
-    private indexBuilt;
-    private routingStats;
-    constructor(embedder: EmbeddingService);
-    /**
-     * Register agent intent for routing
-     *
-     * @param intent - Agent intent configuration
-     */
-    registerAgent(intent: AgentIntent): Promise<void>;
-    /**
-     * Register multiple agents in batch
-     *
-     * @param intents - Array of agent intents
-     */
-    registerAgents(intents: AgentIntent[]): Promise<void>;
-    /**
-     * Build HNSW index for fast routing
-     *
-     * In production, this would use @ruvector/router's native HNSW.
-     * For this implementation, we use a simplified version.
-     */
-    buildIndex(): void;
-    /**
-     * Route task to best agent using semantic similarity
-     *
-     * Process:
-     * 1. Embed task description
-     * 2. Search HNSW index for nearest intents
-     * 3. Return top matches with confidence scores
-     *
-     * @param taskDescription - Natural language task description
-     * @param k - Number of alternatives to return (default: 3)
-     * @returns Routing result with primary agent and alternatives
-     */
-    route(taskDescription: string, k?: number): Promise<RoutingResult>;
-    /**
-     * Detect multiple intents in complex task
-     *
-     * Useful for tasks requiring coordination of multiple agents.
-     *
-     * @param taskDescription - Task that may require multiple agents
-     * @param threshold - Minimum confidence for intent detection (default: 0.6)
-     * @returns Multi-intent result with suggested execution order
-     */
-    detectMultiIntent(taskDescription: string, threshold?: number): Promise<MultiIntentResult>;
-    /**
-     * Get routing statistics
-     *
-     * @returns Cumulative routing metrics
-     */
-    getStats(): typeof this.routingStats;
-    /**
-     * Get all registered agents
-     *
-     * @returns Array of registered agent intents
-     */
-    getRegisteredAgents(): AgentIntent[];
-    /**
-     * Search HNSW index for nearest neighbors
-     *
-     * In production, this would use @ruvector/router's native HNSW.
-     * For this implementation, we use brute-force cosine similarity.
-     *
-     * @param queryEmbedding - Query vector
-     * @param k - Number of results
-     * @returns Top k candidates with similarity scores
-     */
-    private searchHNSW;
-    /**
-     * Calculate cosine similarity
-     */
-    private cosineSimilarity;
-    /**
-     * Segment task into independent clauses
-     */
-    private segmentTask;
-    /**
-     * Deduplicate intents by agent type
-     */
-    private deduplicateIntents;
-    /**
-     * Infer execution order from intents and task description
-     */
-    private inferExecutionOrder;
-    /**
-     * Update routing statistics
-     */
-    private updateStats;
-}
-//# sourceMappingURL=SemanticRouter.d.ts.map

package/dist/routing/index.d.ts

@@ -1,12 +0,0 @@
-/**
- * Routing Module
- *
- * Exports:
- * - CircuitBreakerRouter: Fault-tolerant agent routing
- * - SemanticRouter: HNSW-powered intent matching
- */
-export { CircuitBreakerRouter, CircuitState } from './CircuitBreakerRouter.js';
-export type { CircuitBreakerConfig, RouteRequest, RouteResult, AgentHealth, } from './CircuitBreakerRouter.js';
-export { SemanticRouter } from './SemanticRouter.js';
-export type { AgentIntent, RoutingResult, MultiIntentResult, } from './SemanticRouter.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/services/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/services/embedding-service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"embedding-service.d.ts","sourceRoot":"","sources":["../../src/services/embedding-service.ts"],"names":[],"mappings":"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"}

package/dist/services/embedding-service.js

@@ -1,370 +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';
-/**
- * Base embedding service interface
- */
-export class EmbeddingService extends EventEmitter {
-    config;
-    cache = new Map();
-    constructor(config) {
-        super();
-        this.config = {
-            cacheSize: 1000,
-            ...config
-        };
-    }
-    /**
-     * Get cached embedding if available
-     */
-    getCached(text) {
-        return this.cache.get(text) || null;
-    }
-    /**
-     * Cache embedding with LRU eviction
-     */
-    setCached(text, embedding) {
-        if (this.cache.size >= this.config.cacheSize) {
-            // Remove oldest entry (first in map)
-            const firstKey = this.cache.keys().next().value;
-            this.cache.delete(firstKey);
-        }
-        this.cache.set(text, embedding);
-    }
-    /**
-     * Clear cache
-     */
-    clearCache() {
-        this.cache.clear();
-    }
-}
-/**
- * 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 class OpenAIEmbeddingService extends EmbeddingService {
-    apiKey;
-    model;
-    baseURL = 'https://api.openai.com/v1/embeddings';
-    constructor(config) {
-        super({ ...config, provider: 'openai' });
-        this.apiKey = config.apiKey;
-        this.model = config.model || 'text-embedding-3-small';
-    }
-    async embed(text) {
-        // Check cache
-        const cached = this.getCached(text);
-        if (cached) {
-            return {
-                embedding: cached,
-                latency: 0
-            };
-        }
-        const start = Date.now();
-        try {
-            const response = await fetch(this.baseURL, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: `Bearer ${this.apiKey}`
-                },
-                body: JSON.stringify({
-                    model: this.model,
-                    input: text,
-                    dimensions: this.config.dimensions || undefined
-                })
-            });
-            if (!response.ok) {
-                throw new Error(`OpenAI API error: ${response.statusText}`);
-            }
-            const data = await response.json();
-            const embedding = data.data[0].embedding;
-            // Cache it
-            this.setCached(text, embedding);
-            const latency = Date.now() - start;
-            this.emit('embed', { text, latency });
-            return {
-                embedding,
-                usage: {
-                    promptTokens: data.usage.prompt_tokens,
-                    totalTokens: data.usage.total_tokens,
-                },
-                latency
-            };
-        }
-        catch (error) {
-            throw new Error(`OpenAI embedding failed: ${error.message}`);
-        }
-    }
-    async embedBatch(texts) {
-        const start = Date.now();
-        try {
-            const response = await fetch(this.baseURL, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: `Bearer ${this.apiKey}`
-                },
-                body: JSON.stringify({
-                    model: this.model,
-                    input: texts,
-                    dimensions: this.config.dimensions || undefined
-                })
-            });
-            if (!response.ok) {
-                throw new Error(`OpenAI API error: ${response.statusText}`);
-            }
-            const data = await response.json();
-            const latency = Date.now() - start;
-            return data.data.map((item, index) => {
-                const embedding = item.embedding;
-                this.setCached(texts[index], embedding);
-                return {
-                    embedding,
-                    usage: {
-                        promptTokens: Math.floor(data.usage.prompt_tokens / texts.length),
-                        totalTokens: Math.floor(data.usage.total_tokens / texts.length)
-                    },
-                    latency: Math.floor(latency / texts.length)
-                };
-            });
-        }
-        catch (error) {
-            throw new Error(`OpenAI batch embedding failed: ${error.message}`);
-        }
-    }
-}
-/**
- * Transformers.js Local Embedding Service
- *
- * Runs locally without API calls using ONNX runtime
- * https://huggingface.co/docs/transformers.js
- */
-export class TransformersEmbeddingService extends EmbeddingService {
-    pipeline = null;
-    modelName;
-    constructor(config) {
-        super({ ...config, provider: 'transformers' });
-        this.modelName = config.model || 'Xenova/all-MiniLM-L6-v2';
-    }
-    async initialize() {
-        if (this.pipeline)
-            return;
-        try {
-            // Dynamically import transformers.js
-            const { pipeline } = await import('@xenova/transformers');
-            this.pipeline = await pipeline('feature-extraction', this.modelName);
-            this.emit('initialized', { model: this.modelName });
-        }
-        catch (error) {
-            throw new Error(`Failed to initialize transformers.js: ${error.message}`);
-        }
-    }
-    async embed(text) {
-        await this.initialize();
-        // Check cache
-        const cached = this.getCached(text);
-        if (cached) {
-            return {
-                embedding: cached,
-                latency: 0
-            };
-        }
-        const start = Date.now();
-        try {
-            const output = await this.pipeline(text, { pooling: 'mean', normalize: true });
-            // Convert to regular array (output.data is Float32Array or similar)
-            const embedding = Array.from(output.data);
-            // Cache it
-            this.setCached(text, embedding);
-            const latency = Date.now() - start;
-            this.emit('embed', { text, latency });
-            return {
-                embedding,
-                latency
-            };
-        }
-        catch (error) {
-            throw new Error(`Transformers.js embedding failed: ${error.message}`);
-        }
-    }
-    async embedBatch(texts) {
-        await this.initialize();
-        const start = Date.now();
-        try {
-            const results = [];
-            for (const text of texts) {
-                const cached = this.getCached(text);
-                if (cached) {
-                    results.push({
-                        embedding: cached,
-                        latency: 0
-                    });
-                }
-                else {
-                    const output = await this.pipeline(text, {
-                        pooling: 'mean',
-                        normalize: true
-                    });
-                    const embedding = Array.from(output.data);
-                    this.setCached(text, embedding);
-                    results.push({
-                        embedding,
-                        latency: Math.floor((Date.now() - start) / texts.length)
-                    });
-                }
-            }
-            return results;
-        }
-        catch (error) {
-            throw new Error(`Transformers.js batch embedding failed: ${error.message}`);
-        }
-    }
-}
-/**
- * Mock Embedding Service (for development/testing)
- *
- * Generates deterministic hash-based embeddings
- * Fast but not semantically meaningful
- */
-export class MockEmbeddingService extends EmbeddingService {
-    constructor(config) {
-        super({
-            provider: 'mock',
-            dimensions: 384,
-            ...config
-        });
-    }
-    async embed(text) {
-        // Check cache
-        const cached = this.getCached(text);
-        if (cached) {
-            return {
-                embedding: cached,
-                latency: 0
-            };
-        }
-        const start = Date.now();
-        // Generate hash-based embedding
-        const embedding = this.hashEmbedding(text);
-        // Cache it
-        this.setCached(text, embedding);
-        const latency = Date.now() - start;
-        return {
-            embedding,
-            latency
-        };
-    }
-    async embedBatch(texts) {
-        return Promise.all(texts.map(text => this.embed(text)));
-    }
-    hashEmbedding(text) {
-        const dimensions = this.config.dimensions || 384;
-        const embedding = new Array(dimensions);
-        // Seed with text hash
-        let hash = 0;
-        for (let i = 0; i < text.length; i++) {
-            hash = (hash << 5) - hash + text.charCodeAt(i);
-            hash = hash & hash;
-        }
-        // Generate pseudo-random embedding
-        for (let i = 0; i < dimensions; i++) {
-            const seed = hash + i * 2654435761;
-            const x = Math.sin(seed) * 10000;
-            embedding[i] = x - Math.floor(x);
-        }
-        // Normalize to unit vector
-        const norm = Math.sqrt(embedding.reduce((sum, v) => sum + v * v, 0));
-        return embedding.map(v => v / norm);
-    }
-}
-/**
- * Factory function to create appropriate embedding service
- */
-export function createEmbeddingService(config) {
-    switch (config.provider) {
-        case 'openai':
-            if (!config.apiKey) {
-                throw new Error('OpenAI API key required');
-            }
-            return new OpenAIEmbeddingService(config);
-        case 'transformers':
-            return new TransformersEmbeddingService(config);
-        case 'mock':
-            return new MockEmbeddingService(config);
-        default:
-            console.warn(`Unknown provider: ${config.provider}, using mock`);
-            return new MockEmbeddingService(config);
-    }
-}
-/**
- * Convenience function for quick embeddings
- */
-export async function getEmbedding(text, config) {
-    const service = createEmbeddingService({
-        provider: 'mock',
-        ...config
-    });
-    const result = await service.embed(text);
-    return result.embedding;
-}
-/**
- * Benchmark different embedding providers
- */
-export async function benchmarkEmbeddings(testText = 'Hello world') {
-    const results = {};
-    // Test mock
-    const mockService = new MockEmbeddingService({ dimensions: 384 });
-    const mockResult = await mockService.embed(testText);
-    results.mock = {
-        latency: mockResult.latency,
-        dimensions: mockResult.embedding.length
-    };
-    // Test transformers (if available)
-    try {
-        const transformersService = new TransformersEmbeddingService({
-            model: 'Xenova/all-MiniLM-L6-v2'
-        });
-        const transformersResult = await transformersService.embed(testText);
-        results.transformers = {
-            latency: transformersResult.latency,
-            dimensions: transformersResult.embedding.length
-        };
-    }
-    catch (error) {
-        results.transformers = {
-            error: error.message
-        };
-    }
-    // Test OpenAI (if API key available)
-    const apiKey = process.env.OPENAI_API_KEY;
-    if (apiKey) {
-        try {
-            const openaiService = new OpenAIEmbeddingService({
-                apiKey,
-                model: 'text-embedding-3-small'
-            });
-            const openaiResult = await openaiService.embed(testText);
-            results.openai = {
-                latency: openaiResult.latency,
-                dimensions: openaiResult.embedding.length
-            };
-        }
-        catch (error) {
-            results.openai = {
-                error: error.message
-            };
-        }
-    }
-    return results;
-}
-//# sourceMappingURL=embedding-service.js.map