agentic-flow 2.0.0-alpha → 2.0.1-alpha.2

package/dist/types/agentdb.d.ts

@@ -0,0 +1,304 @@
+/**
+ * TypeScript type definitions for AgentDB wrapper
+ *
+ * Provides clean, typed interfaces for all AgentDB operations
+ * following v2.0.0-alpha.2.11 specification
+ */
+/**
+ * Vector search metrics supported by AgentDB
+ */
+export type DistanceMetric = 'cosine' | 'euclidean' | 'dot' | 'manhattan';
+/**
+ * HNSW index configuration
+ */
+export interface HNSWConfig {
+    /** Maximum number of connections per element (default: 16) */
+    M?: number;
+    /** Size of dynamic candidate list during construction (default: 200) */
+    efConstruction?: number;
+    /** Size of dynamic candidate list during search (default: 100) */
+    efSearch?: number;
+}
+/**
+ * Vector embedding with metadata
+ */
+export interface VectorEntry {
+    /** Unique identifier for the vector */
+    id: string;
+    /** Vector embedding (Float32Array for performance) */
+    vector: Float32Array;
+    /** Optional metadata for filtering and retrieval */
+    metadata?: Record<string, any>;
+    /** Timestamp of insertion */
+    timestamp?: number;
+}
+/**
+ * Vector search result
+ */
+export interface VectorSearchResult {
+    /** Vector entry ID */
+    id: string;
+    /** Similarity score (higher = more similar) */
+    score: number;
+    /** Metadata associated with the vector */
+    metadata?: Record<string, any>;
+    /** Optional vector data if requested */
+    vector?: Float32Array;
+}
+/**
+ * Vector search options
+ */
+export interface VectorSearchOptions {
+    /** Number of results to return (default: 10) */
+    k?: number;
+    /** Distance metric (default: 'cosine') */
+    metric?: DistanceMetric;
+    /** Metadata filters (key-value pairs) */
+    filter?: Record<string, any>;
+    /** Include vector data in results (default: false) */
+    includeVectors?: boolean;
+    /** HNSW-specific search parameters */
+    hnswParams?: {
+        efSearch?: number;
+    };
+}
+/**
+ * Memory operation types
+ */
+export type MemoryOperation = 'insert' | 'search' | 'update' | 'delete' | 'get';
+/**
+ * Memory insert options
+ */
+export interface MemoryInsertOptions {
+    /** Vector embedding */
+    vector: Float32Array;
+    /** Metadata for the memory */
+    metadata?: Record<string, any>;
+    /** Optional custom ID (auto-generated if not provided) */
+    id?: string;
+    /** Namespace for organizing memories */
+    namespace?: string;
+}
+/**
+ * Memory update options
+ */
+export interface MemoryUpdateOptions {
+    /** Vector ID to update */
+    id: string;
+    /** New vector embedding (optional) */
+    vector?: Float32Array;
+    /** New metadata (merged with existing) */
+    metadata?: Record<string, any>;
+    /** Namespace */
+    namespace?: string;
+}
+/**
+ * Memory delete options
+ */
+export interface MemoryDeleteOptions {
+    /** Vector ID to delete */
+    id: string;
+    /** Namespace */
+    namespace?: string;
+}
+/**
+ * Memory get options
+ */
+export interface MemoryGetOptions {
+    /** Vector ID to retrieve */
+    id: string;
+    /** Namespace */
+    namespace?: string;
+    /** Include vector data (default: true) */
+    includeVector?: boolean;
+}
+/**
+ * Attention mechanism types
+ */
+export type AttentionType = 'multi-head' | 'flash' | 'linear' | 'hyperbolic' | 'moe' | 'graph-rope';
+/**
+ * Attention configuration
+ */
+export interface AttentionConfig {
+    /** Attention type */
+    type?: AttentionType;
+    /** Number of attention heads (default: 8) */
+    numHeads?: number;
+    /** Head dimension (default: 64) */
+    headDim?: number;
+    /** Embedding dimension (inferred from vector dimension) */
+    embedDim?: number;
+    /** Dropout rate (default: 0.1) */
+    dropout?: number;
+    /** Hyperbolic curvature for hyperbolic attention */
+    curvature?: number;
+    /** Number of experts for MoE attention */
+    numExperts?: number;
+    /** Top-k experts to activate (default: 2) */
+    topK?: number;
+}
+/**
+ * GNN configuration
+ */
+export interface GNNConfig {
+    /** Enable GNN query refinement (default: false) */
+    enabled?: boolean;
+    /** Input dimension (matches vector dimension) */
+    inputDim?: number;
+    /** Hidden layer dimension (default: 256) */
+    hiddenDim?: number;
+    /** Number of GNN layers (default: 3) */
+    numLayers?: number;
+    /** Number of attention heads per layer (default: 8) */
+    numHeads?: number;
+    /** Aggregation method */
+    aggregation?: 'mean' | 'sum' | 'max' | 'attention';
+}
+/**
+ * Graph context for GNN operations
+ */
+export interface GraphContext {
+    /** Node features (embeddings) */
+    nodes: Float32Array[];
+    /** Edge list [source, target] pairs */
+    edges: [number, number][];
+    /** Optional edge weights */
+    edgeWeights?: number[];
+    /** Optional node labels */
+    nodeLabels?: string[];
+}
+/**
+ * AgentDB configuration
+ */
+export interface AgentDBConfig {
+    /** Database file path (default: ':memory:') */
+    dbPath?: string;
+    /** Namespace for organizing data */
+    namespace?: string;
+    /** Vector dimension (default: 384) */
+    dimension?: number;
+    /** HNSW index configuration */
+    hnswConfig?: HNSWConfig;
+    /** Enable attention mechanisms (default: false) */
+    enableAttention?: boolean;
+    /** Attention configuration */
+    attentionConfig?: AttentionConfig;
+    /** Enable GNN query refinement (default: false) */
+    enableGNN?: boolean;
+    /** GNN configuration */
+    gnnConfig?: GNNConfig;
+    /** Enable auto-initialization (default: true) */
+    autoInit?: boolean;
+}
+/**
+ * Statistics about the AgentDB instance
+ */
+export interface AgentDBStats {
+    /** Total number of vectors */
+    vectorCount: number;
+    /** Vector dimension */
+    dimension: number;
+    /** Database size in bytes */
+    databaseSize: number;
+    /** HNSW index statistics */
+    hnswStats?: {
+        M: number;
+        efConstruction: number;
+        efSearch: number;
+        levels: number;
+    };
+    /** Memory usage in bytes */
+    memoryUsage?: number;
+    /** Index build time in ms */
+    indexBuildTime?: number;
+}
+/**
+ * Batch insert result
+ */
+export interface BatchInsertResult {
+    /** Number of successfully inserted vectors */
+    inserted: number;
+    /** Failed insertions with errors */
+    failed: Array<{
+        index: number;
+        id?: string;
+        error: string;
+    }>;
+    /** Total time in milliseconds */
+    duration: number;
+}
+/**
+ * Error types for AgentDB operations
+ */
+export declare class AgentDBError extends Error {
+    readonly code: string;
+    readonly operation: MemoryOperation;
+    readonly details?: any;
+    constructor(message: string, code: string, operation: MemoryOperation, details?: any);
+}
+/**
+ * Validation error for invalid inputs
+ */
+export declare class ValidationError extends AgentDBError {
+    constructor(message: string, details?: any);
+}
+/**
+ * Database error for storage issues
+ */
+export declare class DatabaseError extends AgentDBError {
+    constructor(message: string, operation: MemoryOperation, details?: any);
+}
+/**
+ * Index error for HNSW operations
+ */
+export declare class IndexError extends AgentDBError {
+    constructor(message: string, operation: MemoryOperation, details?: any);
+}
+/**
+ * Attention result with performance metrics
+ */
+export interface AttentionResult {
+    /** Output tensor */
+    output: Float32Array;
+    /** Attention mechanism used */
+    mechanism: AttentionType;
+    /** Runtime environment (napi or wasm) */
+    runtime: 'napi' | 'wasm' | 'js';
+    /** Execution time in milliseconds */
+    executionTimeMs: number;
+    /** Optional attention weights */
+    attentionWeights?: Float32Array;
+    /** Memory usage in bytes */
+    memoryUsage?: number;
+}
+/**
+ * GNN refinement result
+ */
+export interface GNNRefinementResult {
+    /** Refined results */
+    results: VectorSearchResult[];
+    /** Original recall */
+    originalRecall: number;
+    /** Improved recall after GNN */
+    improvedRecall: number;
+    /** Recall improvement percentage */
+    improvementPercent: number;
+    /** GNN execution time */
+    executionTimeMs: number;
+}
+/**
+ * Vector search options with advanced features
+ */
+export interface AdvancedSearchOptions extends VectorSearchOptions {
+    /** Use attention-based reranking */
+    useAttention?: boolean;
+    /** Attention mechanism to use */
+    attentionMechanism?: AttentionType;
+    /** Use GNN query refinement */
+    useGNN?: boolean;
+    /** Graph context for GNN */
+    graphContext?: GraphContext;
+    /** Include performance metrics */
+    includeMetrics?: boolean;
+}
+//# sourceMappingURL=agentdb.d.ts.map

package/dist/utils/agentBoosterPreprocessor.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Agent Booster Pre-Processor
+ *
+ * Detects code editing intents in agent tasks and attempts Agent Booster
+ * pattern matching before falling back to LLM.
+ */
+export interface EditIntent {
+    type: string;
+    task: string;
+    filePath?: string;
+    originalCode?: string;
+    targetCode?: string;
+    confidence: number;
+}
+export interface PreprocessorResult {
+    success: boolean;
+    method: 'agent_booster' | 'llm_required';
+    output?: string;
+    latency?: number;
+    confidence?: number;
+    strategy?: string;
+    reason?: string;
+}
+export declare class AgentBoosterPreprocessor {
+    private confidenceThreshold;
+    private enabledIntents;
+    constructor(options?: {
+        confidenceThreshold?: number;
+        enabledIntents?: string[];
+    });
+    /**
+     * Detect if a task is a code editing intent that Agent Booster can handle
+     */
+    detectIntent(task: string): EditIntent | null;
+    /**
+     * Try to apply edit using Agent Booster
+     */
+    tryApply(intent: EditIntent): Promise<PreprocessorResult>;
+    /**
+     * Extract file path from task description
+     */
+    private extractFilePath;
+    /**
+     * Detect programming language from file extension
+     */
+    private detectLanguage;
+    /**
+     * Extract var to const transformation
+     */
+    private extractVarToConst;
+    /**
+     * Extract add types transformation (TypeScript)
+     */
+    private extractAddTypes;
+    /**
+     * Extract add error handling transformation
+     */
+    private extractAddErrorHandling;
+    /**
+     * Extract async/await transformation
+     */
+    private extractAsyncAwait;
+    /**
+     * Extract add logging transformation
+     */
+    private extractAddLogging;
+    /**
+     * Extract remove console transformation
+     */
+    private extractRemoveConsole;
+}
+//# sourceMappingURL=agentBoosterPreprocessor.d.ts.map

package/dist/utils/agentLoader.d.ts

@@ -0,0 +1,22 @@
+export interface AgentDefinition {
+    name: string;
+    description: string;
+    systemPrompt: string;
+    color?: string;
+    tools?: string[];
+    filePath: string;
+}
+/**
+ * Load all agents from .claude/agents directory with deduplication
+ * Local agents (.claude/agents in CWD) override package agents
+ */
+export declare function loadAgents(agentsDir?: string): Map<string, AgentDefinition>;
+/**
+ * Get a specific agent by name
+ */
+export declare function getAgent(name: string, agentsDir?: string): AgentDefinition | undefined;
+/**
+ * List all available agents
+ */
+export declare function listAgents(agentsDir?: string): AgentDefinition[];
+//# sourceMappingURL=agentLoader.d.ts.map

package/dist/utils/agentdb-runtime-patch.d.ts

@@ -0,0 +1,28 @@
+/**
+ * AgentDB Runtime Patch
+ *
+ * Automatically fixes AgentDB v1.3.9 import resolution issues at runtime.
+ * This patch works in all contexts: npm install, npm install -g, and npx.
+ *
+ * Issue: agentdb v1.3.9 missing .js extensions in ESM exports
+ * Solution: Patch the controller index.js file at runtime before first import
+ */
+/**
+ * Apply AgentDB import fix at runtime
+ * Safe to call multiple times - only patches once
+ */
+export declare function applyAgentDBPatch(): boolean;
+/**
+ * Check if AgentDB patch is needed
+ */
+export declare function isAgentDBPatchNeeded(): boolean;
+/**
+ * Get patch status information
+ */
+export declare function getAgentDBPatchStatus(): {
+    needed: boolean;
+    applied: boolean;
+    attempted: boolean;
+    location: string | null;
+};
+//# sourceMappingURL=agentdb-runtime-patch.d.ts.map

package/dist/utils/auth.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Simple API key authentication for proxy
+ */
+export declare class AuthManager {
+    private validKeys;
+    constructor(apiKeys?: string[]);
+    authenticate(headers: Record<string, string | string[] | undefined>): boolean;
+    private extractApiKey;
+    addKey(key: string): void;
+    removeKey(key: string): void;
+    hasKeys(): boolean;
+}
+//# sourceMappingURL=auth.d.ts.map

package/dist/utils/cli.d.ts

@@ -0,0 +1,31 @@
+export interface CliOptions {
+    mode: 'agent' | 'parallel' | 'list' | 'mcp' | 'mcp-manager' | 'config' | 'agent-manager' | 'proxy' | 'quic' | 'claude-code' | 'reasoningbank' | 'federation';
+    agent?: string;
+    task?: string;
+    model?: string;
+    provider?: string;
+    anthropicApiKey?: string;
+    openrouterApiKey?: string;
+    stream?: boolean;
+    temperature?: number;
+    maxTokens?: number;
+    agentsDir?: string;
+    outputFormat?: 'text' | 'json' | 'markdown';
+    verbose?: boolean;
+    timeout?: number;
+    retryOnError?: boolean;
+    optimize?: boolean;
+    optimizePriority?: 'quality' | 'balanced' | 'cost' | 'speed' | 'privacy';
+    maxCost?: number;
+    claudeCode?: boolean;
+    agentBooster?: boolean;
+    boosterThreshold?: number;
+    help?: boolean;
+    version?: boolean;
+    mcpCommand?: string;
+    mcpServer?: string;
+}
+export declare function parseArgs(): CliOptions;
+export declare function printHelp(): void;
+export declare function validateOptions(options: CliOptions): string | null;
+//# sourceMappingURL=cli.d.ts.map

package/dist/utils/compression-middleware.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Compression Middleware for Proxy Responses
+ * Provides 30-70% bandwidth reduction with Brotli/Gzip
+ */
+export type CompressionEncoding = 'br' | 'gzip' | 'identity';
+export interface CompressionConfig {
+    minSize: number;
+    level?: number;
+    preferredEncoding: CompressionEncoding;
+    enableBrotli: boolean;
+    enableGzip: boolean;
+}
+export interface CompressionResult {
+    compressed: Buffer;
+    encoding: CompressionEncoding;
+    originalSize: number;
+    compressedSize: number;
+    ratio: number;
+    duration: number;
+}
+export declare class CompressionMiddleware {
+    private config;
+    constructor(config?: Partial<CompressionConfig>);
+    /**
+     * Compress data using best available algorithm
+     */
+    compress(data: Buffer, acceptedEncodings?: string): Promise<CompressionResult>;
+    /**
+     * Compress using Brotli (best compression ratio)
+     */
+    private compressBrotli;
+    /**
+     * Compress using Gzip (faster, broader support)
+     */
+    private compressGzip;
+    /**
+     * Select best encoding based on client support
+     */
+    private selectEncoding;
+    /**
+     * Check if compression is recommended for content type
+     */
+    shouldCompress(contentType?: string): boolean;
+    /**
+     * Get compression statistics
+     */
+    getStats(): {
+        config: Required<CompressionConfig>;
+        capabilities: {
+            brotli: boolean;
+            gzip: boolean;
+        };
+    };
+}
+//# sourceMappingURL=compression-middleware.d.ts.map

package/dist/utils/connection-pool.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Connection Pool for HTTP/2 and HTTP/3 Proxies
+ * Provides connection reuse to reduce latency by 20-30%
+ */
+import http2 from 'http2';
+export interface PoolConfig {
+    maxSize: number;
+    maxIdleTime: number;
+    acquireTimeout: number;
+}
+export declare class ConnectionPool {
+    private pools;
+    private config;
+    private cleanupInterval;
+    constructor(config?: Partial<PoolConfig>);
+    acquire(host: string): Promise<http2.ClientHttp2Session>;
+    release(session: http2.ClientHttp2Session, host: string): Promise<void>;
+    private createConnection;
+    private waitForConnection;
+    private isExpired;
+    private removeConnection;
+    private cleanup;
+    destroy(): void;
+    getStats(): Record<string, {
+        total: number;
+        busy: number;
+        idle: number;
+    }>;
+}
+//# sourceMappingURL=connection-pool.d.ts.map

package/dist/utils/logger.d.ts

@@ -0,0 +1,19 @@
+interface LogContext {
+    agent?: string;
+    task?: string;
+    duration?: number;
+    error?: unknown;
+    [key: string]: any;
+}
+declare class Logger {
+    private context;
+    setContext(ctx: Record<string, any>): void;
+    private log;
+    debug(message: string, data?: LogContext): void;
+    info(message: string, data?: LogContext): void;
+    warn(message: string, data?: LogContext): void;
+    error(message: string, data?: LogContext): void;
+}
+export declare const logger: Logger;
+export {};
+//# sourceMappingURL=logger.d.ts.map

package/dist/utils/math.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Simple math utility functions
+ */
+/**
+ * Adds 2 and 2 together
+ * @returns The sum of 2 + 2
+ * @example
+ * const result = addTwoPlusTwo();
+ * console.log(result); // Output: 4
+ */
+export declare const addTwoPlusTwo: () => number;
+//# sourceMappingURL=math.d.ts.map

package/dist/utils/mcpCommands.d.ts

@@ -0,0 +1,2 @@
+export declare function handleMCPCommand(command: string, server?: string): Promise<void>;
+//# sourceMappingURL=mcpCommands.d.ts.map

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

@@ -0,0 +1,63 @@
+/**
+ * Automatic Model Downloader for ONNX Phi-4
+ *
+ * Downloads Phi-4 ONNX model from HuggingFace on first use
+ */
+export interface DownloadProgress {
+    downloaded: number;
+    total: number;
+    percentage: number;
+}
+export interface ModelInfo {
+    repo: string;
+    filename: string;
+    localPath: string;
+    sha256?: string;
+}
+export declare class ModelDownloader {
+    private baseUrl;
+    /**
+     * Phi-4 Mini ONNX INT4 quantized model (CPU optimized)
+     * Size: ~52MB model + ~4.86GB data = ~4.9GB total
+     * Note: Requires TWO files - model.onnx and model.onnx.data
+     */
+    private phi4Model;
+    private phi4ModelData;
+    /**
+     * Check if model exists locally
+     */
+    isModelDownloaded(modelPath?: string): boolean;
+    /**
+     * Get model download URL
+     */
+    private getDownloadUrl;
+    /**
+     * Download model with progress tracking
+     */
+    downloadModel(modelInfo?: ModelInfo, onProgress?: (progress: DownloadProgress) => void): Promise<string>;
+    /**
+     * Download Phi-4 ONNX model if needed (downloads BOTH .onnx and .onnx.data files)
+     */
+    ensurePhi4Model(onProgress?: (progress: DownloadProgress) => void): Promise<string>;
+    /**
+     * Verify model file integrity (optional)
+     */
+    verifyModel(modelPath: string, expectedSha256?: string): Promise<boolean>;
+    /**
+     * Get model info
+     */
+    getModelInfo(): ModelInfo;
+    /**
+     * Format download progress for display
+     */
+    static formatProgress(progress: DownloadProgress): string;
+}
+/**
+ * Global singleton instance
+ */
+export declare const modelDownloader: ModelDownloader;
+/**
+ * Convenience function for downloading Phi-4 model
+ */
+export declare function ensurePhi4Model(onProgress?: (progress: DownloadProgress) => void): Promise<string>;
+//# sourceMappingURL=model-downloader.d.ts.map

package/dist/utils/modelCapabilities.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Model Capability Detection
+ * Determines if a model supports native tool calling or requires emulation
+ */
+export interface ModelCapabilities {
+    supportsNativeTools: boolean;
+    supportsStreaming: boolean;
+    contextWindow: number;
+    requiresEmulation: boolean;
+    emulationStrategy: 'none' | 'react' | 'prompt' | 'hybrid';
+    costPerMillionTokens: number;
+    provider: string;
+}
+/**
+ * Detect capabilities of a model
+ */
+export declare function detectModelCapabilities(modelId: string): ModelCapabilities;
+/**
+ * Check if model can handle a specific number of tools
+ */
+export declare function canHandleToolCount(modelId: string, toolCount: number): boolean;
+/**
+ * Recommend optimal strategy for a model
+ */
+export declare function recommendStrategy(modelId: string, toolCount: number, taskComplexity: 'simple' | 'medium' | 'complex'): 'native' | 'react' | 'prompt' | 'hybrid';
+/**
+ * Get human-readable capability report
+ */
+export declare function getCapabilityReport(modelId: string): string;
+//# sourceMappingURL=modelCapabilities.d.ts.map