@smythos/sre 1.5.68 → 1.5.71

package/dist/types/Components/MemoryDeleteKeyVal.class.d.ts

@@ -6,13 +6,21 @@ export declare class MemoryDeleteKeyVal extends Component {
     constructor();
     init(): void;
     process(input: any, config: any, agent: Agent): Promise<{
+        _warning: string;
+        _debug: string;
+        Key?: undefined;
+        deleted?: undefined;
+        _error?: undefined;
+    } | {
         Key: string;
         deleted: boolean;
         _debug: string;
+        _warning?: undefined;
         _error?: undefined;
     } | {
         _error: any;
         _debug: string;
+        _warning?: undefined;
         Key?: undefined;
         deleted?: undefined;
     }>;

package/dist/types/Components/MemoryReadKeyVal.class.d.ts

@@ -6,12 +6,19 @@ export declare class MemoryReadKeyVal extends Component {
     constructor();
     init(): void;
     process(input: any, config: any, agent: Agent): Promise<{
+        _warning: string;
+        _debug: string;
+        Value?: undefined;
+        _error?: undefined;
+    } | {
         Value: any;
         _debug: string;
+        _warning?: undefined;
         _error?: undefined;
     } | {
         _error: any;
         _debug: string;
+        _warning?: undefined;
         Value?: undefined;
     }>;
 }

package/dist/types/subsystems/IO/Storage.service/connectors/AzureBlobStorage.class.d.ts

@@ -0,0 +1,211 @@
+import { StorageConnector } from '@sre/IO/Storage.service/StorageConnector';
+import { ACL } from '@sre/Security/AccessControl/ACL.class';
+import { IAccessCandidate, IACL } from '@sre/types/ACL.types';
+import { StorageData, StorageMetadata } from '@sre/types/Storage.types';
+import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
+export type AzureBlobConfig = {
+    storageAccountName: string;
+    storageAccountAccessKey: string;
+    blobContainerName: string;
+};
+export declare class AzureBlobStorage extends StorageConnector {
+    protected _settings: AzureBlobConfig;
+    name: string;
+    private blobServiceClient;
+    private containerClient;
+    private isInitialized;
+    private initializationPromise;
+    constructor(_settings: AzureBlobConfig);
+    private ensureInitialized;
+    private initialize;
+    /**
+     * Reads a blob's content from the Azure Storage container.
+     * This method fetches the entire blob content into a Buffer. If the specified
+     * blob does not exist, it gracefully returns undefined.
+     *
+     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
+     * @param {string} resourceId - The unique identifier (name) of the blob to be read from the container.
+     * @returns {Promise<StorageData | undefined>} A promise that resolves with the blob's content as a Buffer (`StorageData`), or undefined if the blob is not found.
+     * @throws Throws an error if any other issue occurs during the download process (e.g., network issues, permissions problems).
+     */
+    read(acRequest: AccessRequest, resourceId: string): Promise<StorageData | undefined>;
+    /**
+     * Writes or overwrites a blob in the Azure Storage container.
+     *
+     * This method uploads data to a specified blob. It automatically handles the SmythOS
+     * Access Control List (ACL) by ensuring the writer is made the owner of the object.
+     * Any provided metadata is merged with this ACL and stored with the blob.
+     * If a blob with the same `resourceId` already exists, this operation will completely replace its content and metadata.
+     *
+     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
+     * @param {string} resourceId - The unique identifier (name) of the blob to be written or overwritten.
+     * @param {StorageData} value - The content to be written to the blob, typically a Buffer.
+     * @param {IACL} [acl] - An optional Access Control List to apply to the blob. If not provided, a default ACL is generated.
+     * @param {StorageMetadata} [metadata] - Optional key-value metadata to associate with the blob, including properties like `ContentType`.
+     * @returns {Promise<void>} A promise that resolves when the upload operation is complete.
+     * @throws Throws an error if the upload fails due to network issues, invalid credentials, or other storage-related problems.
+     */
+    write(acRequest: AccessRequest, resourceId: string, value: StorageData, acl?: IACL, metadata?: StorageMetadata): Promise<void>;
+    /**
+     * Deletes a blob from the Azure Storage container.
+     *
+     * This method permanently removes the specified blob. The operation is idempotent,
+     * meaning it will complete successfully without error even if the blob does not
+     * already exist. This is useful for ensuring a resource is gone without needing to
+     * check for its existence first.
+     *
+     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
+     * @param {string} resourceId - The unique identifier (name) of the blob to be deleted.
+     * @returns {Promise<void>} A promise that resolves when the delete operation is complete.
+     * @throws Throws an error if the deletion fails for reasons other than the blob not existing (e.g., network issues, permissions problems).
+     */
+    delete(acRequest: AccessRequest, resourceId: string): Promise<void>;
+    /**
+     * Checks for the existence of a blob in the Azure Storage container.
+     *
+     * This method efficiently verifies if a blob with the specified `resourceId` is
+     * present without downloading its content. It's the most performant way to
+     * check for a blob's presence before performing other operations.
+     *
+     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
+     * @param {string} resourceId - The unique identifier (name) of the blob to check.
+     * @returns {Promise<boolean>} A promise that resolves with `true` if the blob exists, and `false` otherwise.
+     * @throws Throws an error for any issue other than the blob not being found (e.g., network issues, invalid credentials).
+     */
+    exists(acRequest: AccessRequest, resourceId: string): Promise<boolean>;
+    /**
+     * Retrieves the user-defined metadata for a specific blob.
+     *
+     * This method fetches the key-value metadata associated with a blob without
+     * downloading the blob's content. It's an efficient way to read custom
+     * information stored with an object. If the blob is not found, it returns undefined.
+     *
+     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
+     * @param {string} resourceId - The unique identifier (name) of the blob whose metadata is to be retrieved.
+     * @returns {Promise<StorageMetadata | undefined>} A promise that resolves with the blob's metadata object, or undefined if the blob does not exist.
+     * @throws Throws an error for any issue other than the blob not being found (e.g., network issues, invalid credentials).
+     */
+    getMetadata(acRequest: AccessRequest, resourceId: string): Promise<StorageMetadata | undefined>;
+    /**
+     * Sets or updates the user-defined metadata for a specific blob.
+     *
+     * This method applies new metadata to an existing blob. It performs a "merge and
+     * update" operation: it first reads the blob's current metadata, then merges
+     * the provided metadata with it (new values overwrite existing ones).
+     * This operation does not affect the blob's content.
+     *
+     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
+     * @param {string} resourceId - The unique identifier (name) of the blob whose metadata is to be updated.
+     * @param {StorageMetadata} metadata - An object containing the key-value pairs to set. These will be merged with any existing metadata.
+     * @returns {Promise<void>} A promise that resolves when the metadata has been successfully updated.
+     * @throws Throws an error if the blob does not exist, or if the update fails for other reasons (e.g., network issues).
+     */
+    setMetadata(acRequest: AccessRequest, resourceId: string, metadata: StorageMetadata): Promise<void>;
+    /**
+     * Retrieves the Access Control List (ACL) for a specific blob.
+     *
+     * This method fetches the blob's metadata and specifically extracts the
+     * SmythOS-native ACL object. It provides a direct way to inspect the
+     * permissions of a blob without downloading its content.
+     *
+     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
+     * @param {string} resourceId - The unique identifier (name) of the blob whose ACL is to be retrieved.
+     * @returns {Promise<ACL | undefined>} A promise that resolves with the `ACL` object for the blob. Returns undefined if the blob does not exist or has no ACL.
+     * @throws Throws an error for any issue other than the blob not being found (e.g., network issues, invalid credentials).
+     */
+    getACL(acRequest: AccessRequest, resourceId: string): Promise<ACL | undefined>;
+    /**
+     * Sets or updates the Access Control List (ACL) for a specific blob.
+     *
+     * This method applies a new SmythOS ACL to an existing blob. It reads the blob's
+     * full metadata, replaces the ACL portion, and writes the updated metadata back.
+     * A crucial security feature of this method is that it automatically ensures the
+     * user/agent making the request always retains ownership of the blob.
+     *
+     * @param {AccessRequest} acRequest - The access request object, used to identify the user/agent to ensure they retain ownership.
+     * @param {string} resourceId - The unique identifier (name) of the blob whose ACL is to be updated.
+     * @param {IACL} acl - The new Access Control List object to apply to the blob.
+     * @returns {Promise<void>} A promise that resolves when the ACL has been successfully updated.
+     * @throws Throws an error if the blob does not exist or if the update fails for other reasons.
+     */
+    setACL(acRequest: AccessRequest, resourceId: string, acl: IACL): Promise<void>;
+    /**
+     * Determines the effective Access Control List (ACL) for a given resource.
+     *
+     * This crucial security method is called by the access control system to fetch a
+     * resource's ACL before making an authorization decision. If the resource does
+     * not exist (and thus has no ACL), this method dynamically generates a new ACL
+     * that grants 'Owner' access to the requesting candidate. This is the mechanism
+     * that allows authorized users to create new resources.
+     *
+     * @param {string} resourceId - The unique identifier (name) of the blob whose ACL is to be determined.
+     * @param {IAccessCandidate} candidate - The user or agent attempting to access the resource, used to grant ownership if the resource is new.
+     * @returns {Promise<ACL>} A promise that resolves with the existing ACL object if the blob is found, or a new ACL object granting ownership if the blob does not exist.
+     * @throws Throws an error if there is an unexpected issue fetching the blob's metadata (e.g., network issues).
+     */
+    getResourceACL(resourceId: string, candidate: IAccessCandidate): Promise<ACL>;
+    /**
+     * Schedules a blob for automatic deletion after a specified time-to-live (TTL).
+     *
+     * This method applies a Blob Index Tag ('deleteAfterDays') to an existing blob.
+     * It does not delete the blob immediately. Instead, it relies on a pre-configured
+     * Lifecycle Management rule on the Azure Storage Account to automatically delete the
+     * blob after the specified number of days.
+     *
+     * @param {AccessRequest} acRequest - The access request object, handled by the @SecureConnector decorator to authorize the operation.
+     * @param {string} resourceId - The unique identifier (name) of the blob to schedule for deletion.
+     * @param {number} ttl - The time-to-live for the blob, in seconds. Must be a positive number.
+     * @returns {Promise<void>} A promise that resolves when the expiration tag has been successfully applied.
+     * @throws Throws an error if the blob does not exist, if the TTL is invalid, or if applying the tag fails.
+     */
+    expire(acRequest: AccessRequest, resourceId: string, ttl: number): Promise<void>;
+    /**
+     * Migrates legacy ACL metadata to the new structured format.
+     *
+     * This internal helper function checks for an outdated ACL format where permissions
+     * were stored in separate keys like `userid`, `teamid`, or `agentid`. If found,
+     * it converts them into the modern, structured `azure-acl` object, granting full
+     * ownership. This ensures seamless backward compatibility with older data.
+     *
+     * @param {Record<string, string>} metadata - The raw metadata object which may contain legacy ACL keys.
+     * @returns {Record<string, any>} The metadata object, with legacy keys converted into a new `azure-acl` property.
+     * @private
+     */
+    private _migrateMetadata;
+    /**
+     * Serializes the internal metadata object into a format compatible with Azure Blob Storage.
+     *
+     * This internal helper prepares the metadata for upload. It converts the `ACL` object
+     * into its serialized string representation and stringifies any other non-string
+     * metadata values. The `ContentType` property is intentionally excluded as it's
+     * handled separately in the blob's HTTP headers.
+     *
+     * @param {Record<string, any>} metadata - The internal metadata object, containing mixed-type values.
+     * @returns {Record<string, string>} A flat key-value object where all values are strings.
+     * @private
+     */
+    private _serializeAzureMetadata;
+    /**
+     * Deserializes a flat metadata object from Azure into the rich internal format.
+     *
+     * This internal helper processes the raw string-based metadata retrieved from a blob.
+     * It reconstructs the `ACL` object from its string representation and parses any
+     * other JSON-stringified values back into their original object/data types. It then
+     * calls the migration helper to ensure backward compatibility with legacy ACL formats.
+     *
+     * @param {Record<string, string>} metadata - The flat, string-only key-value metadata from the Azure SDK.
+     * @returns {Record<string, any>} The rich internal metadata object with complex data types restored.
+     * @private
+     */
+    private _deserializeAzureMetadata;
+    /**
+     * Private helper to fetch and deserialize metadata from Azure.
+     * @private
+     */
+    private _getAzureMetadata;
+    /**
+     * Private helper to serialize and write metadata to Azure.
+     * @private
+     */
+    private _setAzureMetadata;
+}

package/dist/types/subsystems/IO/VectorDB.service/connectors/RAMVecrtorDB.class.d.ts

@@ -1,7 +1,7 @@
 import { ACL } from '@sre/Security/AccessControl/ACL.class';
 import { IAccessCandidate } from '@sre/types/ACL.types';
 import { AccessRequest } from '@sre/Security/AccessControl/AccessRequest.class';
-import { VectorDBConnector } from '../VectorDBConnector';
+import { VectorDBConnector, DeleteTarget } from '../VectorDBConnector';
 import { DatasourceDto, IStorageVectorDataSource, IStorageVectorNamespace, IVectorDataSourceDto, QueryOptions, VectorsResultData } from '@sre/types/VectorDB.types';
 import { BaseEmbedding, TEmbeddings } from '../embed/BaseEmbedding';
 export type RAMVectorDBConfig = {
@@ -36,17 +36,13 @@ export declare class RAMVectorDB extends VectorDBConnector {
     protected deleteNamespace(acRequest: AccessRequest, namespace: string): Promise<void>;
     protected search(acRequest: AccessRequest, namespace: string, query: string | number[], options?: QueryOptions): Promise<VectorsResultData>;
     protected insert(acRequest: AccessRequest, namespace: string, sourceWrapper: IVectorDataSourceDto | IVectorDataSourceDto[]): Promise<string[]>;
-    protected delete(acRequest: AccessRequest, namespace: string, id: string | string[]): Promise<void>;
+    protected delete(acRequest: AccessRequest, namespace: string, deleteTarget: DeleteTarget): Promise<void>;
     protected createDatasource(acRequest: AccessRequest, namespace: string, datasource: DatasourceDto): Promise<IStorageVectorDataSource>;
     protected deleteDatasource(acRequest: AccessRequest, namespace: string, datasourceId: string): Promise<void>;
     protected listDatasources(acRequest: AccessRequest, namespace: string): Promise<IStorageVectorDataSource[]>;
-    protected getDatasource(acRequest: AccessRequest, namespace: string, datasourceId: string): Promise<IStorageVectorDataSource>;
+    protected getDatasource(acRequest: AccessRequest, namespace: string, datasourceId: string): Promise<IStorageVectorDataSource | undefined>;
     /**
      * Calculate cosine similarity between two vectors
      */
     private cosineSimilarity;
-    /**
-     * Split text into chunks with overlap
-     */
-    private splitTextIntoChunks;
 }

package/dist/types/subsystems/LLMManager/models.d.ts

@@ -55,7 +55,6 @@ export declare const models: {
     };
     'gpt-4o-mini': {
         llm: string;
-        alias: string;
         components: string[];
         label: string;
         modelId: string;

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

@@ -189,7 +189,7 @@ export type TLLMModel = {
         tokens: number;
         completionTokens: number;
     };
-    credentials?: TLLMCredentials;
+    credentials?: TLLMCredentials | TLLMCredentials[];
     params?: TLLMParams;
     /**
      * Specifies the API interface type to use for this model

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smythos/sre",
-  "version": "1.5.68",
+  "version": "1.5.71",
   "description": "Smyth Runtime Environment",
   "author": "Alaa-eddine KADDOURI",
   "license": "MIT",
@@ -107,6 +107,10 @@
     "build:types": "tsc --emitDeclarationOnly --declaration --outDir dist/types -p tsconfig.dts.json",
     "build:jsbundle": "cross-env rollup -c",
     "build": "pnpm run build:jsbundle && pnpm run build:types",
+    "test:unit": "cd ../.. && vitest run packages/core/tests/unit",
+    "test:unit:watch": "cd ../.. && vitest watch packages/core/tests/unit",
+    "test:integration": "cd ../.. && vitest run packages/core/tests/integration",
+    "test:integration:watch": "cd ../.. && vitest watch packages/core/tests/integration",
     "gen:docs": "typedoc",
     "doc:graphgen": "npx depcruise src --config ./doc/.dep-minimal.json --output-type dot > ./doc/dep-graph.dot && dot -Tpng ./doc/dep-graph.dot -o ./doc/dep-graph.png",
     "knip": "knip"

package/src/Components/ECMASandbox.class.ts

@@ -38,14 +38,15 @@ export class ECMASandbox extends Component {
                 }
             }
 
-            const inputVarsCode = this.generateInputVarCode(codeInputs);
-            const code = inputVarsCode + '\n' + config.data.code;
+            //const inputVarsCode = this.generateInputVarCode(codeInputs);
+            //const code = inputVarsCode + '\n' + config.data.code;
+            const code = config.data.code;
 
             logger.debug(`Running code: \n${code}\n`);
 
             const ecmaCodeConnector = ConnectorService.getCodeConnector('ECMASandbox');
 
-            const executionResponse: CodeExecutionResult = await ecmaCodeConnector.agent(agent.id).execute(config.id, { code });
+            const executionResponse: CodeExecutionResult = await ecmaCodeConnector.agent(agent.id).execute(config.id, { code, inputs: input });
             if (executionResponse.success) {
                 Output = executionResponse.output;
             } else {

package/src/Components/MemoryDeleteKeyVal.class.ts

@@ -37,7 +37,7 @@ export class MemoryDeleteKeyVal extends Component {
             const scopeStrData = await connectorRequester.get(scopeKeyId);
 
             if (!scopeStrData) {
-                return { _error: 'key not found', _debug: logger.output };
+                return { _warning: 'key not found', _debug: logger.output };
             }
 
             logger.debug(`Checking Scope for deletion`);
@@ -46,11 +46,11 @@ export class MemoryDeleteKeyVal extends Component {
 
             // Validate scope access like in MemoryReadKeyVal
             if (scopeData.scope === 'session' && scopeKey !== sessionId) {
-                return { _error: 'key not found', _debug: logger.output };
+                return { _warning: 'key not found', _debug: logger.output };
             }
 
             if (scopeData.scope === 'request' && scopeKey !== workflowId) {
-                return { _error: 'key not found', _debug: logger.output };
+                return { _warning: 'key not found', _debug: logger.output };
             }
 
             logger.debug(`Deleting memory value and scope data`);

package/src/Components/MemoryReadKeyVal.class.ts

@@ -10,6 +10,7 @@ const memory = {};
 export class MemoryReadKeyVal extends Component {
     protected configSchema = Joi.object({
         memoryName: Joi.string().max(255).allow('').label('Memory Name'),
+        key: Joi.string().max(255).allow('').label('Key'),
     });
     constructor() {
         super();
@@ -28,7 +29,7 @@ export class MemoryReadKeyVal extends Component {
 
             const memoryName = config.data.memoryName;
 
-            const key = input.Key;
+            const key = TemplateString(config.data.key).parse(input).result;
 
             const sessionId = agent.sessionId;
             const workflowId = agent.agentRuntime.workflowReqId;
@@ -38,18 +39,18 @@ export class MemoryReadKeyVal extends Component {
             const scopeStrData = await connectorRequester.get(scopeKeyId);
 
             if (!scopeStrData) {
-                return { _error: 'key not found', _debug: logger.output };
+                return { _warning: 'key not found', _debug: logger.output };
             }
 
             logger.debug(`Checking Scope`);
             const scopeData = JSON.parse(scopeStrData);
             const scopeKey = scopeData.value;
             if (scopeData.scope === 'session' && scopeKey !== sessionId) {
-                return { _error: 'key not found', _debug: logger.output };
+                return { _warning: 'key not found', _debug: logger.output };
             }
 
             if (scopeData.scope === 'request' && scopeKey !== workflowId) {
-                return { _error: 'key not found', _debug: logger.output };
+                return { _warning: 'key not found', _debug: logger.output };
             }
 
             logger.debug(`Reading Value`);

package/src/Components/MemoryWriteObject.class.ts

@@ -35,7 +35,7 @@ export class MemoryWriteObject extends Component {
             // Parse the JSON data
             let dataObject;
             try {
-                dataObject = JSON.parse(dataString);
+                dataObject = typeof dataString === 'object' ? dataString : JSON.parse(dataString);
             } catch (parseError) {
                 return { _error: 'Invalid JSON data provided', _debug: logger.output };
             }

package/src/helpers/AWSLambdaCode.helper.ts

@@ -2,7 +2,17 @@ import crypto from 'crypto';
 import { ConnectorService } from '@sre/Core/ConnectorsService';
 import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
 import zl from 'zip-lib';
-import { InvokeCommand, Runtime, LambdaClient, UpdateFunctionCodeCommand, CreateFunctionCommand, GetFunctionCommand, GetFunctionCommandOutput, InvokeCommandOutput, UpdateFunctionConfigurationCommand } from '@aws-sdk/client-lambda';
+import {
+    InvokeCommand,
+    Runtime,
+    LambdaClient,
+    UpdateFunctionCodeCommand,
+    CreateFunctionCommand,
+    GetFunctionCommand,
+    GetFunctionCommandOutput,
+    InvokeCommandOutput,
+    UpdateFunctionConfigurationCommand,
+} from '@aws-sdk/client-lambda';
 import { GetRoleCommand, CreateRoleCommand, IAMClient, GetRoleCommandOutput, CreateRoleCommandOutput } from '@aws-sdk/client-iam';
 import fs from 'fs';
 import { AWSConfig, AWSCredentials, AWSRegionConfig } from '@sre/types/AWS.types';
@@ -19,7 +29,6 @@ export function getLambdaFunctionName(agentId: string, componentId: string) {
     return `${agentId}-${componentId}`;
 }
 
-
 export function generateCodeHash(code_body: string, codeInputs: string[], envVariables: string[]) {
     const bodyHash = getSanitizeCodeHash(code_body);
     const inputsHash = getSanitizeCodeHash(JSON.stringify(codeInputs));
@@ -79,9 +88,7 @@ export async function getDeployedCodeHash(agentId: string, componentId: string)
 
 export async function setDeployedCodeHash(agentId: string, componentId: string, codeHash: string) {
     const redisCache = ConnectorService.getCacheConnector();
-    await redisCache
-        .user(AccessCandidate.agent(agentId))
-        .set(`${cachePrefix}_${agentId}-${componentId}`, codeHash, null, null, cacheTTL);
+    await redisCache.user(AccessCandidate.agent(agentId)).set(`${cachePrefix}_${agentId}-${componentId}`, codeHash, null, null, cacheTTL);
 }
 
 function replaceVaultKeysTemplateVars(code: string, envVariables: Record<string, string>) {
@@ -121,7 +128,7 @@ export async function zipCode(directory: string) {
             },
             function (err) {
                 reject(err);
-            },
+            }
         );
     });
 }
@@ -276,7 +283,6 @@ export function getLambdaRolePolicy() {
     });
 }
 
-
 export async function updateDeployedCodeTTL(agentId: string, componentId: string, ttl: number) {
     const redisCache = ConnectorService.getCacheConnector();
     await redisCache.user(AccessCandidate.agent(agentId)).updateTTL(`${cachePrefix}_${agentId}-${componentId}`, ttl);
@@ -285,7 +291,7 @@ export async function updateDeployedCodeTTL(agentId: string, componentId: string
 export async function invokeLambdaFunction(
     functionName: string,
     inputs: { [key: string]: any },
-    awsCredentials: AWSCredentials & AWSRegionConfig,
+    awsCredentials: AWSCredentials & AWSRegionConfig
 ): Promise<any> {
     try {
         const client = new LambdaClient({
@@ -384,11 +390,11 @@ export function reportUsage({ cost, agentId, teamId }: { cost: number; agentId:
 
 export function validateAsyncMainFunction(rawCode: string): { isValid: boolean; error?: string; parameters?: string[]; dependencies?: string[] } {
     try {
-        const code = replaceVaultKeysTemplateVars(rawCode, {});
+        const code = replaceVaultKeysTemplateVars(rawCode.trim(), {});
         // Parse the code using     acorn
         const ast = acorn.parse(code, {
             ecmaVersion: 'latest',
-            sourceType: 'module'
+            sourceType: 'module',
         });
 
         // Extract library imports
@@ -414,11 +420,13 @@ export function validateAsyncMainFunction(rawCode: string): { isValid: boolean;
             }
 
             // Handle CallExpression (require() calls)
-            if (node.type === 'CallExpression' &&
+            if (
+                node.type === 'CallExpression' &&
                 node.callee.type === 'Identifier' &&
                 node.callee.name === 'require' &&
                 node.arguments.length > 0 &&
-                node.arguments[0].type === 'Literal') {
+                node.arguments[0].type === 'Literal'
+            ) {
                 const modulePath = node.arguments[0].value;
                 if (modulePath && !modulePath.startsWith('.') && !modulePath.startsWith('/')) {
                     libraries.add(extractPackageName(modulePath));
@@ -426,10 +434,12 @@ export function validateAsyncMainFunction(rawCode: string): { isValid: boolean;
             }
 
             // Handle dynamic import() calls
-            if (node.type === 'CallExpression' &&
+            if (
+                node.type === 'CallExpression' &&
                 node.callee.type === 'Import' &&
                 node.arguments.length > 0 &&
-                node.arguments[0].type === 'Literal') {
+                node.arguments[0].type === 'Literal'
+            ) {
                 const modulePath = node.arguments[0].value;
                 if (modulePath && !modulePath.startsWith('.') && !modulePath.startsWith('/')) {
                     libraries.add(extractPackageName(modulePath));
@@ -503,7 +513,7 @@ export function validateAsyncMainFunction(rawCode: string): { isValid: boolean;
             return {
                 isValid: false,
                 error: 'No main function found at root level',
-                dependencies
+                dependencies,
             };
         }
 
@@ -511,7 +521,7 @@ export function validateAsyncMainFunction(rawCode: string): { isValid: boolean;
             return {
                 isValid: false,
                 error: 'Main function exists but is not async',
-                dependencies
+                dependencies,
             };
         }
 
@@ -519,7 +529,7 @@ export function validateAsyncMainFunction(rawCode: string): { isValid: boolean;
     } catch (error) {
         return {
             isValid: false,
-            error: `Failed to parse code: ${error.message}`
+            error: `Failed to parse code: ${error.message}`,
         };
     }
 }
@@ -549,7 +559,7 @@ export function generateCodeFromLegacyComponent(code_body: string, code_imports:
      async function main(${codeInputs.join(', ')}) {
         ${code_body}
     }
-    `
+    `;
     return code;
 }
 
@@ -565,14 +575,12 @@ export function extractAllKeyNamesFromTemplateVars(input: string): string[] {
     return matches;
 }
 
-
-async function fetchVaultSecret(keyName: string, agentTeamId: string): Promise<{ value: string, key: string }> {
+async function fetchVaultSecret(keyName: string, agentTeamId: string): Promise<{ value: string; key: string }> {
     const vaultSecret = await VaultHelper.getAgentKey(keyName, agentTeamId);
     return {
         value: vaultSecret,
         key: keyName,
     };
-
 }
 
 export async function getCurrentEnvironmentVariables(agentTeamId: string, code: string): Promise<Record<string, string>> {
@@ -588,4 +596,4 @@ export async function getCurrentEnvironmentVariables(agentTeamId: string, code:
 export function getSortedObjectValues(obj: Record<string, string>): string[] {
     const sortedKeys = Object.keys(obj).sort();
     return sortedKeys.map((key) => obj[key]);
-}
+}

package/src/helpers/Conversation.helper.ts

@@ -132,9 +132,9 @@ export class Conversation extends EventEmitter {
             console.warn('Conversation Error: ', error?.message);
         });
         this._maxContextSize =
-            _settings.maxContextSize || (this._model as TLLMModel).tokens || (this._model as TLLMModel).keyOptions?.tokens || this._maxContextSize;
+            _settings?.maxContextSize || (this._model as TLLMModel).tokens || (this._model as TLLMModel).keyOptions?.tokens || this._maxContextSize;
         this._maxOutputTokens =
-            _settings.maxOutputTokens ||
+            _settings?.maxOutputTokens ||
             (this._model as TLLMModel).completionTokens ||
             (this._model as TLLMModel).keyOptions?.completionTokens ||
             this._maxOutputTokens;
@@ -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.function.name === tool.function.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,
                 });
 
@@ -919,6 +928,7 @@ export class Conversation extends EventEmitter {
             //is this a valid agent data?
             if (typeof specSource?.behavior === 'string' && specSource?.components && specSource?.connections) {
                 this.agentData = specSource; //agent loaded from data directly
+                this._agentId = specSource.id;
                 return await this.loadSpecFromAgent(specSource);
             }