@sparkleideas/embeddings 3.0.0-alpha.17 → 3.0.0-alpha.27

package/dist/embedding-service.d.ts

@@ -1,113 +0,0 @@
-/**
- * V3 Embedding Service Implementation
- *
- * Production embedding service aligned with agentic-flow@alpha:
- * - OpenAI provider (text-embedding-3-small/large)
- * - Transformers.js provider (local ONNX models)
- * - Mock provider (development/testing)
- *
- * Performance Targets:
- * - Single embedding: <100ms (API), <50ms (local)
- * - Batch embedding: <500ms for 10 items
- * - Cache hit: <1ms
- */
-import { EventEmitter } from 'events';
-import type { EmbeddingProvider, EmbeddingConfig, OpenAIEmbeddingConfig, TransformersEmbeddingConfig, MockEmbeddingConfig, EmbeddingResult, BatchEmbeddingResult, IEmbeddingService, EmbeddingEvent, EmbeddingEventListener, SimilarityMetric, SimilarityResult } from './types.js';
-declare class LRUCache<K, V> {
-    private readonly maxSize;
-    private cache;
-    private hits;
-    private misses;
-    constructor(maxSize: number);
-    get(key: K): V | undefined;
-    set(key: K, value: V): void;
-    clear(): void;
-    get size(): number;
-    get hitRate(): number;
-    getStats(): {
-        size: number;
-        maxSize: number;
-        hits: number;
-        misses: number;
-        hitRate: number;
-    };
-}
-declare abstract class BaseEmbeddingService extends EventEmitter implements IEmbeddingService {
-    protected readonly config: EmbeddingConfig;
-    abstract readonly provider: EmbeddingProvider;
-    protected cache: LRUCache<string, Float32Array>;
-    protected embeddingListeners: Set<EmbeddingEventListener>;
-    constructor(config: EmbeddingConfig);
-    abstract embed(text: string): Promise<EmbeddingResult>;
-    abstract embedBatch(texts: string[]): Promise<BatchEmbeddingResult>;
-    protected emitEvent(event: EmbeddingEvent): void;
-    addEventListener(listener: EmbeddingEventListener): void;
-    removeEventListener(listener: EmbeddingEventListener): void;
-    clearCache(): void;
-    getCacheStats(): {
-        size: number;
-        maxSize: number;
-        hitRate: number;
-    };
-    shutdown(): Promise<void>;
-}
-export declare class OpenAIEmbeddingService extends BaseEmbeddingService {
-    readonly provider: EmbeddingProvider;
-    private readonly apiKey;
-    private readonly model;
-    private readonly baseURL;
-    private readonly timeout;
-    private readonly maxRetries;
-    constructor(config: OpenAIEmbeddingConfig);
-    embed(text: string): Promise<EmbeddingResult>;
-    embedBatch(texts: string[]): Promise<BatchEmbeddingResult>;
-    private callOpenAI;
-}
-export declare class TransformersEmbeddingService extends BaseEmbeddingService {
-    readonly provider: EmbeddingProvider;
-    private pipeline;
-    private readonly modelName;
-    private initialized;
-    constructor(config: TransformersEmbeddingConfig);
-    private initialize;
-    embed(text: string): Promise<EmbeddingResult>;
-    embedBatch(texts: string[]): Promise<BatchEmbeddingResult>;
-}
-export declare class MockEmbeddingService extends BaseEmbeddingService {
-    readonly provider: EmbeddingProvider;
-    private readonly dimensions;
-    private readonly simulatedLatency;
-    constructor(config: MockEmbeddingConfig);
-    embed(text: string): Promise<EmbeddingResult>;
-    embedBatch(texts: string[]): Promise<BatchEmbeddingResult>;
-    /**
-     * Generate deterministic hash-based embedding
-     */
-    private hashEmbedding;
-}
-/**
- * Create embedding service based on configuration
- */
-export declare function createEmbeddingService(config: EmbeddingConfig): IEmbeddingService;
-/**
- * Convenience function for quick embeddings
- */
-export declare function getEmbedding(text: string, config?: Partial<EmbeddingConfig>): Promise<Float32Array | number[]>;
-/**
- * Compute cosine similarity between two embeddings
- */
-export declare function cosineSimilarity(a: Float32Array | number[], b: Float32Array | number[]): number;
-/**
- * Compute Euclidean distance between two embeddings
- */
-export declare function euclideanDistance(a: Float32Array | number[], b: Float32Array | number[]): number;
-/**
- * Compute dot product between two embeddings
- */
-export declare function dotProduct(a: Float32Array | number[], b: Float32Array | number[]): number;
-/**
- * Compute similarity using specified metric
- */
-export declare function computeSimilarity(a: Float32Array | number[], b: Float32Array | number[], metric?: SimilarityMetric): SimilarityResult;
-export {};
-//# sourceMappingURL=embedding-service.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"embedding-service.d.ts","sourceRoot":"","sources":["../src/embedding-service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,KAAK,EACV,iBAAiB,EACjB,eAAe,EACf,qBAAqB,EACrB,2BAA2B,EAC3B,mBAAmB,EACnB,eAAe,EACf,oBAAoB,EACpB,iBAAiB,EACjB,cAAc,EACd,sBAAsB,EACtB,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAMpB,cAAM,QAAQ,CAAC,CAAC,EAAE,CAAC;IAKL,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJpC,OAAO,CAAC,KAAK,CAAwB;IACrC,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,MAAM,CAAK;gBAEU,OAAO,EAAE,MAAM;IAE5C,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAa1B,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAa3B,KAAK,IAAI,IAAI;IAMb,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,OAAO,IAAI,MAAM,CAGpB;IAED,QAAQ;;;;;;;CAST;AAMD,uBAAe,oBAAqB,SAAQ,YAAa,YAAW,iBAAiB;IAKvE,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,eAAe;IAJtD,QAAQ,CAAC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IAC9C,SAAS,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAChD,SAAS,CAAC,kBAAkB,EAAE,GAAG,CAAC,sBAAsB,CAAC,CAAa;gBAEvC,MAAM,EAAE,eAAe;IAKtD,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IACtD,QAAQ,CAAC,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAEnE,SAAS,CAAC,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IAWhD,gBAAgB,CAAC,QAAQ,EAAE,sBAAsB,GAAG,IAAI;IAIxD,mBAAmB,CAAC,QAAQ,EAAE,sBAAsB,GAAG,IAAI;IAI3D,UAAU,IAAI,IAAI;IAMlB,aAAa;;;;;IASP,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAIhC;AAMD,qBAAa,sBAAuB,SAAQ,oBAAoB;IAC9D,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAY;IAChD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;gBAExB,MAAM,EAAE,qBAAqB;IASnC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAwC7C,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,oBAAoB,CAAC;YA6DlD,UAAU;CA+CzB;AAMD,qBAAa,4BAA6B,SAAQ,oBAAoB;IACpE,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAkB;IACtD,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,WAAW,CAAS;gBAEhB,MAAM,EAAE,2BAA2B;YAKjC,UAAU;IAYlB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAsC7C,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,oBAAoB,CAAC;CAoCjE;AAMD,qBAAa,oBAAqB,SAAQ,oBAAoB;IAC5D,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAU;IAC9C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAS;gBAE9B,MAAM,EAAE,mBAAmB;IAMjC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAgC7C,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAiChE;;OAEG;IACH,OAAO,CAAC,aAAa;CAyBtB;AAMD;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,eAAe,GAAG,iBAAiB,CAYjF;AAED;;GAEG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,GAChC,OAAO,CAAC,YAAY,GAAG,MAAM,EAAE,CAAC,CAalC;AAMD;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,YAAY,GAAG,MAAM,EAAE,EAC1B,CAAC,EAAE,YAAY,GAAG,MAAM,EAAE,GACzB,MAAM,CAiBR;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,YAAY,GAAG,MAAM,EAAE,EAC1B,CAAC,EAAE,YAAY,GAAG,MAAM,EAAE,GACzB,MAAM,CAYR;AAED;;GAEG;AACH,wBAAgB,UAAU,CACxB,CAAC,EAAE,YAAY,GAAG,MAAM,EAAE,EAC1B,CAAC,EAAE,YAAY,GAAG,MAAM,EAAE,GACzB,MAAM,CAWR;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,YAAY,GAAG,MAAM,EAAE,EAC1B,CAAC,EAAE,YAAY,GAAG,MAAM,EAAE,EAC1B,MAAM,GAAE,gBAA2B,GAClC,gBAAgB,CAYlB"}

package/dist/embedding-service.js

@@ -1,543 +0,0 @@
-/**
- * V3 Embedding Service Implementation
- *
- * Production embedding service aligned with agentic-flow@alpha:
- * - OpenAI provider (text-embedding-3-small/large)
- * - Transformers.js provider (local ONNX models)
- * - Mock provider (development/testing)
- *
- * Performance Targets:
- * - Single embedding: <100ms (API), <50ms (local)
- * - Batch embedding: <500ms for 10 items
- * - Cache hit: <1ms
- */
-import { EventEmitter } from 'events';
-// ============================================================================
-// LRU Cache Implementation
-// ============================================================================
-class LRUCache {
-    maxSize;
-    cache = new Map();
-    hits = 0;
-    misses = 0;
-    constructor(maxSize) {
-        this.maxSize = maxSize;
-    }
-    get(key) {
-        const value = this.cache.get(key);
-        if (value !== undefined) {
-            // Move to end (most recently used)
-            this.cache.delete(key);
-            this.cache.set(key, value);
-            this.hits++;
-            return value;
-        }
-        this.misses++;
-        return undefined;
-    }
-    set(key, value) {
-        if (this.cache.has(key)) {
-            this.cache.delete(key);
-        }
-        else if (this.cache.size >= this.maxSize) {
-            // Remove oldest (first) entry
-            const firstKey = this.cache.keys().next().value;
-            if (firstKey !== undefined) {
-                this.cache.delete(firstKey);
-            }
-        }
-        this.cache.set(key, value);
-    }
-    clear() {
-        this.cache.clear();
-        this.hits = 0;
-        this.misses = 0;
-    }
-    get size() {
-        return this.cache.size;
-    }
-    get hitRate() {
-        const total = this.hits + this.misses;
-        return total > 0 ? this.hits / total : 0;
-    }
-    getStats() {
-        return {
-            size: this.cache.size,
-            maxSize: this.maxSize,
-            hits: this.hits,
-            misses: this.misses,
-            hitRate: this.hitRate,
-        };
-    }
-}
-// ============================================================================
-// Base Embedding Service
-// ============================================================================
-class BaseEmbeddingService extends EventEmitter {
-    config;
-    cache;
-    embeddingListeners = new Set();
-    constructor(config) {
-        super();
-        this.config = config;
-        this.cache = new LRUCache(config.cacheSize ?? 1000);
-    }
-    emitEvent(event) {
-        for (const listener of this.embeddingListeners) {
-            try {
-                listener(event);
-            }
-            catch (error) {
-                console.error('Error in embedding event listener:', error);
-            }
-        }
-        this.emit(event.type, event);
-    }
-    addEventListener(listener) {
-        this.embeddingListeners.add(listener);
-    }
-    removeEventListener(listener) {
-        this.embeddingListeners.delete(listener);
-    }
-    clearCache() {
-        const size = this.cache.size;
-        this.cache.clear();
-        this.emitEvent({ type: 'cache_eviction', size });
-    }
-    getCacheStats() {
-        const stats = this.cache.getStats();
-        return {
-            size: stats.size,
-            maxSize: stats.maxSize,
-            hitRate: stats.hitRate,
-        };
-    }
-    async shutdown() {
-        this.clearCache();
-        this.embeddingListeners.clear();
-    }
-}
-// ============================================================================
-// OpenAI Embedding Service
-// ============================================================================
-export class OpenAIEmbeddingService extends BaseEmbeddingService {
-    provider = 'openai';
-    apiKey;
-    model;
-    baseURL;
-    timeout;
-    maxRetries;
-    constructor(config) {
-        super(config);
-        this.apiKey = config.apiKey;
-        this.model = config.model ?? 'text-embedding-3-small';
-        this.baseURL = config.baseURL ?? 'https://api.openai.com/v1/embeddings';
-        this.timeout = config.timeout ?? 30000;
-        this.maxRetries = config.maxRetries ?? 3;
-    }
-    async embed(text) {
-        // Check cache
-        const cached = this.cache.get(text);
-        if (cached) {
-            this.emitEvent({ type: 'cache_hit', text });
-            return {
-                embedding: cached,
-                latencyMs: 0,
-                cached: true,
-            };
-        }
-        this.emitEvent({ type: 'embed_start', text });
-        const startTime = performance.now();
-        try {
-            const response = await this.callOpenAI([text]);
-            const embedding = new Float32Array(response.data[0].embedding);
-            // Cache result
-            this.cache.set(text, embedding);
-            const latencyMs = performance.now() - startTime;
-            this.emitEvent({ type: 'embed_complete', text, latencyMs });
-            return {
-                embedding,
-                latencyMs,
-                usage: {
-                    promptTokens: response.usage?.prompt_tokens ?? 0,
-                    totalTokens: response.usage?.total_tokens ?? 0,
-                },
-            };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            this.emitEvent({ type: 'embed_error', text, error: message });
-            throw new Error(`OpenAI embedding failed: ${message}`);
-        }
-    }
-    async embedBatch(texts) {
-        this.emitEvent({ type: 'batch_start', count: texts.length });
-        const startTime = performance.now();
-        // Check cache for each text
-        const cached = [];
-        const uncached = [];
-        texts.forEach((text, index) => {
-            const cachedEmbedding = this.cache.get(text);
-            if (cachedEmbedding) {
-                cached.push({ index, embedding: cachedEmbedding });
-                this.emitEvent({ type: 'cache_hit', text });
-            }
-            else {
-                uncached.push({ index, text });
-            }
-        });
-        // Fetch uncached embeddings
-        let apiEmbeddings = [];
-        let usage = { promptTokens: 0, totalTokens: 0 };
-        if (uncached.length > 0) {
-            const response = await this.callOpenAI(uncached.map(u => u.text));
-            apiEmbeddings = response.data.map(d => new Float32Array(d.embedding));
-            // Cache results
-            uncached.forEach((item, i) => {
-                this.cache.set(item.text, apiEmbeddings[i]);
-            });
-            usage = {
-                promptTokens: response.usage?.prompt_tokens ?? 0,
-                totalTokens: response.usage?.total_tokens ?? 0,
-            };
-        }
-        // Reconstruct result array in original order
-        const embeddings = new Array(texts.length);
-        cached.forEach(c => {
-            embeddings[c.index] = c.embedding;
-        });
-        uncached.forEach((u, i) => {
-            embeddings[u.index] = apiEmbeddings[i];
-        });
-        const totalLatencyMs = performance.now() - startTime;
-        this.emitEvent({ type: 'batch_complete', count: texts.length, latencyMs: totalLatencyMs });
-        return {
-            embeddings,
-            totalLatencyMs,
-            avgLatencyMs: totalLatencyMs / texts.length,
-            usage,
-            cacheStats: {
-                hits: cached.length,
-                misses: uncached.length,
-            },
-        };
-    }
-    async callOpenAI(texts) {
-        const config = this.config;
-        for (let attempt = 0; attempt < this.maxRetries; attempt++) {
-            try {
-                const controller = new AbortController();
-                const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-                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: config.dimensions,
-                    }),
-                    signal: controller.signal,
-                });
-                clearTimeout(timeoutId);
-                if (!response.ok) {
-                    const error = await response.text();
-                    throw new Error(`OpenAI API error: ${response.status} - ${error}`);
-                }
-                return await response.json();
-            }
-            catch (error) {
-                if (attempt === this.maxRetries - 1) {
-                    throw error;
-                }
-                // Exponential backoff
-                await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 100));
-            }
-        }
-        throw new Error('Max retries exceeded');
-    }
-}
-// ============================================================================
-// Transformers.js Embedding Service
-// ============================================================================
-export class TransformersEmbeddingService extends BaseEmbeddingService {
-    provider = 'transformers';
-    pipeline = null;
-    modelName;
-    initialized = false;
-    constructor(config) {
-        super(config);
-        this.modelName = config.model ?? 'Xenova/all-MiniLM-L6-v2';
-    }
-    async initialize() {
-        if (this.initialized)
-            return;
-        try {
-            const { pipeline } = await import('@xenova/transformers');
-            this.pipeline = await pipeline('feature-extraction', this.modelName);
-            this.initialized = true;
-        }
-        catch (error) {
-            throw new Error(`Failed to initialize transformers.js: ${error}`);
-        }
-    }
-    async embed(text) {
-        await this.initialize();
-        // Check cache
-        const cached = this.cache.get(text);
-        if (cached) {
-            this.emitEvent({ type: 'cache_hit', text });
-            return {
-                embedding: cached,
-                latencyMs: 0,
-                cached: true,
-            };
-        }
-        this.emitEvent({ type: 'embed_start', text });
-        const startTime = performance.now();
-        try {
-            const output = await this.pipeline(text, { pooling: 'mean', normalize: true });
-            const embedding = new Float32Array(output.data);
-            // Cache result
-            this.cache.set(text, embedding);
-            const latencyMs = performance.now() - startTime;
-            this.emitEvent({ type: 'embed_complete', text, latencyMs });
-            return {
-                embedding,
-                latencyMs,
-            };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            this.emitEvent({ type: 'embed_error', text, error: message });
-            throw new Error(`Transformers.js embedding failed: ${message}`);
-        }
-    }
-    async embedBatch(texts) {
-        await this.initialize();
-        this.emitEvent({ type: 'batch_start', count: texts.length });
-        const startTime = performance.now();
-        const embeddings = [];
-        let cacheHits = 0;
-        for (const text of texts) {
-            const cached = this.cache.get(text);
-            if (cached) {
-                embeddings.push(cached);
-                cacheHits++;
-                this.emitEvent({ type: 'cache_hit', text });
-            }
-            else {
-                const output = await this.pipeline(text, { pooling: 'mean', normalize: true });
-                const embedding = new Float32Array(output.data);
-                this.cache.set(text, embedding);
-                embeddings.push(embedding);
-            }
-        }
-        const totalLatencyMs = performance.now() - startTime;
-        this.emitEvent({ type: 'batch_complete', count: texts.length, latencyMs: totalLatencyMs });
-        return {
-            embeddings,
-            totalLatencyMs,
-            avgLatencyMs: totalLatencyMs / texts.length,
-            cacheStats: {
-                hits: cacheHits,
-                misses: texts.length - cacheHits,
-            },
-        };
-    }
-}
-// ============================================================================
-// Mock Embedding Service
-// ============================================================================
-export class MockEmbeddingService extends BaseEmbeddingService {
-    provider = 'mock';
-    dimensions;
-    simulatedLatency;
-    constructor(config) {
-        super(config);
-        this.dimensions = config.dimensions ?? 384;
-        this.simulatedLatency = config.simulatedLatency ?? 0;
-    }
-    async embed(text) {
-        // Check cache
-        const cached = this.cache.get(text);
-        if (cached) {
-            this.emitEvent({ type: 'cache_hit', text });
-            return {
-                embedding: cached,
-                latencyMs: 0,
-                cached: true,
-            };
-        }
-        this.emitEvent({ type: 'embed_start', text });
-        const startTime = performance.now();
-        // Simulate latency
-        if (this.simulatedLatency > 0) {
-            await new Promise(resolve => setTimeout(resolve, this.simulatedLatency));
-        }
-        const embedding = this.hashEmbedding(text);
-        this.cache.set(text, embedding);
-        const latencyMs = performance.now() - startTime;
-        this.emitEvent({ type: 'embed_complete', text, latencyMs });
-        return {
-            embedding,
-            latencyMs,
-        };
-    }
-    async embedBatch(texts) {
-        this.emitEvent({ type: 'batch_start', count: texts.length });
-        const startTime = performance.now();
-        const embeddings = [];
-        let cacheHits = 0;
-        for (const text of texts) {
-            const cached = this.cache.get(text);
-            if (cached) {
-                embeddings.push(cached);
-                cacheHits++;
-            }
-            else {
-                const embedding = this.hashEmbedding(text);
-                this.cache.set(text, embedding);
-                embeddings.push(embedding);
-            }
-        }
-        const totalLatencyMs = performance.now() - startTime;
-        this.emitEvent({ type: 'batch_complete', count: texts.length, latencyMs: totalLatencyMs });
-        return {
-            embeddings,
-            totalLatencyMs,
-            avgLatencyMs: totalLatencyMs / texts.length,
-            cacheStats: {
-                hits: cacheHits,
-                misses: texts.length - cacheHits,
-            },
-        };
-    }
-    /**
-     * Generate deterministic hash-based embedding
-     */
-    hashEmbedding(text) {
-        const embedding = new Float32Array(this.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 < this.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));
-        for (let i = 0; i < this.dimensions; i++) {
-            embedding[i] /= norm;
-        }
-        return embedding;
-    }
-}
-// ============================================================================
-// Factory Functions
-// ============================================================================
-/**
- * Create embedding service based on configuration
- */
-export function createEmbeddingService(config) {
-    switch (config.provider) {
-        case 'openai':
-            return new OpenAIEmbeddingService(config);
-        case 'transformers':
-            return new TransformersEmbeddingService(config);
-        case 'mock':
-            return new MockEmbeddingService(config);
-        default:
-            console.warn(`Unknown provider, using mock`);
-            return new MockEmbeddingService({ provider: 'mock', dimensions: 384 });
-    }
-}
-/**
- * Convenience function for quick embeddings
- */
-export async function getEmbedding(text, config) {
-    const service = createEmbeddingService({
-        provider: 'mock',
-        dimensions: 384,
-        ...config,
-    });
-    try {
-        const result = await service.embed(text);
-        return result.embedding;
-    }
-    finally {
-        await service.shutdown();
-    }
-}
-// ============================================================================
-// Similarity Functions
-// ============================================================================
-/**
- * Compute cosine similarity between two embeddings
- */
-export function cosineSimilarity(a, b) {
-    if (a.length !== b.length) {
-        throw new Error('Embedding dimensions must match');
-    }
-    let dot = 0;
-    let normA = 0;
-    let normB = 0;
-    for (let i = 0; i < a.length; i++) {
-        dot += a[i] * b[i];
-        normA += a[i] * a[i];
-        normB += b[i] * b[i];
-    }
-    const denom = Math.sqrt(normA) * Math.sqrt(normB);
-    return denom > 0 ? dot / denom : 0;
-}
-/**
- * Compute Euclidean distance between two embeddings
- */
-export function euclideanDistance(a, b) {
-    if (a.length !== b.length) {
-        throw new Error('Embedding dimensions must match');
-    }
-    let sum = 0;
-    for (let i = 0; i < a.length; i++) {
-        const diff = a[i] - b[i];
-        sum += diff * diff;
-    }
-    return Math.sqrt(sum);
-}
-/**
- * Compute dot product between two embeddings
- */
-export function dotProduct(a, b) {
-    if (a.length !== b.length) {
-        throw new Error('Embedding dimensions must match');
-    }
-    let dot = 0;
-    for (let i = 0; i < a.length; i++) {
-        dot += a[i] * b[i];
-    }
-    return dot;
-}
-/**
- * Compute similarity using specified metric
- */
-export function computeSimilarity(a, b, metric = 'cosine') {
-    switch (metric) {
-        case 'cosine':
-            return { score: cosineSimilarity(a, b), metric };
-        case 'euclidean':
-            // Convert distance to similarity (closer = higher score)
-            return { score: 1 / (1 + euclideanDistance(a, b)), metric };
-        case 'dot':
-            return { score: dotProduct(a, b), metric };
-        default:
-            return { score: cosineSimilarity(a, b), metric: 'cosine' };
-    }
-}
-//# sourceMappingURL=embedding-service.js.map