@smythos/sre 1.7.18 → 1.7.40

package/src/Components/RAG/DataSourceIndexer.class.ts

@@ -0,0 +1,254 @@
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { DataSourceComponent } from './DataSourceComponent.class';
+import Joi from 'joi';
+import { validateCharacterSet } from '@sre/utils/validation.utils';
+import { TemplateString } from '@sre/helpers/TemplateString.helper';
+import { isUrl, detectURLSourceType } from '../../utils';
+import { SmythFS } from '@sre/IO/Storage.service/SmythFS.class';
+import { ConnectorService } from '@sre/Core/ConnectorsService';
+
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { TEmbeddings } from '@sre/IO/VectorDB.service/embed/BaseEmbedding';
+import { VectorDBConnector } from '@sre/IO/VectorDB.service/VectorDBConnector';
+import { JSONContentHelper } from '@sre/helpers/JsonContent.helper';
+
+export class DataSourceIndexer extends DataSourceComponent {
+    private MAX_ALLOWED_URLS_PER_INPUT = 20;
+    protected configSchema = Joi.object({
+        namespace: Joi.string().max(50).allow(''),
+        id: Joi.string().custom(validateCharacterSet, 'id custom validation').allow('').label('source identifier'),
+        name: Joi.string().max(50).allow('').label('label'),
+        metadata: Joi.string().allow(null).allow('').max(10000).label('metadata'),
+        chunkSize: Joi.number().optional(),
+        chunkOverlap: Joi.number().optional(),
+        version: Joi.string().valid('v1', 'v2').default('v1'),
+    });
+    constructor() {
+        super();
+    }
+    init() {}
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+
+        let response: any = null;
+        if (!config.data.version || config.data.version === 'v1') {
+            response = await this.processV1(input, config, agent);
+        } else if (config.data.version === 'v2') {
+            response = await this.processV2(input, config, agent);
+        }
+
+        return response;
+    }
+
+    private async processV1(input, config, agent: Agent) {
+        const teamId = agent.teamId;
+        const agentId = agent.id;
+        let debugOutput = agent.agentRuntime?.debug ? '== Source Indexer Log ==\n' : null;
+
+        try {
+            const _config = {
+                ...config.data,
+                name: TemplateString(config.data.name).parse(input).result,
+                id: TemplateString(config.data.id).parse(input).result,
+                metadata: TemplateString(config.data.metadata).parse(input).result,
+            };
+
+            const outputs = {};
+            for (let con of config.outputs) {
+                if (con.default) continue;
+                outputs[con.name] = con?.description ? `<${con?.description}>` : '';
+            }
+
+            const namespaceId = _config.namespace.split('_').slice(1).join('_') || _config.namespace;
+            debugOutput += `[Selected namespace id] \n${namespaceId}\n\n`;
+
+            const vectorDbConnector =
+                // (await vectorDBHelper.getTeamConnector(teamId)) ||
+                ConnectorService.getVectorDBConnector();
+            const nsExists = await vectorDbConnector.requester(AccessCandidate.team(teamId)).namespaceExists(namespaceId);
+
+            if (!nsExists) {
+                const newNs = await vectorDbConnector.requester(AccessCandidate.team(teamId)).createNamespace(namespaceId);
+                debugOutput += `[Created namespace] \n${newNs}\n\n`;
+            }
+
+            const inputSchema = this.validateInput(input);
+            if (inputSchema.error) {
+                throw new Error(`Input validation error: ${inputSchema.error}\n EXITING...`);
+            }
+
+            const providedId = _config.id;
+            // const isAutoId = _config.isAutoId;
+            const idRegex = /^[a-zA-Z0-9\-\_\.]+$/;
+
+            if (!providedId) {
+                // Assign a new ID if it's set to auto-generate or not provided
+                // _config.id = crypto.randomBytes(16).toString('hex');
+                throw new Error(`Id is required`);
+            } else if (!idRegex.test(providedId)) {
+                // Validate the provided ID if it's not auto-generated
+                throw new Error(`Invalid id. Accepted characters: 'a-z', 'A-Z', '0-9', '-', '_', '.'`);
+            }
+
+            let indexRes: any = null;
+            let parsedUrlArray: string[] | null = null;
+            const dsId = DataSourceIndexer.normalizeDsId(providedId, teamId, namespaceId);
+
+            if (isUrl(inputSchema.value.Source)) {
+                debugOutput += `STEP: Parsing input as url\n\n`;
+                throw new Error('URLs are not supported yet');
+            } else {
+                debugOutput += `STEP: Parsing input as text\n\n`;
+                indexRes = await this.addDSFromText({
+                    teamId,
+                    namespaceId: namespaceId,
+                    text: inputSchema.value.Source,
+                    name: _config.name || 'Untitled',
+                    metadata: _config.metadata || null,
+                    sourceId: dsId,
+                });
+            }
+
+            debugOutput += `Created datasource successfully\n\n`;
+
+            return {
+                _debug: debugOutput,
+                Success: {
+                    result: indexRes?.data?.dataSource || true,
+                    id: _config.id,
+                },
+                // _error,
+            };
+        } catch (err: any) {
+            debugOutput += `Error: ${err?.message || "Couldn't index data source"}\n\n`;
+            return {
+                _debug: debugOutput,
+                _error: err?.message || "Couldn't index data source",
+            };
+        }
+    }
+
+    private async processV2(input, config, agent: Agent) {
+        const teamId = agent.teamId;
+        const agentId = agent.id;
+        let debugOutput = agent.agentRuntime?.debug ? '== Source Indexer Log ==\n' : null;
+
+        try {
+            const _config = {
+                ...config.data,
+                name: TemplateString(config.data.name).parse(input).result,
+                id: TemplateString(config.data.id).parse(input).result,
+                metadata: TemplateString(config.data.metadata).parse(input).result,
+            };
+
+            const outputs = {};
+            for (let con of config.outputs) {
+                if (con.default) continue;
+                outputs[con.name] = con?.description ? `<${con?.description}>` : '';
+            }
+
+            // we try to get the namespace without the prefix teamId, if not exist, we use the full namespace id
+            // const namespaceLabel = _config.namespace.split('_').slice(1).join('_') || _config.namespace;
+            const namespaceLabel = /^c[a-z0-9]{24}.+$/.test(_config.namespace) ? _config.namespace.split('_').slice(1).join('_') : _config.namespace;
+            const namespaceId = _config.namespace;
+            debugOutput += `[Selected namespace] \n${namespaceLabel}\n\n`;
+
+            let vecDbConnector: VectorDBConnector = null;
+            try {
+                vecDbConnector = await this.resolveVectorDbConnector(namespaceId, teamId);
+            } catch (err: any) {
+                debugOutput += `Error: ${err?.message || "Couldn't get vector database connector"}\n\n`;
+                return {
+                    _debug: debugOutput,
+                    _error: err?.message || "Couldn't get vector database connector",
+                };
+            }
+            const vecDbClient = vecDbConnector.requester(AccessCandidate.team(teamId));
+
+            const inputSchema = this.validateInput(input);
+            if (inputSchema.error) {
+                throw new Error(`Input validation error: ${inputSchema.error}\n EXITING...`);
+            }
+
+            const providedId = _config.id;
+            // const isAutoId = _config.isAutoId;
+            const idRegex = /^[a-zA-Z0-9\-\_\.]+$/;
+
+            if (!providedId) {
+                // Assign a new ID if it's set to auto-generate or not provided
+                // _config.id = crypto.randomBytes(16).toString('hex');
+                throw new Error(`Id is required`);
+            } else if (!idRegex.test(providedId)) {
+                // Validate the provided ID if it's not auto-generated
+                throw new Error(`Invalid id. Accepted characters: 'a-z', 'A-Z', '0-9', '-', '_', '.'`);
+            }
+
+            const dsId = DataSourceIndexer.normalizeDsId(providedId, teamId, namespaceLabel);
+
+            // check if the datasource already exists
+            const dsExists = await vecDbClient.getDatasource(namespaceLabel, dsId);
+            if (dsExists) {
+                debugOutput += `Datasource already exists\n\n`;
+                return {
+                    _debug: debugOutput,
+                    _error: `Datasource already exists`,
+                };
+            }
+
+            debugOutput += `STEP: Parsing input as text\n\n`;
+
+            const response = await vecDbClient.createDatasource(namespaceLabel, {
+                text: inputSchema.value.Source,
+                metadata: JSONContentHelper.create(_config.metadata).tryParse() || null,
+                id: dsId,
+                label: _config.name || 'Untitled',
+                chunkSize: _config.chunkSize ? parseInt(_config.chunkSize) : undefined,
+                chunkOverlap: _config.chunkOverlap ? parseInt(_config.chunkOverlap) : undefined,
+            });
+
+            debugOutput += `Created datasource successfully\n\n`;
+
+            return {
+                _debug: debugOutput,
+                Success: {
+                    result: response || true,
+                    id: _config.id,
+                },
+                // _error,
+            };
+        } catch (err: any) {
+            debugOutput += `Error: ${err?.message || "Couldn't index data source"}\n\n`;
+            return {
+                _debug: debugOutput,
+                _error: err?.message || "Couldn't index data source",
+            };
+        }
+    }
+
+    validateInput(input: any) {
+        return Joi.object({
+            Source: Joi.any().required(),
+        })
+            .unknown(true)
+            .validate(input);
+    }
+
+    private async addDSFromText({ teamId, sourceId, namespaceId, text, name, metadata }) {
+        let vectorDbConnector = ConnectorService.getVectorDBConnector();
+        // const isOnCustomStorage = await vectorDBHelper.isNamespaceOnCustomStorage(teamId, namespaceId);
+        // if (isOnCustomStorage) {
+        // const customTeamConnector = await vectorDBHelper.getTeamConnector(teamId);
+        // if (customTeamConnector) {
+        // vectorDbConnector = customTeamConnector;
+        // }
+        // }
+        const id = await vectorDbConnector.requester(AccessCandidate.team(teamId)).createDatasource(namespaceId, {
+            text,
+            metadata,
+            id: sourceId,
+            label: name,
+        });
+
+        return id;
+    }
+}

package/src/Components/{DataSourceLookup.class.ts → RAG/DataSourceLookup.class.ts}

@@ -1,12 +1,12 @@
 import Joi from 'joi';
-import { validateInteger } from '../utils';
+import { validateInteger } from '../../utils';
 import { jsonrepair } from 'jsonrepair';
 import { TemplateString } from '@sre/helpers/TemplateString.helper';
 import { JSONContent } from '@sre/helpers/JsonContent.helper';
 import { ConnectorService } from '@sre/Core/ConnectorsService';
 import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
 import { IAgent as Agent } from '@sre/types/Agent.types';
-import { Component } from './Component.class';
+import { DataSourceComponent } from './DataSourceComponent.class';
 
 // Note: LLMHelper renamed to LLMInference
 class LLMInference {
@@ -15,7 +15,7 @@ class LLMInference {
     }
 }
 
-export class DataSourceLookup extends Component {
+export class DataSourceLookup extends DataSourceComponent {
     protected configSchema = Joi.object({
         topK: Joi.alternatives([Joi.string(), Joi.number()]) // Value is now a number; keep string fallback for backward compatibility.
 
@@ -31,13 +31,22 @@ export class DataSourceLookup extends Component {
         }),
         scoreThreshold: Joi.number().optional().label('Score Threshold'),
         includeScore: Joi.boolean().optional().label('Include Score'),
+        version: Joi.string().valid('v1', 'v2').default('v1'),
     });
     constructor() {
         super();
     }
     init() {}
+
     async process(input, config, agent: Agent) {
         await super.process(input, config, agent);
+        if (!config.data.version || config.data.version === 'v1') {
+            return await this.processV1(input, config, agent);
+        } else if (config.data.version === 'v2') {
+            return await this.processV2(input, config, agent);
+        }
+    }
+    async processV1(input, config, agent: Agent) {
         const componentId = config.id;
         const component = agent.components[componentId];
         const teamId = agent.teamId;
@@ -139,6 +148,86 @@ export class DataSourceLookup extends Component {
         };
     }
 
+    async processV2(input, config, agent: Agent) {
+        const teamId = agent.teamId;
+        let debugOutput = agent.agentRuntime?.debug ? '== Data Source Lookup Log ==\n' : null;
+
+        const outputs = {};
+        for (let con of config.outputs) {
+            if (con.default) continue;
+            outputs[con.name] = '';
+        }
+
+        const namespaceLabel = /^c[a-z0-9]{24}.+$/.test(config.data.namespace)
+            ? config.data.namespace.split('_').slice(1).join('_')
+            : config.data.namespace;
+        const namespaceId = config.data.namespace;
+        const model = config.data?.model || 'gpt-4o-mini';
+        const includeMetadata = config.data?.includeMetadata || false;
+
+        const scoreThreshold = config.data?.scoreThreshold || 0.001; // Use low score (0.001) to return most results for backward compatibility
+        const includeScore = config.data?.includeScore || false;
+
+        const _input = typeof input.Query === 'string' ? input.Query : JSON.stringify(input.Query);
+
+        const topK = Math.max(config.data?.topK || 50, 50);
+
+        // let vectorDbConnector = ConnectorService.getVectorDBConnector();
+        // let existingNs = await vectorDbConnector.requester(AccessCandidate.team(teamId)).namespaceExists(namespaceLabel);
+
+        const vecDbConnector = await this.resolveVectorDbConnector(namespaceId, teamId);
+
+        let results: string[] | { content: string; metadata: any; score?: number }[];
+        let _error;
+        try {
+            const response = await vecDbConnector
+                .requester(AccessCandidate.team(teamId))
+                .search(namespaceLabel, _input, { topK, includeMetadata: true });
+
+            results = response.slice(0, config.data.topK).map((result) => ({
+                content: result.text,
+                metadata: result.metadata,
+                score: result.score, // use a very low score to return
+            }));
+
+            results = results.filter((result) => result.score >= scoreThreshold);
+
+            // Transform results based on inclusion flags
+            results = results.map((result) => {
+                const transformedResult: any = {
+                    content: result.content,
+                };
+
+                if (includeMetadata) {
+                    // legacy user-specific metadata key [result.metadata?.metadata]
+                    transformedResult.metadata = this.parseMetadata(result.metadata || result.metadata?.metadata);
+                }
+
+                if (includeScore) {
+                    transformedResult.score = result.score;
+                }
+
+                // If neither metadata nor score is included, return just the content string
+                return includeMetadata || includeScore ? transformedResult : result.content;
+            });
+
+            debugOutput += `[Results] \nLoaded ${results.length} results from namespace: ${namespaceLabel}\n\n`;
+        } catch (error) {
+            debugOutput += `Error: ${error instanceof Error ? error.message : error.toString()}\n\n`;
+            _error = error instanceof Error ? error.message : error.toString();
+        }
+
+        const totalLength = JSON.stringify(results).length;
+        debugOutput += `[Total Length] \n${totalLength}\n\n`;
+
+        return {
+            Results: results,
+            _error,
+            _debug: debugOutput,
+            //_debug: `Query: ${_input}. \nTotal Length = ${totalLength} \nResults: ${JSON.stringify(results)}`,
+        };
+    }
+
     // private async checkIfTeamOwnsNamespace(teamId: string, namespaceId: string, token: string) {
     //     try {
     //         const res = await SmythAPIHelper.fromAuth({ token }).mwSysAPI.get(`/vectors/namespaces/${namespaceId}`);

package/src/Components/ServerlessCode.class.ts

@@ -41,10 +41,7 @@ export class ServerlessCode extends Component {
             let codeInputs = {};
 
             for (let field of componentInputs) {
-                // Parse using input values first, then agent variables.
-                // This correctly resolves cases where input values reference agent variables with the same name.
-                // Example: agent variables { user_id: "123" }, input { user_id: "{{user_id}}" }.
-                const inputValue = TemplateString(input[field.name]).parse(input).parse(agent.agentVariables).result;
+                const inputValue = TemplateString(input[field.name]).parse(input).result;
 
                 const _type = typeof inputValue;
 

package/src/Components/index.ts

@@ -8,9 +8,9 @@ import { FSleep } from './FSleep.class';
 import { FHash } from './FHash.class';
 import { FEncDec } from './FEncDec.class';
 import { FTimestamp } from './FTimestamp.class';
-import { DataSourceLookup } from './DataSourceLookup.class';
-import { DataSourceIndexer } from './DataSourceIndexer.class';
-import { DataSourceCleaner } from './DataSourceCleaner.class';
+import { DataSourceLookup } from './RAG/DataSourceLookup.class';
+import { DataSourceIndexer } from './RAG/DataSourceIndexer.class';
+import { DataSourceCleaner } from './RAG/DataSourceCleaner.class';
 import { JSONFilter } from './JSONFilter.class';
 import { LogicAND } from './LogicAND.class';
 import { LogicOR } from './LogicOR.class';

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;