@smythos/sre 1.7.18 → 1.7.20

package/dist/types/Components/RAG/DataSourceCleaner.class.d.ts

@@ -0,0 +1,37 @@
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import Joi from 'joi';
+import { DataSourceComponent } from './DataSourceComponent.class';
+export declare class DataSourceCleaner extends DataSourceComponent {
+    protected configSchema: Joi.ObjectSchema<any>;
+    constructor();
+    init(): void;
+    process(input: any, config: any, agent: Agent): Promise<{
+        _debug: string;
+        Success: boolean;
+        _error?: undefined;
+    } | {
+        _debug: string;
+        _error: any;
+        Success?: undefined;
+    }>;
+    processV1(input: any, config: any, agent: Agent): Promise<{
+        _debug: string;
+        Success: boolean;
+        _error?: undefined;
+    } | {
+        _debug: string;
+        _error: any;
+        Success?: undefined;
+    }>;
+    processV2(input: any, config: any, agent: Agent): Promise<{
+        _debug: string;
+        _error: any;
+        Success?: undefined;
+    } | {
+        _debug: string;
+        Success: boolean;
+        _error?: undefined;
+    }>;
+    validateInput(input: any): Joi.ValidationResult<any>;
+    validateConfigData(data: any): Joi.ValidationResult<any>;
+}

package/dist/types/Components/RAG/DataSourceComponent.class.d.ts

@@ -0,0 +1,30 @@
+import { Component } from '../Component.class';
+import { TEmbeddings } from '@sre/IO/VectorDB.service/embed/BaseEmbedding';
+import { VectorDBConnector } from '@sre/IO/VectorDB.service/VectorDBConnector';
+export type NsRecord = {
+    credentialId: string;
+    embeddings: {
+        dimensions: string;
+        modelId: string;
+    };
+    label: string;
+    createdAt: string;
+};
+export declare enum TDataSourceCompErrorCodes {
+    NAMESPACE_NOT_FOUND = 1,
+    CREDENTIAL_NOT_FOUND = 2,
+    EMBEDDING_CONFIG_ERROR = 3
+}
+export declare class DataSourceCompError extends Error {
+    code: TDataSourceCompErrorCodes;
+    constructor(message: string, code: TDataSourceCompErrorCodes);
+}
+export declare class DataSourceComponent extends Component {
+    constructor();
+    resolveVectorDbConnector(namespace: string | NsRecord, teamId: string): Promise<VectorDBConnector>;
+    buildEmbeddingConfig(embedding: {
+        dimensions: string;
+        modelId: string;
+    }, teamId: string): Promise<TEmbeddings>;
+    static normalizeDsId(providedId: string, teamId: string, namespaceId: string): string;
+}

package/dist/types/Components/RAG/DataSourceIndexer.class.d.ts

@@ -0,0 +1,14 @@
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { DataSourceComponent } from './DataSourceComponent.class';
+import Joi from 'joi';
+export declare class DataSourceIndexer extends DataSourceComponent {
+    private MAX_ALLOWED_URLS_PER_INPUT;
+    protected configSchema: Joi.ObjectSchema<any>;
+    constructor();
+    init(): void;
+    process(input: any, config: any, agent: Agent): Promise<any>;
+    private processV1;
+    private processV2;
+    validateInput(input: any): Joi.ValidationResult<any>;
+    private addDSFromText;
+}

package/dist/types/Components/RAG/DataSourceLookup.class.d.ts

@@ -0,0 +1,36 @@
+import Joi from 'joi';
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { DataSourceComponent } from './DataSourceComponent.class';
+export declare class DataSourceLookup extends DataSourceComponent {
+    protected configSchema: Joi.ObjectSchema<any>;
+    constructor();
+    init(): void;
+    process(input: any, config: any, agent: Agent): Promise<{
+        Results: string[] | {
+            content: string;
+            metadata: any;
+            score?: number;
+        }[];
+        _error: any;
+        _debug: string;
+    }>;
+    processV1(input: any, config: any, agent: Agent): Promise<{
+        Results: string[] | {
+            content: string;
+            metadata: any;
+            score?: number;
+        }[];
+        _error: any;
+        _debug: string;
+    }>;
+    processV2(input: any, config: any, agent: Agent): Promise<{
+        Results: string[] | {
+            content: string;
+            metadata: any;
+            score?: number;
+        }[];
+        _error: any;
+        _debug: string;
+    }>;
+    private parseMetadata;
+}

package/dist/types/helpers/Conversation.helper.d.ts

@@ -1,3 +1,4 @@
+import { LLMInference } from '@sre/LLMManager/LLM.inference';
 import { LLMContext } from '@sre/MemoryManager/LLMContext';
 import { ILLMContextStore, TLLMModel } from '@sre/types/LLM.types';
 import EventEmitter from 'events';
@@ -38,6 +39,8 @@ export declare class Conversation extends EventEmitter {
     set spec(specSource: any);
     set model(model: string | TLLMModel);
     get model(): string | TLLMModel;
+    private _llmInference;
+    get llmInference(): LLMInference;
     constructor(_model: string | TLLMModel, _specSource?: string | Record<string, any>, _settings?: {
         maxContextSize?: number;
         maxOutputTokens?: number;

package/dist/types/subsystems/LLMManager/LLM.inference.d.ts

@@ -2,6 +2,7 @@ import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.cla
 import { IAgent } from '@sre/types/Agent.types';
 import { TLLMModel, TLLMParams } from '@sre/types/LLM.types';
 import { LLMConnector } from './LLM.service/LLMConnector';
+import { IModelsProviderRequest } from './ModelsProvider.service/ModelsProviderConnector';
 type TPromptParams = {
     query?: string;
     contextWindow?: any[];
@@ -10,9 +11,15 @@ type TPromptParams = {
     onFallback?: (data: any) => void;
 };
 export declare class LLMInference {
-    private model;
-    private llmConnector;
-    private modelProviderReq;
+    private _model;
+    get model(): string | TLLMModel;
+    get modelId(): string;
+    private _llmConnector;
+    get llmConnector(): LLMConnector;
+    private _modelProviderReq;
+    get modelProviderReq(): IModelsProviderRequest;
+    private _llmProviderName;
+    get llmProviderName(): string;
     teamId?: string;
     static getInstance(model: string | TLLMModel, candidate: AccessCandidate): Promise<LLMInference>;
     static user(candidate: AccessCandidate): any;

package/dist/types/subsystems/LLMManager/LLM.service/connectors/GoogleAI.class.d.ts

@@ -28,12 +28,14 @@ export declare class GoogleAIConnector extends LLMConnector {
         output_tokens: number;
         input_tokens_audio: number;
         input_tokens_cache_read: number;
+        input_tokens_cache_read_audio: number;
         input_tokens_cache_write: number;
-        reasoning_tokens: number;
         keySource: APIKeySource;
         agentId: string;
         teamId: string;
-        tier: string;
+        inTier: string;
+        outTier: string;
+        crTier: string;
     };
     /**
      * Extract text and image tokens from Google AI usage metadata

package/dist/types/subsystems/Security/ManagedVault.service/connectors/SecretManagerManagedVault.d.ts

@@ -1,17 +1,21 @@
 import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
 import { ACL } from '@sre/Security/AccessControl/ACL.class';
 import { IAccessCandidate } from '@sre/types/ACL.types';
+import { GetSecretValueCommandOutput } from '@aws-sdk/client-secrets-manager';
 import { ManagedVaultConnector } from '../ManagedVaultConnector';
 import { SecretsManagerConfig } from '../../Vault.service/connectors/SecretsManager.class';
 export declare class SecretManagerManagedVault extends ManagedVaultConnector {
     protected _settings: SecretsManagerConfig & {
         vaultName: string;
+        prefix: string;
     };
     name: string;
     scope: string;
     private secretsManager;
+    private prefix;
     constructor(_settings: SecretsManagerConfig & {
         vaultName: string;
+        prefix: string;
     });
     protected get(acRequest: AccessRequest, secretName: string): Promise<any>;
     protected set(acRequest: AccessRequest, secretName: string, value: string): Promise<void>;
@@ -19,4 +23,10 @@ export declare class SecretManagerManagedVault extends ManagedVaultConnector {
     protected exists(acRequest: AccessRequest, secretName: string): Promise<boolean>;
     getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
     private getSecretByName;
+    getVaultKey(secretName: string, teamId: string): string;
+    getFormattedSecret(secret: GetSecretValueCommandOutput): {
+        secretId: string;
+        key: string;
+        value: string;
+    };
 }

package/dist/types/subsystems/Security/Vault.service/connectors/SecretsManager.class.d.ts

@@ -6,15 +6,20 @@ export type SecretsManagerConfig = {
     region: string;
     awsAccessKeyId?: string;
     awsSecretAccessKey?: string;
+    prefix?: string;
 };
 export declare class SecretsManager extends VaultConnector {
     protected _settings: SecretsManagerConfig;
     name: string;
     private secretsManager;
+    private prefix;
     constructor(_settings: SecretsManagerConfig);
     protected get(acRequest: AccessRequest, secretName: string): Promise<any>;
     protected exists(acRequest: AccessRequest, keyId: string): Promise<boolean>;
     protected listKeys(acRequest: AccessRequest): Promise<any[]>;
     getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
     private getSecretByName;
+    private getVaultKey;
+    private getSecretById;
+    private getSecretValue;
 }

package/dist/types/types/LLM.types.d.ts

@@ -300,6 +300,7 @@ export type ToolData = {
     function?: any;
     error?: string;
     callId?: string;
+    thoughtSignature?: string;
 };
 /**
  * Base tool definition interface - only truly common properties
@@ -497,6 +498,7 @@ export interface TGoogleAIRequestBody {
         topK?: number;
         stopSequences?: string[];
         responseMimeType?: string;
+        media_resolution?: 'low' | 'medium' | 'high';
     };
     tools?: any;
     toolConfig?: any;

package/dist/types/utils/array.utils.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Utility method to chunk arrays into smaller batches
+ */
+export declare function chunkArr<T>(arr: T[], sizePerChunk: number): T[][];

package/package.json

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

package/src/helpers/AWSLambdaCode.helper.ts

@@ -134,13 +134,7 @@ export async function zipCode(directory: string) {
 }
 
 export async function createOrUpdateLambdaFunction(functionName, zipFilePath, awsConfigs, envVariables: Record<string, string>) {
-    const client = new LambdaClient({
-        region: awsConfigs.region,
-        credentials: {
-            accessKeyId: awsConfigs.accessKeyId,
-            secretAccessKey: awsConfigs.secretAccessKey,
-        },
-    });
+    const client = getAWSLambdaClient(awsConfigs.region, awsConfigs.accessKeyId, awsConfigs.secretAccessKey)
     const functionContent = fs.readFileSync(zipFilePath);
 
     try {
@@ -168,26 +162,19 @@ export async function createOrUpdateLambdaFunction(functionName, zipFilePath, aw
             let roleArn = '';
             // check if the role exists
             try {
-                const iamClient = new IAMClient({
-                    region: awsConfigs.region,
-                    credentials: { accessKeyId: awsConfigs.accessKeyId, secretAccessKey: awsConfigs.secretAccessKey },
-                });
+                const iamClient = getAWSIAMClient(awsConfigs.region, awsConfigs.accessKeyId, awsConfigs.secretAccessKey);
                 const getRoleCommand = new GetRoleCommand({ RoleName: `smyth-${functionName}-role` });
                 const roleResponse: GetRoleCommandOutput = await iamClient.send(getRoleCommand);
                 roleArn = roleResponse.Role.Arn;
             } catch (error) {
                 if (error.name === 'NoSuchEntityException') {
                     // create role
-                    const iamClient = new IAMClient({
-                        region: awsConfigs.region,
-                        credentials: { accessKeyId: awsConfigs.accessKeyId, secretAccessKey: awsConfigs.secretAccessKey },
-                    });
+                    const iamClient = getAWSIAMClient(awsConfigs.region, awsConfigs.accessKeyId, awsConfigs.secretAccessKey);
                     const createRoleCommand = new CreateRoleCommand({
                         RoleName: `smyth-${functionName}-role`,
                         AssumeRolePolicyDocument: getLambdaRolePolicy(),
                     });
                     const roleResponse: CreateRoleCommandOutput = await iamClient.send(createRoleCommand);
-                 
                     await waitForRoleDeploymentStatus(`smyth-${functionName}-role`, iamClient);
                     roleArn = roleResponse.Role.Arn;
                 } else {
@@ -231,7 +218,7 @@ function updateLambdaFunctionConfiguration(client: LambdaClient, functionName: s
 
 async function createLambdaFunction(client: LambdaClient, functionParams: any, maxRetries: number = 5): Promise<void> {
     let lastError: Error | null = null;
-    
+
     for (let attempt = 1; attempt <= maxRetries; attempt++) {
         try {
             const functionCreateCommand = new CreateFunctionCommand(functionParams);
@@ -241,7 +228,6 @@ async function createLambdaFunction(client: LambdaClient, functionParams: any, m
             lastError = error;
             // Check if this is a role trust policy error
             if (error?.message?.includes('cannot be assumed by Lambda')) {
-                
                 if (attempt < maxRetries) {
                     // Exponential backoff: 2^attempt seconds (2, 4, 8, 16, 32 seconds)
                     const waitTime = Math.pow(2, attempt) * 1000;
@@ -249,12 +235,11 @@ async function createLambdaFunction(client: LambdaClient, functionParams: any, m
                     continue;
                 }
             }
-            
             // For other errors or if we've exhausted retries, throw immediately
             throw error;
         }
     }
-    
+
     // If we get here, all retries failed
     throw lastError || new Error('Lambda function creation failed after all retry attempts');
 }
@@ -262,15 +247,15 @@ async function createLambdaFunction(client: LambdaClient, functionParams: any, m
 export async function waitForRoleDeploymentStatus(roleName, client): Promise<boolean> {
     return new Promise((resolve, reject) => {
         const interval = setInterval(async () => {
-                const getRoleCommand = new GetRoleCommand({ RoleName: roleName });
-                const roleResponse = await client.send(getRoleCommand);
-
-                // Check if role exists and has assume role policy document
-                if (roleResponse.Role && roleResponse.Role.AssumeRolePolicyDocument) {
-                    clearInterval(interval);
-                    setTimeout(() => resolve(true), 2000);
-                    return;
-                }
+            const getRoleCommand = new GetRoleCommand({ RoleName: roleName });
+            const roleResponse = await client.send(getRoleCommand);
+
+            // Check if role exists and has assume role policy document
+            if (roleResponse.Role && roleResponse.Role.AssumeRolePolicyDocument) {
+                clearInterval(interval);
+                setTimeout(() => resolve(true), 2000);
+                return;
+            }
         }, 2000); // Check every 2 seconds
     });
 }
@@ -319,15 +304,7 @@ export async function invokeLambdaFunction(
     awsCredentials: AWSCredentials & AWSRegionConfig
 ): Promise<any> {
     try {
-        const client = new LambdaClient({
-            region: awsCredentials.region as string,
-            ...(awsCredentials.accessKeyId && {
-                credentials: {
-                    accessKeyId: awsCredentials.accessKeyId as string,
-                    secretAccessKey: awsCredentials.secretAccessKey as string,
-                },
-            }),
-        });
+        const client = getAWSLambdaClient(awsCredentials.region, awsCredentials.accessKeyId, awsCredentials.secretAccessKey);
 
         const invokeCommand = new InvokeCommand({
             FunctionName: functionName,
@@ -347,13 +324,7 @@ export async function invokeLambdaFunction(
 
 export async function getDeployedFunction(functionName: string, awsConfigs: AWSCredentials & AWSRegionConfig) {
     try {
-        const client = new LambdaClient({
-            region: awsConfigs.region as string,
-            credentials: {
-                accessKeyId: awsConfigs.accessKeyId as string,
-                secretAccessKey: awsConfigs.secretAccessKey as string,
-            },
-        });
+        const client = getAWSLambdaClient(awsConfigs.region as string, awsConfigs.accessKeyId as string, awsConfigs.secretAccessKey as string);
         const getFunctionCommand = new GetFunctionCommand({ FunctionName: functionName });
         const lambdaResponse: GetFunctionCommandOutput = await client.send(getFunctionCommand);
         return {
@@ -392,6 +363,30 @@ export async function getLambdaCredentials(agent: IAgent, config: any): Promise<
     return awsCredentials;
 }
 
+function getAWSLambdaClient(region: string, accessKeyId?: string, secretAccessKey?: string) {
+    return new LambdaClient({
+        region,
+        ...(accessKeyId && secretAccessKey && {
+            credentials: {
+                accessKeyId,
+                secretAccessKey,
+            },
+        }),
+    });
+}
+
+function getAWSIAMClient(region: string, accessKeyId?: string, secretAccessKey?: string) {
+    return new IAMClient({
+        region,
+        ...(accessKeyId && secretAccessKey && {
+            credentials: {
+                accessKeyId,
+                secretAccessKey,
+            },
+        }),
+    });
+}
+
 export function calculateExecutionCost(executionTime: number) {
     // executionTime in milliseconds
     const cost = (executionTime / 1000) * Number(PER_SECOND_COST);

package/src/helpers/Conversation.helper.ts

@@ -117,6 +117,11 @@ export class Conversation extends EventEmitter {
         return this._model;
     }
 
+    private _llmInference: LLMInference;
+    public get llmInference() {
+        return this._llmInference;
+    }
+
     constructor(
         private _model: string | TLLMModel,
         private _specSource?: string | Record<string, any>,
@@ -308,7 +313,6 @@ export class Conversation extends EventEmitter {
         //     toolsConfig,
         // });
         /* ==================== STEP ENTRY ==================== */
-        const llmInference: LLMInference = await LLMInference.getInstance(this.model, AccessCandidate.team(this._teamId));
 
         if (message) this._context.addUserMessage(message, message_id);
 
@@ -329,7 +333,7 @@ export class Conversation extends EventEmitter {
             requestId: llmReqUid,
         });
 
-        const eventEmitter: any = await llmInference
+        const eventEmitter: any = await this.llmInference
             .promptStream({
                 contextWindow,
                 files,
@@ -818,6 +822,7 @@ export class Conversation extends EventEmitter {
         handler: (args: Record<string, any>) => Promise<any>;
         inputs?: any[];
     }) {
+        await this.ready;
         if (!tool.arguments) {
             //if no arguments are provided, we need to extract them from the function
             const toolFunction = tool.handler as Function;
@@ -879,11 +884,10 @@ export class Conversation extends EventEmitter {
 
         //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({
+        const toolsConfig: any = this.llmInference.connector.formatToolsConfig({
             type: 'function',
             toolDefinitions: this._customToolsDeclarations,
             toolChoice: this.toolChoice,
@@ -896,11 +900,11 @@ export class Conversation extends EventEmitter {
     }
 
     async removeTool(toolName: string) {
+        await this.ready;
         this._customToolsDeclarations = this._customToolsDeclarations.filter((tool) => tool.name !== toolName);
         delete this._customToolsHandlers[toolName];
-        const llmInference: LLMInference = await LLMInference.getInstance(this.model, AccessCandidate.team(this._teamId));
 
-        const toolsConfig: any = llmInference.connector.formatToolsConfig({
+        const toolsConfig: any = this.llmInference.connector.formatToolsConfig({
             type: 'function',
             toolDefinitions: this._customToolsDeclarations,
             toolChoice: this.toolChoice,
@@ -928,15 +932,15 @@ export class Conversation extends EventEmitter {
                 const functionDeclarations = this.getFunctionDeclarations(this._spec);
                 //functionDeclarations.push(...this._customToolsDeclarations);
                 this._customToolsDeclarations.push(...functionDeclarations);
-                const llmInference: LLMInference = await LLMInference.getInstance(this._model, AccessCandidate.team(this._teamId));
-                if (!llmInference.connector) {
+                this._llmInference = await LLMInference.getInstance(this._model, AccessCandidate.team(this._teamId));
+                if (!this._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({
+                this._toolsConfig = this.llmInference.connector.formatToolsConfig({
                     type: 'function',
                     toolDefinitions: this._customToolsDeclarations,
                     toolChoice: this.toolChoice,
@@ -945,7 +949,7 @@ export class Conversation extends EventEmitter {
                 let messages = [];
                 if (this._context) messages = this._context.messages; // preserve messages
 
-                this._context = new LLMContext(llmInference, this.systemPrompt, this._llmContextStore);
+                this._context = new LLMContext(this.llmInference, this.systemPrompt, this._llmContextStore);
             } else {
                 this._toolsConfig = null;
                 this._reqMethods = null;