@smythos/sre 1.6.0 → 1.6.8

package/src/subsystems/IO/VectorDB.service/embed/BaseEmbedding.ts

@@ -1,107 +1,107 @@
-import { IVectorDataSourceDto, Source } from '@sre/types/VectorDB.types';
-import { isUrl } from '@sre/utils/index';
-import { SupportedProviders, SupportedModels } from './index';
-import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
-
-export type TEmbeddings = {
-    provider: SupportedProviders;
-    model: SupportedModels[SupportedProviders];
-
-    credentials?: {
-        apiKey: string;
-    };
-    params?: {
-        dimensions?: number;
-        timeout?: number;
-        chunkSize?: number;
-        stripNewLines?: boolean;
-    };
-};
-
-type SupportedSources = 'text' | 'vector' | 'url';
-
-export abstract class BaseEmbedding {
-    model: string;
-    modelName: string;
-    chunkSize = 512;
-    stripNewLines = true;
-    dimensions?: number;
-    timeout?: number;
-
-    constructor(fields?: Partial<TEmbeddings>) {
-        this.model = fields?.model ?? this.model;
-        this.chunkSize = fields?.params?.chunkSize ?? this.chunkSize;
-        this.stripNewLines = fields?.params?.stripNewLines ?? this.stripNewLines;
-        this.timeout = fields?.params?.timeout;
-        this.dimensions = fields?.params?.dimensions;
-    }
-
-    /**
-     * Embed multiple texts and return their vector representations
-     */
-    abstract embedTexts(texts: string[], candidate: AccessCandidate): Promise<number[][]>;
-
-    /**
-     * Embed a single text and return its vector representation
-     */
-    abstract embedText(text: string, candidate: AccessCandidate): Promise<number[]>;
-
-    /**
-     * Utility method to chunk arrays into smaller batches
-     */
-    protected chunkArr<T>(arr: T[], sizePerChunk: number): T[][] {
-        return arr.reduce((chunks, elem, index) => {
-            const chunkIndex = Math.floor(index / sizePerChunk);
-            const chunk = chunks[chunkIndex] || [];
-            chunks[chunkIndex] = chunk.concat([elem]);
-            return chunks;
-        }, [] as T[][]);
-    }
-
-    /**
-     * Utility method to process multiple texts based on stripNewLines setting
-     */
-    protected processTexts(texts: string[]): string[] {
-        return this.stripNewLines ? texts.map((t) => t.replace(/\n/g, ' ')) : texts;
-    }
-
-    public detectSourceType(source: Source): SupportedSources | 'unknown' {
-        if (typeof source === 'string') {
-            return isUrl(source) ? 'url' : 'text';
-        } else if (Array.isArray(source) && source.every((v) => typeof v === 'number')) {
-            return 'vector';
-        } else {
-            return 'unknown';
-        }
-    }
-
-    public transformSource(source: IVectorDataSourceDto[], sourceType: SupportedSources, candidate: AccessCandidate) {
-        //* as the accepted sources increases, you will need to implement the strategy pattern instead of a switch case
-        switch (sourceType) {
-            case 'text': {
-                const texts = source.map((s) => s.source as string);
-
-                return this.embedTexts(texts, candidate).then((vectors) => {
-                    return source.map((s, i) => ({
-                        ...s,
-                        source: vectors[i],
-                        metadata: { ...s.metadata, text: texts[i] },
-                    }));
-                });
-            }
-            case 'vector': {
-                return source;
-            }
-        }
-    }
-
-    // this is a dummy vector used to maximize search distance
-    // we use it to create reserved vectors that store namespace data
-    public get dummyVector(): number[] {
-        //This is good for cosine similarity, but not for euclidean distance
-        //TODO: detect current similarity metric and use the appropriate vector (e.g for euclidean distance, use a vector with all large values like [1e6, 1e6, ..., 1e6])
-        return Array(this.dimensions - 1)
-            .fill(0)
-            .concat([1]);
-    }
-}
+import { IVectorDataSourceDto, Source } from '@sre/types/VectorDB.types';
+import { isUrl } from '@sre/utils/index';
+import { SupportedProviders, SupportedModels } from './index';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+
+export type TEmbeddings = {
+    provider: SupportedProviders;
+    model: SupportedModels[SupportedProviders];
+
+    credentials?: {
+        apiKey: string;
+    };
+    params?: {
+        dimensions?: number;
+        timeout?: number;
+        chunkSize?: number;
+        stripNewLines?: boolean;
+    };
+};
+
+type SupportedSources = 'text' | 'vector' | 'url';
+
+export abstract class BaseEmbedding {
+    model: string;
+    modelName: string;
+    chunkSize = 512;
+    stripNewLines = true;
+    dimensions?: number;
+    timeout?: number;
+
+    constructor(fields?: Partial<TEmbeddings>) {
+        this.model = fields?.model ?? this.model;
+        this.chunkSize = fields?.params?.chunkSize ?? this.chunkSize;
+        this.stripNewLines = fields?.params?.stripNewLines ?? this.stripNewLines;
+        this.timeout = fields?.params?.timeout;
+        this.dimensions = fields?.params?.dimensions;
+    }
+
+    /**
+     * Embed multiple texts and return their vector representations
+     */
+    abstract embedTexts(texts: string[], candidate: AccessCandidate): Promise<number[][]>;
+
+    /**
+     * Embed a single text and return its vector representation
+     */
+    abstract embedText(text: string, candidate: AccessCandidate): Promise<number[]>;
+
+    /**
+     * Utility method to chunk arrays into smaller batches
+     */
+    protected chunkArr<T>(arr: T[], sizePerChunk: number): T[][] {
+        return arr.reduce((chunks, elem, index) => {
+            const chunkIndex = Math.floor(index / sizePerChunk);
+            const chunk = chunks[chunkIndex] || [];
+            chunks[chunkIndex] = chunk.concat([elem]);
+            return chunks;
+        }, [] as T[][]);
+    }
+
+    /**
+     * Utility method to process multiple texts based on stripNewLines setting
+     */
+    protected processTexts(texts: string[]): string[] {
+        return this.stripNewLines ? texts.map((t) => t.replace(/\n/g, ' ')) : texts;
+    }
+
+    public detectSourceType(source: Source): SupportedSources | 'unknown' {
+        if (typeof source === 'string') {
+            return isUrl(source) ? 'url' : 'text';
+        } else if (Array.isArray(source) && source.every((v) => typeof v === 'number')) {
+            return 'vector';
+        } else {
+            return 'unknown';
+        }
+    }
+
+    public transformSource(source: IVectorDataSourceDto[], sourceType: SupportedSources, candidate: AccessCandidate) {
+        //* as the accepted sources increases, you will need to implement the strategy pattern instead of a switch case
+        switch (sourceType) {
+            case 'text': {
+                const texts = source.map((s) => s.source as string);
+
+                return this.embedTexts(texts, candidate).then((vectors) => {
+                    return source.map((s, i) => ({
+                        ...s,
+                        source: vectors[i],
+                        metadata: { ...s.metadata, text: texts[i] },
+                    }));
+                });
+            }
+            case 'vector': {
+                return source;
+            }
+        }
+    }
+
+    // this is a dummy vector used to maximize search distance
+    // we use it to create reserved vectors that store namespace data
+    public get dummyVector(): number[] {
+        //This is good for cosine similarity, but not for euclidean distance
+        //TODO: detect current similarity metric and use the appropriate vector (e.g for euclidean distance, use a vector with all large values like [1e6, 1e6, ..., 1e6])
+        return Array(this.dimensions - 1)
+            .fill(0)
+            .concat([1]);
+    }
+}

package/src/subsystems/IO/VectorDB.service/embed/GoogleEmbedding.ts

@@ -1,118 +1,118 @@
-import { GoogleGenAI } from '@google/genai';
-import { BaseEmbedding, TEmbeddings } from './BaseEmbedding';
-import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
-import { getLLMCredentials } from '@sre/LLMManager/LLM.service/LLMCredentials.helper';
-import { TLLMCredentials, TLLMModel, BasicCredentials } from '@sre/types/LLM.types';
-
-const DEFAULT_MODEL = 'gemini-embedding-001';
-
-export class GoogleEmbeds extends BaseEmbedding {
-    protected client: GoogleGenAI;
-
-    // Keep in sync with Gemini API supported embedding models
-    public static models = ['gemini-embedding-001', 'text-embedding-005', 'text-multilingual-embedding-002'];
-    public canSpecifyDimensions = true;
-
-    constructor(private settings?: Partial<TEmbeddings>) {
-        super({ model: settings?.model ?? DEFAULT_MODEL, ...settings });
-    }
-
-    async embedTexts(texts: string[], candidate: AccessCandidate): Promise<number[][]> {
-        const batches = this.chunkArr(this.processTexts(texts), this.chunkSize);
-
-        const batchRequests = batches.map((batch) => {
-            return this.embed(batch, candidate);
-        });
-        const batchResponses = await Promise.all(batchRequests);
-
-        const embeddings: number[][] = [];
-        for (let i = 0; i < batchResponses.length; i += 1) {
-            const batch = batches[i];
-            const batchResponse = batchResponses[i];
-            for (let j = 0; j < batch.length; j += 1) {
-                embeddings.push(batchResponse[j]);
-            }
-        }
-        return embeddings;
-    }
-
-    async embedText(text: string, candidate: AccessCandidate): Promise<number[]> {
-        const processedText = this.processTexts([text])[0];
-        const embeddings = await this.embed([processedText], candidate);
-        return embeddings[0];
-    }
-
-    protected async embed(texts: string[], candidate: AccessCandidate): Promise<number[][]> {
-        let apiKey: string | undefined;
-
-        // Try to get from credentials first
-        try {
-            const modelInfo: TLLMModel = {
-                provider: 'GoogleAI',
-                modelId: this.model,
-                credentials: (this.settings?.credentials as unknown as TLLMCredentials) || [TLLMCredentials.Internal, TLLMCredentials.Vault],
-            };
-            const credentials = await getLLMCredentials(candidate, modelInfo);
-            apiKey = (credentials as BasicCredentials)?.apiKey;
-        } catch (e) {
-            // If credential system fails, fall back to environment variable
-        }
-
-        // Fall back to environment variable if not found in credentials
-        if (!apiKey) {
-            apiKey = process.env.GOOGLE_AI_API_KEY;
-        }
-
-        if (!apiKey) {
-            throw new Error('Please provide an API key for Google AI embeddings via credentials or GOOGLE_AI_API_KEY environment variable');
-        }
-
-        if (!this.client) {
-            this.client = new GoogleGenAI({ apiKey });
-        }
-
-        try {
-            const outputDimensionality = this.dimensions && Number.isFinite(this.dimensions) ? this.dimensions : undefined;
-
-            // Batch request using the new SDK
-            const res = await this.client.models.embedContent({
-                model: this.model,
-                contents: texts,
-                ...(outputDimensionality ? { outputDimensionality } : {}),
-            });
-
-            // The SDK can return either { embedding } for single or { embeddings } for batch
-            const vectors: number[][] = Array.isArray((res as any).embeddings)
-                ? (res as any).embeddings.map((e: any) => e.values as number[])
-                : [((res as any).embedding?.values as number[]) || []];
-
-            // Enforce dimensions and normalization when requested or when non-3072
-            const targetDim = outputDimensionality;
-            const processed = vectors.map((v) => this.postProcessEmbedding(v, targetDim));
-
-            return processed;
-        } catch (e) {
-            throw new Error(`Google Embeddings API error: ${e.message || e}`);
-        }
-    }
-
-    private postProcessEmbedding(values: number[], targetDim?: number): number[] {
-        let v = Array.isArray(values) ? values.slice() : [];
-        if (targetDim && targetDim > 0) {
-            if (v.length > targetDim) {
-                // SDK ignored smaller dimension: truncate
-                v = v.slice(0, targetDim);
-            } else if (v.length < targetDim) {
-                // SDK returned shorter vector: pad with zeros
-                v = v.concat(Array(targetDim - v.length).fill(0));
-            }
-        }
-        // Normalize for non-default 3072 dims (recommended by Google docs)
-        const needNormalize = (targetDim && targetDim !== 3072) || (!targetDim && v.length !== 3072);
-        if (needNormalize && v.length > 0) {
-            const norm = Math.sqrt(v.reduce((acc, x) => acc + x * x, 0));
-            if (norm > 0) v = v.map((x) => x / norm);
-        }
-        return v;
-    }
-}
+import { GoogleGenAI } from '@google/genai';
+import { BaseEmbedding, TEmbeddings } from './BaseEmbedding';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { getLLMCredentials } from '@sre/LLMManager/LLM.service/LLMCredentials.helper';
+import { TLLMCredentials, TLLMModel, BasicCredentials } from '@sre/types/LLM.types';
+
+const DEFAULT_MODEL = 'gemini-embedding-001';
+
+export class GoogleEmbeds extends BaseEmbedding {
+    protected client: GoogleGenAI;
+
+    // Keep in sync with Gemini API supported embedding models
+    public static models = ['gemini-embedding-001', 'text-embedding-005', 'text-multilingual-embedding-002'];
+    public canSpecifyDimensions = true;
+
+    constructor(private settings?: Partial<TEmbeddings>) {
+        super({ model: settings?.model ?? DEFAULT_MODEL, ...settings });
+    }
+
+    async embedTexts(texts: string[], candidate: AccessCandidate): Promise<number[][]> {
+        const batches = this.chunkArr(this.processTexts(texts), this.chunkSize);
+
+        const batchRequests = batches.map((batch) => {
+            return this.embed(batch, candidate);
+        });
+        const batchResponses = await Promise.all(batchRequests);
+
+        const embeddings: number[][] = [];
+        for (let i = 0; i < batchResponses.length; i += 1) {
+            const batch = batches[i];
+            const batchResponse = batchResponses[i];
+            for (let j = 0; j < batch.length; j += 1) {
+                embeddings.push(batchResponse[j]);
+            }
+        }
+        return embeddings;
+    }
+
+    async embedText(text: string, candidate: AccessCandidate): Promise<number[]> {
+        const processedText = this.processTexts([text])[0];
+        const embeddings = await this.embed([processedText], candidate);
+        return embeddings[0];
+    }
+
+    protected async embed(texts: string[], candidate: AccessCandidate): Promise<number[][]> {
+        let apiKey: string | undefined;
+
+        // Try to get from credentials first
+        try {
+            const modelInfo: TLLMModel = {
+                provider: 'GoogleAI',
+                modelId: this.model,
+                credentials: (this.settings?.credentials as unknown as TLLMCredentials) || [TLLMCredentials.Internal, TLLMCredentials.Vault],
+            };
+            const credentials = await getLLMCredentials(candidate, modelInfo);
+            apiKey = (credentials as BasicCredentials)?.apiKey;
+        } catch (e) {
+            // If credential system fails, fall back to environment variable
+        }
+
+        // Fall back to environment variable if not found in credentials
+        if (!apiKey) {
+            apiKey = process.env.GOOGLE_AI_API_KEY;
+        }
+
+        if (!apiKey) {
+            throw new Error('Please provide an API key for Google AI embeddings via credentials or GOOGLE_AI_API_KEY environment variable');
+        }
+
+        if (!this.client) {
+            this.client = new GoogleGenAI({ apiKey });
+        }
+
+        try {
+            const outputDimensionality = this.dimensions && Number.isFinite(this.dimensions) ? this.dimensions : undefined;
+
+            // Batch request using the new SDK
+            const res = await this.client.models.embedContent({
+                model: this.model,
+                contents: texts,
+                ...(outputDimensionality ? { outputDimensionality } : {}),
+            });
+
+            // The SDK can return either { embedding } for single or { embeddings } for batch
+            const vectors: number[][] = Array.isArray((res as any).embeddings)
+                ? (res as any).embeddings.map((e: any) => e.values as number[])
+                : [((res as any).embedding?.values as number[]) || []];
+
+            // Enforce dimensions and normalization when requested or when non-3072
+            const targetDim = outputDimensionality;
+            const processed = vectors.map((v) => this.postProcessEmbedding(v, targetDim));
+
+            return processed;
+        } catch (e) {
+            throw new Error(`Google Embeddings API error: ${e.message || e}`);
+        }
+    }
+
+    private postProcessEmbedding(values: number[], targetDim?: number): number[] {
+        let v = Array.isArray(values) ? values.slice() : [];
+        if (targetDim && targetDim > 0) {
+            if (v.length > targetDim) {
+                // SDK ignored smaller dimension: truncate
+                v = v.slice(0, targetDim);
+            } else if (v.length < targetDim) {
+                // SDK returned shorter vector: pad with zeros
+                v = v.concat(Array(targetDim - v.length).fill(0));
+            }
+        }
+        // Normalize for non-default 3072 dims (recommended by Google docs)
+        const needNormalize = (targetDim && targetDim !== 3072) || (!targetDim && v.length !== 3072);
+        if (needNormalize && v.length > 0) {
+            const norm = Math.sqrt(v.reduce((acc, x) => acc + x * x, 0));
+            if (norm > 0) v = v.map((x) => x / norm);
+        }
+        return v;
+    }
+}