@weavelogic/knowledge-graph-agent 0.6.0 → 0.7.1

package/dist/transport/agent-transport.d.ts

@@ -0,0 +1,269 @@
+/**
+ * Agent Transport Service
+ *
+ * High-level API combining QUIC Transport and Federation Hub for
+ * seamless agent communication and distributed execution.
+ *
+ * Provides:
+ * - Agent-to-agent messaging with automatic protocol selection
+ * - Distributed task execution across federation nodes
+ * - Parallel task execution with aggregation
+ * - Health monitoring and metrics
+ *
+ * @module transport/agent-transport
+ */
+import { QUICTransportAdapter, type LatencyStats } from '../integrations/agentic-flow/adapters/quic-transport-adapter.js';
+import { FederationHubAdapter } from '../integrations/agentic-flow/adapters/federation-hub-adapter.js';
+/**
+ * Transport configuration
+ */
+export interface TransportConfig {
+    /**
+     * Prefer QUIC protocol over HTTP when available
+     */
+    preferQuic: boolean;
+    /**
+     * Fall back to HTTP if QUIC is unavailable
+     */
+    fallbackToHttp: boolean;
+    /**
+     * Enable federation for distributed execution
+     */
+    federationEnabled: boolean;
+    /**
+     * Maximum retry attempts for failed operations
+     */
+    maxRetries: number;
+    /**
+     * Timeout for send operations in milliseconds
+     */
+    sendTimeout: number;
+    /**
+     * Timeout for distributed execution in milliseconds
+     */
+    executionTimeout: number;
+    /**
+     * Enable automatic reconnection
+     */
+    autoReconnect: boolean;
+    /**
+     * Interval between reconnection attempts in milliseconds
+     */
+    reconnectInterval: number;
+}
+/**
+ * Default transport configuration
+ */
+export declare const defaultTransportConfig: TransportConfig;
+/**
+ * Transport health status
+ */
+export interface TransportHealth {
+    quic: boolean;
+    federation: boolean;
+    overallHealthy: boolean;
+    details: {
+        quicConnections?: number;
+        quicLatency?: number;
+        federationNodes?: number;
+        federationAgents?: number;
+    };
+}
+/**
+ * Transport metrics
+ */
+export interface TransportMetrics {
+    messagesSent: number;
+    messagesReceived: number;
+    bytesSent: number;
+    bytesReceived: number;
+    tasksExecuted: number;
+    tasksFailed: number;
+    averageLatencyMs: number;
+    p95LatencyMs: number;
+    errors: number;
+    reconnections: number;
+}
+/**
+ * Distributed execution options
+ */
+export interface DistributedExecutionOptions {
+    /**
+     * Preferred nodes for execution
+     */
+    preferredNodes?: string[];
+    /**
+     * Required capabilities for the task
+     */
+    requiredCapabilities?: string[];
+    /**
+     * Task priority
+     */
+    priority?: 'low' | 'normal' | 'high' | 'critical';
+    /**
+     * Timeout override in milliseconds
+     */
+    timeout?: number;
+    /**
+     * Whether to spawn ephemeral agents
+     */
+    spawnEphemeral?: boolean;
+}
+/**
+ * Parallel execution result
+ */
+export interface ParallelExecutionResult<T = unknown> {
+    results: Array<{
+        taskId: string;
+        success: boolean;
+        result?: T;
+        error?: string;
+        nodeId?: string;
+        agentId?: string;
+        durationMs: number;
+    }>;
+    summary: {
+        total: number;
+        successful: number;
+        failed: number;
+        averageDurationMs: number;
+    };
+}
+/**
+ * Agent message for transport
+ */
+export interface AgentMessage {
+    id: string;
+    fromAgent: string;
+    toAgent?: string;
+    agentType?: string;
+    payload: unknown;
+    timestamp: number;
+    priority?: 'low' | 'normal' | 'high' | 'critical';
+    requiresResponse?: boolean;
+}
+/**
+ * Agent Transport Service
+ *
+ * Unified transport layer for agent communication combining QUIC
+ * for low-latency messaging and Federation Hub for distributed
+ * task execution.
+ */
+export declare class AgentTransport {
+    private config;
+    private quic;
+    private federation;
+    private emitter;
+    private metrics;
+    private initialized;
+    private connections;
+    private agentEndpoints;
+    private latencies;
+    constructor(quic: QUICTransportAdapter, federation: FederationHubAdapter, config?: Partial<TransportConfig>);
+    /**
+     * Initialize the transport service
+     */
+    initialize(): Promise<void>;
+    /**
+     * Send a message to a specific agent
+     *
+     * @param agentId - Target agent ID
+     * @param message - Message to send
+     * @returns Response if requiresResponse is true
+     */
+    sendToAgent(agentId: string, message: unknown): Promise<unknown>;
+    /**
+     * Broadcast a message to all agents of a specific type
+     *
+     * @param agentType - Type of agents to broadcast to
+     * @param message - Message to broadcast
+     */
+    broadcastToAgents(agentType: string, message: unknown): Promise<void>;
+    /**
+     * Register an agent endpoint for direct messaging
+     *
+     * @param agentId - Agent ID
+     * @param endpoint - Agent endpoint address
+     */
+    registerAgentEndpoint(agentId: string, endpoint: string): Promise<void>;
+    /**
+     * Unregister an agent endpoint
+     *
+     * @param agentId - Agent ID to unregister
+     */
+    unregisterAgentEndpoint(agentId: string): Promise<void>;
+    /**
+     * Execute a task on the optimal node in the federation
+     *
+     * @param task - Task payload to execute
+     * @param options - Execution options
+     * @returns Execution result
+     */
+    executeDistributed(task: unknown, options?: DistributedExecutionOptions): Promise<unknown>;
+    /**
+     * Execute multiple tasks in parallel across the federation
+     *
+     * @param tasks - Array of task payloads
+     * @param options - Execution options applied to all tasks
+     * @returns Aggregated results
+     */
+    executeParallel<T = unknown>(tasks: unknown[], options?: DistributedExecutionOptions): Promise<ParallelExecutionResult<T>>;
+    /**
+     * Check transport health status
+     *
+     * @returns Health status for QUIC and Federation
+     */
+    healthCheck(): Promise<TransportHealth>;
+    /**
+     * Get transport metrics
+     *
+     * @returns Combined metrics from all transport layers
+     */
+    getMetrics(): Promise<TransportMetrics>;
+    /**
+     * Get latency statistics
+     */
+    getLatencyStats(): Promise<LatencyStats>;
+    /**
+     * Reset transport metrics
+     */
+    resetMetrics(): void;
+    /**
+     * Subscribe to transport events
+     */
+    on(event: string, listener: (...args: unknown[]) => void): this;
+    /**
+     * Unsubscribe from transport events
+     */
+    off(event: string, listener: (...args: unknown[]) => void): this;
+    /**
+     * Dispose of transport resources
+     */
+    dispose(): Promise<void>;
+    /**
+     * Get current configuration
+     */
+    getConfig(): TransportConfig;
+    /**
+     * Check if transport is initialized
+     */
+    isInitialized(): boolean;
+    private ensureInitialized;
+    private shouldUseQuic;
+    private sendViaQuic;
+    private sendViaFederation;
+    private waitForTaskCompletion;
+    private createId;
+    private createInitialMetrics;
+    private recordLatency;
+    private calculateAverageLatency;
+    private calculateP95Latency;
+}
+/**
+ * Create a new AgentTransport instance with default adapters
+ *
+ * @param config - Transport configuration
+ * @returns Configured AgentTransport instance
+ */
+export declare function createAgentTransport(config?: Partial<TransportConfig>): AgentTransport;
+//# sourceMappingURL=agent-transport.d.ts.map

package/dist/transport/agent-transport.d.ts.map

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

package/dist/transport/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Transport Module
+ *
+ * Provides unified transport services for agent communication
+ * and distributed task execution.
+ *
+ * @module transport
+ */
+export { AgentTransport, createAgentTransport, type TransportConfig, type TransportHealth, type TransportMetrics, type DistributedExecutionOptions, type ParallelExecutionResult, type AgentMessage, defaultTransportConfig, } from './agent-transport.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transport/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,2BAA2B,EAChC,KAAK,uBAAuB,EAC5B,KAAK,YAAY,EACjB,sBAAsB,GACvB,MAAM,sBAAsB,CAAC"}

package/dist/vector/index.d.ts

@@ -46,5 +46,5 @@
  */
 export { createRuVectorConfig, createHighPerformanceConfig, createLowMemoryConfig, createHybridSearchConfig, validateRuVectorConfig, getRecommendedConfig, DEFAULT_HNSW_CONFIG, DEFAULT_INDEX_CONFIG, DEFAULT_CACHE_CONFIG, DEFAULT_PERFORMANCE_CONFIG, defaultConfig, type RuVectorConfig, type VectorBackend, type ConfigValidationResult, type ValidationResult, type HNSWConfig, type PostgresBackendConfig, type CloudBackendConfig, type StandaloneBackendConfig, } from './config.js';
 export type { DistanceMetric, IndexType, SearchSource, VectorEntry, SearchResult, HybridSearchQuery, HybridSearchResult, BatchInsertEntry, BatchInsertOperation, BatchInsertResult, VectorIndexStats, VectorSearchOptions, VectorIndexConfig, VectorStoreEvent, VectorStoreEventListener, IVectorStore, TrajectoryStep, AgentTrajectory, SonaLearningRecord, GraphNode, GraphEdge, CypherQueryResult, VectorUpdateOperation, VectorDeleteOperation, VectorDeleteResult, VectorNamespace, } from './types.js';
-export { EnhancedVectorStore, createVectorStore, TrajectoryTracker, createTrajectoryTracker, type TrajectoryTrackerConfig, type DetectedPattern, } from './services/index.js';
+export { EnhancedVectorStore, createVectorStore, TrajectoryTracker, createTrajectoryTracker, type TrajectoryTrackerConfig, type DetectedPattern, EmbeddingService, createEmbeddingService, getDefaultEmbeddingService, type EmbeddingConfig, type EmbeddingResult, type BatchEmbeddingResult, HybridSearch, createHybridSearch, type HybridSearchConfig, type FTSResult, type FTSProvider, type ExtendedHybridSearchResult, type HybridSearchQuery as ServiceHybridSearchQuery, type HybridSearchResponse, type SearchStats, } from './services/index.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/vector/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAGH,OAAO,EACL,oBAAoB,EACpB,2BAA2B,EAC3B,qBAAqB,EACrB,wBAAwB,EACxB,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,0BAA0B,EAC1B,aAAa,EACb,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,EACrB,KAAK,UAAU,EACf,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACvB,KAAK,uBAAuB,GAC7B,MAAM,aAAa,CAAC;AAGrB,YAAY,EACV,cAAc,EACd,SAAS,EACT,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EAChB,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EAChB,wBAAwB,EACxB,YAAY,EACZ,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,SAAS,EACT,SAAS,EACT,iBAAiB,EACjB,qBAAqB,EACrB,qBAAqB,EACrB,kBAAkB,EAClB,eAAe,GAChB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EACjB,uBAAuB,EACvB,KAAK,uBAAuB,EAC5B,KAAK,eAAe,GACrB,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/vector/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAGH,OAAO,EACL,oBAAoB,EACpB,2BAA2B,EAC3B,qBAAqB,EACrB,wBAAwB,EACxB,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,0BAA0B,EAC1B,aAAa,EACb,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,EACrB,KAAK,UAAU,EACf,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACvB,KAAK,uBAAuB,GAC7B,MAAM,aAAa,CAAC;AAGrB,YAAY,EACV,cAAc,EACd,SAAS,EACT,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EAChB,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EAChB,wBAAwB,EACxB,YAAY,EACZ,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,SAAS,EACT,SAAS,EACT,iBAAiB,EACjB,qBAAqB,EACrB,qBAAqB,EACrB,kBAAkB,EAClB,eAAe,GAChB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,iBAAiB,EACjB,uBAAuB,EACvB,KAAK,uBAAuB,EAC5B,KAAK,eAAe,EACpB,gBAAgB,EAChB,sBAAsB,EACtB,0BAA0B,EAC1B,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,oBAAoB,EACzB,YAAY,EACZ,kBAAkB,EAClB,KAAK,kBAAkB,EACvB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,0BAA0B,EAC/B,KAAK,iBAAiB,IAAI,wBAAwB,EAClD,KAAK,oBAAoB,EACzB,KAAK,WAAW,GACjB,MAAM,qBAAqB,CAAC"}

package/dist/vector/services/embedding-service.d.ts

@@ -0,0 +1,244 @@
+/**
+ * Embedding Service
+ *
+ * Provides text embedding generation using transformer models via @xenova/transformers.
+ * Uses the all-MiniLM-L6-v2 model (384 dimensions) by default for efficient local inference.
+ *
+ * @module vector/services/embedding-service
+ */
+/**
+ * Configuration for the embedding service
+ */
+export interface EmbeddingConfig {
+    /**
+     * Model identifier for the embedding model
+     * @default 'Xenova/all-MiniLM-L6-v2'
+     */
+    model: string;
+    /**
+     * Expected output dimensions for embeddings
+     * @default 384
+     */
+    dimensions: number;
+    /**
+     * Maximum input text length in characters (not tokens)
+     * Longer texts will be truncated
+     * @default 512
+     */
+    maxLength: number;
+    /**
+     * Number of texts to process in a single batch
+     * @default 32
+     */
+    batchSize: number;
+    /**
+     * Whether to normalize embeddings to unit length
+     * @default true
+     */
+    normalize: boolean;
+    /**
+     * Pooling strategy for generating embeddings from token outputs
+     * @default 'mean'
+     */
+    pooling: 'mean' | 'cls' | 'none';
+    /**
+     * Enable quantization for reduced memory usage
+     * @default false
+     */
+    quantized: boolean;
+}
+/**
+ * Result of embedding generation
+ */
+export interface EmbeddingResult {
+    /**
+     * The embedding vector
+     */
+    embedding: Float32Array;
+    /**
+     * Time taken to generate the embedding in milliseconds
+     */
+    durationMs: number;
+    /**
+     * Number of input tokens (approximate)
+     */
+    tokenCount?: number;
+}
+/**
+ * Result of batch embedding generation
+ */
+export interface BatchEmbeddingResult {
+    /**
+     * Array of embedding vectors
+     */
+    embeddings: Float32Array[];
+    /**
+     * Total time taken in milliseconds
+     */
+    durationMs: number;
+    /**
+     * Number of texts successfully embedded
+     */
+    successCount: number;
+    /**
+     * Number of texts that failed
+     */
+    errorCount: number;
+    /**
+     * Error details for failed texts
+     */
+    errors?: Array<{
+        index: number;
+        error: string;
+    }>;
+}
+/**
+ * Embedding Service
+ *
+ * Provides text embedding generation using transformer models.
+ * Supports single and batch operations with automatic initialization.
+ *
+ * @example
+ * ```typescript
+ * const service = new EmbeddingService();
+ * await service.initialize();
+ *
+ * // Single embedding
+ * const embedding = await service.embed('Hello, world!');
+ *
+ * // Batch embeddings
+ * const embeddings = await service.embedBatch([
+ *   'First document',
+ *   'Second document',
+ *   'Third document'
+ * ]);
+ * ```
+ */
+export declare class EmbeddingService {
+    private pipeline;
+    private config;
+    private initPromise;
+    private isInitialized;
+    /**
+     * Create a new EmbeddingService
+     *
+     * @param config - Optional configuration overrides
+     */
+    constructor(config?: Partial<EmbeddingConfig>);
+    /**
+     * Initialize the embedding pipeline
+     *
+     * Loads the transformer model. This is called automatically on first use
+     * but can be called explicitly to pre-load the model.
+     *
+     * @throws Error if model loading fails
+     */
+    initialize(): Promise<void>;
+    private doInitialize;
+    /**
+     * Generate embedding for a single text
+     *
+     * @param text - Text to embed
+     * @returns Embedding result with vector and metadata
+     * @throws Error if not initialized or embedding fails
+     */
+    embed(text: string): Promise<EmbeddingResult>;
+    /**
+     * Generate embeddings for multiple texts
+     *
+     * Processes texts in batches for efficiency.
+     *
+     * @param texts - Array of texts to embed
+     * @returns Batch result with embeddings and metadata
+     */
+    embedBatch(texts: string[]): Promise<BatchEmbeddingResult>;
+    /**
+     * Truncate text to maximum length
+     *
+     * @param text - Text to truncate
+     * @returns Truncated text
+     */
+    private truncateText;
+    /**
+     * Extract embedding from pipeline output
+     *
+     * @param output - Pipeline output tensor
+     * @returns Float32Array embedding
+     */
+    private extractEmbedding;
+    /**
+     * Extract multiple embeddings from batch output
+     *
+     * @param output - Pipeline output tensor for batch
+     * @param batchSize - Number of items in the batch
+     * @returns Array of embeddings
+     */
+    private extractBatchEmbeddings;
+    /**
+     * Flatten nested array
+     *
+     * @param arr - Array to flatten
+     * @returns Flattened number array
+     */
+    private flattenArray;
+    /**
+     * Get the embedding dimensions
+     *
+     * @returns Number of dimensions in generated embeddings
+     */
+    getDimensions(): number;
+    /**
+     * Get the current configuration
+     *
+     * @returns Copy of the current configuration
+     */
+    getConfig(): EmbeddingConfig;
+    /**
+     * Check if the service is initialized
+     *
+     * @returns True if initialized
+     */
+    isReady(): boolean;
+    /**
+     * Get model information
+     *
+     * @returns Model details
+     */
+    getModelInfo(): {
+        model: string;
+        dimensions: number;
+        quantized: boolean;
+    };
+}
+/**
+ * Create an embedding service instance
+ *
+ * Factory function for creating embedding services.
+ *
+ * @param config - Optional configuration overrides
+ * @returns New EmbeddingService instance
+ *
+ * @example
+ * ```typescript
+ * // Default configuration (all-MiniLM-L6-v2, 384 dimensions)
+ * const service = createEmbeddingService();
+ *
+ * // Custom configuration
+ * const customService = createEmbeddingService({
+ *   model: 'Xenova/all-MiniLM-L12-v2',
+ *   dimensions: 384,
+ *   batchSize: 64,
+ * });
+ * ```
+ */
+export declare function createEmbeddingService(config?: Partial<EmbeddingConfig>): EmbeddingService;
+/**
+ * Get the default embedding service
+ *
+ * Returns a shared singleton instance for convenience.
+ * Use createEmbeddingService() for custom configurations.
+ *
+ * @returns Default EmbeddingService instance
+ */
+export declare function getDefaultEmbeddingService(): EmbeddingService;
+//# sourceMappingURL=embedding-service.d.ts.map

package/dist/vector/services/embedding-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedding-service.d.ts","sourceRoot":"","sources":["../../../src/vector/services/embedding-service.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAC;IAEnB;;;OAGG;IACH,OAAO,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,CAAC;IAEjC;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAC;CACpB;AAgBD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,SAAS,EAAE,YAAY,CAAC;IAExB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;OAEG;IACH,UAAU,EAAE,YAAY,EAAE,CAAC;IAE3B;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,MAAM,CAAC,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAClD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAA0C;IAC1D,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,WAAW,CAA8B;IACjD,OAAO,CAAC,aAAa,CAAkB;IAEvC;;;;OAIG;gBACS,MAAM,GAAE,OAAO,CAAC,eAAe,CAAM;IAIjD;;;;;;;OAOG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;YAanB,YAAY;IA6B1B;;;;;;OAMG;IACG,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAyCnD;;;;;;;OAOG;IACG,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAsEhE;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAapB;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IA6BxB;;;;;;OAMG;IACH,OAAO,CAAC,sBAAsB;IAkC9B;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAYpB;;;;OAIG;IACH,aAAa,IAAI,MAAM;IAIvB;;;;OAIG;IACH,SAAS,IAAI,eAAe;IAI5B;;;;OAIG;IACH,OAAO,IAAI,OAAO;IAIlB;;;;OAIG;IACH,YAAY,IAAI;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAE;CAO1E;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,gBAAgB,CAE1F;AAQD;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,IAAI,gBAAgB,CAK7D"}

package/dist/vector/services/embedding-service.js

@@ -0,0 +1,10 @@
+import "../../node_modules/@xenova/transformers/src/tokenizers.js";
+import "../../node_modules/@xenova/transformers/src/models.js";
+import "fs";
+import "path";
+import "../../node_modules/@xenova/transformers/src/env.js";
+import "../../node_modules/@xenova/transformers/src/utils/tensor.js";
+import "../../node_modules/@xenova/transformers/src/utils/image.js";
+import { createLogger } from "../../utils/logger.js";
+createLogger("embedding-service");
+//# sourceMappingURL=embedding-service.js.map

package/dist/vector/services/embedding-service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedding-service.js","sources":["../../../src/vector/services/embedding-service.ts"],"sourcesContent":["/**\n * Embedding Service\n *\n * Provides text embedding generation using transformer models via @xenova/transformers.\n * Uses the all-MiniLM-L6-v2 model (384 dimensions) by default for efficient local inference.\n *\n * @module vector/services/embedding-service\n */\n\nimport { pipeline, type Pipeline, type FeatureExtractionPipeline } from '@xenova/transformers';\nimport { createLogger } from '../../utils/index.js';\n\nconst logger = createLogger('embedding-service');\n\n/**\n * Configuration for the embedding service\n */\nexport interface EmbeddingConfig {\n  /**\n   * Model identifier for the embedding model\n   * @default 'Xenova/all-MiniLM-L6-v2'\n   */\n  model: string;\n\n  /**\n   * Expected output dimensions for embeddings\n   * @default 384\n   */\n  dimensions: number;\n\n  /**\n   * Maximum input text length in characters (not tokens)\n   * Longer texts will be truncated\n   * @default 512\n   */\n  maxLength: number;\n\n  /**\n   * Number of texts to process in a single batch\n   * @default 32\n   */\n  batchSize: number;\n\n  /**\n   * Whether to normalize embeddings to unit length\n   * @default true\n   */\n  normalize: boolean;\n\n  /**\n   * Pooling strategy for generating embeddings from token outputs\n   * @default 'mean'\n   */\n  pooling: 'mean' | 'cls' | 'none';\n\n  /**\n   * Enable quantization for reduced memory usage\n   * @default false\n   */\n  quantized: boolean;\n}\n\n/**\n * Default configuration for embedding service\n * Uses all-MiniLM-L6-v2 which provides a good balance of quality and speed\n */\nconst DEFAULT_CONFIG: EmbeddingConfig = {\n  model: 'Xenova/all-MiniLM-L6-v2',\n  dimensions: 384,\n  maxLength: 512,\n  batchSize: 32,\n  normalize: true,\n  pooling: 'mean',\n  quantized: false,\n};\n\n/**\n * Result of embedding generation\n */\nexport interface EmbeddingResult {\n  /**\n   * The embedding vector\n   */\n  embedding: Float32Array;\n\n  /**\n   * Time taken to generate the embedding in milliseconds\n   */\n  durationMs: number;\n\n  /**\n   * Number of input tokens (approximate)\n   */\n  tokenCount?: number;\n}\n\n/**\n * Result of batch embedding generation\n */\nexport interface BatchEmbeddingResult {\n  /**\n   * Array of embedding vectors\n   */\n  embeddings: Float32Array[];\n\n  /**\n   * Total time taken in milliseconds\n   */\n  durationMs: number;\n\n  /**\n   * Number of texts successfully embedded\n   */\n  successCount: number;\n\n  /**\n   * Number of texts that failed\n   */\n  errorCount: number;\n\n  /**\n   * Error details for failed texts\n   */\n  errors?: Array<{ index: number; error: string }>;\n}\n\n/**\n * Embedding Service\n *\n * Provides text embedding generation using transformer models.\n * Supports single and batch operations with automatic initialization.\n *\n * @example\n * ```typescript\n * const service = new EmbeddingService();\n * await service.initialize();\n *\n * // Single embedding\n * const embedding = await service.embed('Hello, world!');\n *\n * // Batch embeddings\n * const embeddings = await service.embedBatch([\n *   'First document',\n *   'Second document',\n *   'Third document'\n * ]);\n * ```\n */\nexport class EmbeddingService {\n  private pipeline: FeatureExtractionPipeline | null = null;\n  private config: EmbeddingConfig;\n  private initPromise: Promise<void> | null = null;\n  private isInitialized: boolean = false;\n\n  /**\n   * Create a new EmbeddingService\n   *\n   * @param config - Optional configuration overrides\n   */\n  constructor(config: Partial<EmbeddingConfig> = {}) {\n    this.config = { ...DEFAULT_CONFIG, ...config };\n  }\n\n  /**\n   * Initialize the embedding pipeline\n   *\n   * Loads the transformer model. This is called automatically on first use\n   * but can be called explicitly to pre-load the model.\n   *\n   * @throws Error if model loading fails\n   */\n  async initialize(): Promise<void> {\n    if (this.isInitialized) {\n      return;\n    }\n\n    if (this.initPromise) {\n      return this.initPromise;\n    }\n\n    this.initPromise = this.doInitialize();\n    return this.initPromise;\n  }\n\n  private async doInitialize(): Promise<void> {\n    try {\n      logger.info('Loading embedding model', { model: this.config.model });\n      const startTime = Date.now();\n\n      // Load the feature extraction pipeline\n      this.pipeline = (await pipeline(\n        'feature-extraction',\n        this.config.model,\n        { quantized: this.config.quantized }\n      )) as FeatureExtractionPipeline;\n\n      const durationMs = Date.now() - startTime;\n      logger.info('Embedding model loaded', {\n        model: this.config.model,\n        durationMs,\n      });\n\n      this.isInitialized = true;\n    } catch (error) {\n      this.initPromise = null;\n      const message = error instanceof Error ? error.message : String(error);\n      logger.error('Failed to load embedding model', new Error(message), {\n        model: this.config.model,\n      });\n      throw new Error(`Failed to initialize embedding service: ${message}`);\n    }\n  }\n\n  /**\n   * Generate embedding for a single text\n   *\n   * @param text - Text to embed\n   * @returns Embedding result with vector and metadata\n   * @throws Error if not initialized or embedding fails\n   */\n  async embed(text: string): Promise<EmbeddingResult> {\n    await this.initialize();\n\n    if (!this.pipeline) {\n      throw new Error('Embedding pipeline not initialized');\n    }\n\n    const startTime = Date.now();\n\n    // Truncate text if too long\n    const truncated = this.truncateText(text);\n\n    try {\n      const output = await this.pipeline(truncated, {\n        pooling: this.config.pooling,\n        normalize: this.config.normalize,\n      });\n\n      // Extract the embedding data\n      const embedding = this.extractEmbedding(output);\n\n      const durationMs = Date.now() - startTime;\n\n      logger.debug('Generated embedding', {\n        inputLength: text.length,\n        truncated: text.length !== truncated.length,\n        durationMs,\n      });\n\n      return {\n        embedding,\n        durationMs,\n        tokenCount: Math.ceil(truncated.length / 4), // Rough estimate\n      };\n    } catch (error) {\n      const message = error instanceof Error ? error.message : String(error);\n      logger.error('Embedding generation failed', new Error(message));\n      throw new Error(`Failed to generate embedding: ${message}`);\n    }\n  }\n\n  /**\n   * Generate embeddings for multiple texts\n   *\n   * Processes texts in batches for efficiency.\n   *\n   * @param texts - Array of texts to embed\n   * @returns Batch result with embeddings and metadata\n   */\n  async embedBatch(texts: string[]): Promise<BatchEmbeddingResult> {\n    await this.initialize();\n\n    if (!this.pipeline) {\n      throw new Error('Embedding pipeline not initialized');\n    }\n\n    const startTime = Date.now();\n    const results: Float32Array[] = [];\n    const errors: Array<{ index: number; error: string }> = [];\n\n    // Process in batches\n    for (let i = 0; i < texts.length; i += this.config.batchSize) {\n      const batch = texts.slice(i, i + this.config.batchSize);\n      const truncatedBatch = batch.map((t) => this.truncateText(t));\n\n      try {\n        // Process batch\n        const outputs = await this.pipeline(truncatedBatch, {\n          pooling: this.config.pooling,\n          normalize: this.config.normalize,\n        });\n\n        // Extract embeddings from batch output\n        const batchEmbeddings = this.extractBatchEmbeddings(outputs, batch.length);\n        results.push(...batchEmbeddings);\n      } catch (error) {\n        // Fall back to individual processing on batch error\n        logger.warn('Batch embedding failed, falling back to individual', {\n          batchIndex: i / this.config.batchSize,\n        });\n\n        for (let j = 0; j < batch.length; j++) {\n          try {\n            const output = await this.pipeline(truncatedBatch[j], {\n              pooling: this.config.pooling,\n              normalize: this.config.normalize,\n            });\n            results.push(this.extractEmbedding(output));\n          } catch (individualError) {\n            errors.push({\n              index: i + j,\n              error: individualError instanceof Error ? individualError.message : String(individualError),\n            });\n            // Push zero vector as placeholder\n            results.push(new Float32Array(this.config.dimensions));\n          }\n        }\n      }\n    }\n\n    const durationMs = Date.now() - startTime;\n\n    logger.info('Batch embedding completed', {\n      totalTexts: texts.length,\n      successCount: texts.length - errors.length,\n      errorCount: errors.length,\n      durationMs,\n      avgTimePerText: durationMs / texts.length,\n    });\n\n    return {\n      embeddings: results,\n      durationMs,\n      successCount: texts.length - errors.length,\n      errorCount: errors.length,\n      errors: errors.length > 0 ? errors : undefined,\n    };\n  }\n\n  /**\n   * Truncate text to maximum length\n   *\n   * @param text - Text to truncate\n   * @returns Truncated text\n   */\n  private truncateText(text: string): string {\n    if (text.length <= this.config.maxLength * 4) {\n      return text;\n    }\n    // Truncate at word boundary if possible\n    const truncated = text.slice(0, this.config.maxLength * 4);\n    const lastSpace = truncated.lastIndexOf(' ');\n    if (lastSpace > this.config.maxLength * 2) {\n      return truncated.slice(0, lastSpace);\n    }\n    return truncated;\n  }\n\n  /**\n   * Extract embedding from pipeline output\n   *\n   * @param output - Pipeline output tensor\n   * @returns Float32Array embedding\n   */\n  private extractEmbedding(output: unknown): Float32Array {\n    // Handle different output formats from transformers.js\n    if (output && typeof output === 'object') {\n      const outputObj = output as Record<string, unknown>;\n\n      // Check for .data property (Tensor object)\n      if ('data' in outputObj && outputObj.data) {\n        const data = outputObj.data;\n        if (data instanceof Float32Array) {\n          return data.slice(0, this.config.dimensions);\n        }\n        if (ArrayBuffer.isView(data)) {\n          return new Float32Array(data.buffer, data.byteOffset, this.config.dimensions);\n        }\n        if (Array.isArray(data)) {\n          return new Float32Array(data.slice(0, this.config.dimensions));\n        }\n      }\n\n      // Check for nested array structure\n      if (Array.isArray(outputObj)) {\n        const flattened = this.flattenArray(outputObj);\n        return new Float32Array(flattened.slice(0, this.config.dimensions));\n      }\n    }\n\n    throw new Error('Unexpected output format from embedding pipeline');\n  }\n\n  /**\n   * Extract multiple embeddings from batch output\n   *\n   * @param output - Pipeline output tensor for batch\n   * @param batchSize - Number of items in the batch\n   * @returns Array of embeddings\n   */\n  private extractBatchEmbeddings(output: unknown, batchSize: number): Float32Array[] {\n    const results: Float32Array[] = [];\n\n    if (output && typeof output === 'object') {\n      const outputObj = output as Record<string, unknown>;\n\n      if ('data' in outputObj && outputObj.data) {\n        const data = outputObj.data;\n        let dataArray: Float32Array;\n\n        if (data instanceof Float32Array) {\n          dataArray = data;\n        } else if (ArrayBuffer.isView(data)) {\n          dataArray = new Float32Array(data.buffer, data.byteOffset);\n        } else if (Array.isArray(data)) {\n          dataArray = new Float32Array(data as number[]);\n        } else {\n          throw new Error('Unexpected data format in batch output');\n        }\n\n        // Split the data array into individual embeddings\n        for (let i = 0; i < batchSize; i++) {\n          const start = i * this.config.dimensions;\n          const embedding = dataArray.slice(start, start + this.config.dimensions);\n          results.push(embedding);\n        }\n\n        return results;\n      }\n    }\n\n    throw new Error('Unexpected output format from batch embedding pipeline');\n  }\n\n  /**\n   * Flatten nested array\n   *\n   * @param arr - Array to flatten\n   * @returns Flattened number array\n   */\n  private flattenArray(arr: unknown[]): number[] {\n    const result: number[] = [];\n    for (const item of arr) {\n      if (Array.isArray(item)) {\n        result.push(...this.flattenArray(item));\n      } else if (typeof item === 'number') {\n        result.push(item);\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Get the embedding dimensions\n   *\n   * @returns Number of dimensions in generated embeddings\n   */\n  getDimensions(): number {\n    return this.config.dimensions;\n  }\n\n  /**\n   * Get the current configuration\n   *\n   * @returns Copy of the current configuration\n   */\n  getConfig(): EmbeddingConfig {\n    return { ...this.config };\n  }\n\n  /**\n   * Check if the service is initialized\n   *\n   * @returns True if initialized\n   */\n  isReady(): boolean {\n    return this.isInitialized;\n  }\n\n  /**\n   * Get model information\n   *\n   * @returns Model details\n   */\n  getModelInfo(): { model: string; dimensions: number; quantized: boolean } {\n    return {\n      model: this.config.model,\n      dimensions: this.config.dimensions,\n      quantized: this.config.quantized,\n    };\n  }\n}\n\n/**\n * Create an embedding service instance\n *\n * Factory function for creating embedding services.\n *\n * @param config - Optional configuration overrides\n * @returns New EmbeddingService instance\n *\n * @example\n * ```typescript\n * // Default configuration (all-MiniLM-L6-v2, 384 dimensions)\n * const service = createEmbeddingService();\n *\n * // Custom configuration\n * const customService = createEmbeddingService({\n *   model: 'Xenova/all-MiniLM-L12-v2',\n *   dimensions: 384,\n *   batchSize: 64,\n * });\n * ```\n */\nexport function createEmbeddingService(config?: Partial<EmbeddingConfig>): EmbeddingService {\n  return new EmbeddingService(config);\n}\n\n/**\n * Default embedding service singleton\n * Created lazily on first use\n */\nlet defaultService: EmbeddingService | null = null;\n\n/**\n * Get the default embedding service\n *\n * Returns a shared singleton instance for convenience.\n * Use createEmbeddingService() for custom configurations.\n *\n * @returns Default EmbeddingService instance\n */\nexport function getDefaultEmbeddingService(): EmbeddingService {\n  if (!defaultService) {\n    defaultService = new EmbeddingService();\n  }\n  return defaultService;\n}\n"],"names":[],"mappings":";;;;;;;;AAYe,aAAa,mBAAmB;"}