@smythos/sre 1.5.67 → 1.5.70

package/dist/types/index.d.ts

@@ -160,6 +160,7 @@ export * from './subsystems/IO/VectorDB.service/connectors/MilvusVectorDB.class'
 export * from './subsystems/IO/VectorDB.service/connectors/PineconeVectorDB.class';
 export * from './subsystems/IO/VectorDB.service/connectors/RAMVecrtorDB.class';
 export * from './subsystems/IO/VectorDB.service/embed/BaseEmbedding';
+export * from './subsystems/IO/VectorDB.service/embed/GoogleEmbedding';
 export * from './subsystems/IO/VectorDB.service/embed/index';
 export * from './subsystems/IO/VectorDB.service/embed/OpenAIEmbedding';
 export * from './subsystems/LLMManager/LLM.service/connectors/Anthropic.class';

package/dist/types/subsystems/IO/VectorDB.service/embed/GoogleEmbedding.d.ts

@@ -0,0 +1,14 @@
+import { GoogleGenAI } from '@google/genai';
+import { BaseEmbedding, TEmbeddings } from './BaseEmbedding';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+export declare class GoogleEmbeds extends BaseEmbedding {
+    private settings?;
+    protected client: GoogleGenAI;
+    static models: string[];
+    canSpecifyDimensions: boolean;
+    constructor(settings?: Partial<TEmbeddings>);
+    embedTexts(texts: string[], candidate: AccessCandidate): Promise<number[][]>;
+    embedText(text: string, candidate: AccessCandidate): Promise<number[]>;
+    protected embed(texts: string[], candidate: AccessCandidate): Promise<number[][]>;
+    private postProcessEmbedding;
+}

package/dist/types/subsystems/IO/VectorDB.service/embed/index.d.ts

@@ -1,16 +1,21 @@
 import { OpenAIEmbeds } from './OpenAIEmbedding';
+import { GoogleEmbeds } from './GoogleEmbedding';
 import { TEmbeddings } from './BaseEmbedding';
 declare const supportedProviders: {
     readonly OpenAI: {
         readonly embedder: typeof OpenAIEmbeds;
         readonly models: string[];
     };
+    readonly GoogleAI: {
+        readonly embedder: typeof GoogleEmbeds;
+        readonly models: string[];
+    };
 };
 export type SupportedProviders = keyof typeof supportedProviders;
 export type SupportedModels = {
     [K in SupportedProviders]: (typeof supportedProviders)[K]['models'][number];
 };
 export declare class EmbeddingsFactory {
-    static create(provider: SupportedProviders, config: TEmbeddings): OpenAIEmbeds;
+    static create(provider: SupportedProviders, config: TEmbeddings): OpenAIEmbeds | GoogleEmbeds;
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smythos/sre",
-  "version": "1.5.67",
+  "version": "1.5.70",
   "description": "Smyth Runtime Environment",
   "author": "Alaa-eddine KADDOURI",
   "license": "MIT",

package/src/helpers/Conversation.helper.ts

@@ -281,8 +281,6 @@ export class Conversation extends EventEmitter {
         let _content = '';
         const reqMethods = this._reqMethods;
         const toolsConfig = this._toolsConfig;
-        //deduplicate tools
-        toolsConfig.tools = toolsConfig.tools.filter((tool, index, self) => self.findIndex((t) => t.name === tool.name) === index);
         const endpoints = this._endpoints;
         const baseUrl = this._baseUrl;
         const message_id = 'msg_' + randomUUID();
@@ -832,15 +830,22 @@ export class Conversation extends EventEmitter {
         this._customToolsDeclarations.push(toolDefinition);
         this._customToolsHandlers[tool.name] = tool.handler;
 
+        //deduplicate tools
+
         const llmInference: LLMInference = await LLMInference.getInstance(this.model, AccessCandidate.team(this._teamId));
+        this._customToolsDeclarations = this._customToolsDeclarations.filter(
+            (tool, index, self) => self.findIndex((t) => t.name === tool.name) === index
+        );
         const toolsConfig: any = llmInference.connector.formatToolsConfig({
             type: 'function',
-            toolDefinitions: [toolDefinition],
+            toolDefinitions: this._customToolsDeclarations,
             toolChoice: this.toolChoice,
         });
 
-        if (this._toolsConfig) this._toolsConfig.tools.push(...toolsConfig?.tools);
-        else this._toolsConfig = toolsConfig;
+        //if (this._toolsConfig) this._toolsConfig.tools.push(...toolsConfig?.tools);
+        //else this._toolsConfig = toolsConfig;
+
+        this._toolsConfig = toolsConfig;
     }
     /**
      * updates LLM model, if spec is available, it will update the tools config
@@ -857,15 +862,19 @@ export class Conversation extends EventEmitter {
                 this._baseUrl = this._spec?.servers?.[0].url;
 
                 const functionDeclarations = this.getFunctionDeclarations(this._spec);
-                functionDeclarations.push(...this._customToolsDeclarations);
+                //functionDeclarations.push(...this._customToolsDeclarations);
+                this._customToolsDeclarations.push(...functionDeclarations);
                 const llmInference: LLMInference = await LLMInference.getInstance(this._model, AccessCandidate.team(this._teamId));
                 if (!llmInference.connector) {
                     this.emit('error', 'No connector found for model: ' + this._model);
                     return;
                 }
+                this._customToolsDeclarations = this._customToolsDeclarations.filter(
+                    (tool, index, self) => self.findIndex((t) => t.name === tool.name) === index
+                );
                 this._toolsConfig = llmInference.connector.formatToolsConfig({
                     type: 'function',
-                    toolDefinitions: functionDeclarations,
+                    toolDefinitions: this._customToolsDeclarations,
                     toolChoice: this.toolChoice,
                 });
 

package/src/index.ts

@@ -166,6 +166,7 @@ export * from './subsystems/IO/VectorDB.service/connectors/MilvusVectorDB.class'
 export * from './subsystems/IO/VectorDB.service/connectors/PineconeVectorDB.class';
 export * from './subsystems/IO/VectorDB.service/connectors/RAMVecrtorDB.class';
 export * from './subsystems/IO/VectorDB.service/embed/BaseEmbedding';
+export * from './subsystems/IO/VectorDB.service/embed/GoogleEmbedding';
 export * from './subsystems/IO/VectorDB.service/embed/index';
 export * from './subsystems/IO/VectorDB.service/embed/OpenAIEmbedding';
 export * from './subsystems/LLMManager/LLM.service/connectors/Anthropic.class';

package/src/index.ts.bak

@@ -166,6 +166,7 @@ export * from './subsystems/IO/VectorDB.service/connectors/MilvusVectorDB.class'
 export * from './subsystems/IO/VectorDB.service/connectors/PineconeVectorDB.class';
 export * from './subsystems/IO/VectorDB.service/connectors/RAMVecrtorDB.class';
 export * from './subsystems/IO/VectorDB.service/embed/BaseEmbedding';
+export * from './subsystems/IO/VectorDB.service/embed/GoogleEmbedding';
 export * from './subsystems/IO/VectorDB.service/embed/index';
 export * from './subsystems/IO/VectorDB.service/embed/OpenAIEmbedding';
 export * from './subsystems/LLMManager/LLM.service/connectors/Anthropic.class';

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

@@ -0,0 +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,
+            };
+            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;
+    }
+}

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

@@ -1,4 +1,5 @@
 import { OpenAIEmbeds } from './OpenAIEmbedding';
+import { GoogleEmbeds } from './GoogleEmbedding';
 import { TEmbeddings } from './BaseEmbedding';
 
 // a factory to get the correct embedding provider based on the provider name
@@ -7,6 +8,10 @@ const supportedProviders = {
         embedder: OpenAIEmbeds,
         models: OpenAIEmbeds.models,
     },
+    GoogleAI: {
+        embedder: GoogleEmbeds,
+        models: GoogleEmbeds.models,
+    },
 } as const;
 
 export type SupportedProviders = keyof typeof supportedProviders;