@smythos/sre 1.7.20 → 1.7.40

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

@@ -6,18 +6,10 @@ export declare class DataSourceIndexer extends Component {
     protected configSchema: Joi.ObjectSchema<any>;
     constructor();
     init(): void;
-    process(input: any, config: any, agent: Agent): Promise<{
-        _debug: string;
-        Success: {
-            result: any;
-            id: any;
-        };
-        _error?: undefined;
-    } | {
-        _debug: string;
-        _error: any;
-        Success?: undefined;
-    }>;
+    process(input: any, config: any, agent: Agent): Promise<any>;
+    private processV1;
+    private processV2;
+    private transformEmbedding;
     validateInput(input: any): Joi.ValidationResult<any>;
     private addDSFromText;
     static genDsId(providedId: string, teamId: string, namespaceId: string): string;

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

@@ -262,19 +262,19 @@ export declare class GenAILLM extends Component {
     process(input: any, config: any, agent: Agent): Promise<{
         Reply: any;
     } | {
-        Reply: any;
+        Output: any;
         _error: string;
         _debug: string;
-        Output?: undefined;
+        Reply?: undefined;
     } | {
-        Output: any;
+        Reply: any;
         _error: string;
         _debug: string;
-        Reply?: undefined;
+        Output?: undefined;
     } | {
         _error: any;
         _debug: string;
-        Reply?: undefined;
         Output?: undefined;
+        Reply?: undefined;
     }>;
 }

package/dist/types/Components/index.d.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/dist/types/index.d.ts

@@ -9,9 +9,6 @@ export * from './Components/Await.class';
 export * from './Components/Classifier.class';
 export * from './Components/Component.class';
 export * from './Components/ComponentHost.class';
-export * from './Components/DataSourceCleaner.class';
-export * from './Components/DataSourceIndexer.class';
-export * from './Components/DataSourceLookup.class';
 export * from './Components/FEncDec.class';
 export * from './Components/FHash.class';
 export * from './Components/FileStore.class';
@@ -88,6 +85,9 @@ export * from './Components/APICall/parseHeaders';
 export * from './Components/APICall/parseProxy';
 export * from './Components/APICall/parseUrl';
 export * from './Components/Image/imageSettings.config';
+export * from './Components/RAG/DataSourceCleaner.class';
+export * from './Components/RAG/DataSourceComponent.class';
+export * from './Components/RAG/DataSourceLookup.class';
 export * from './Components/Triggers/Gmail.trigger';
 export * from './Components/Triggers/JobScheduler.trigger';
 export * from './Components/Triggers/Trigger.class';

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

@@ -34,6 +34,7 @@ export declare class MilvusVectorDB extends VectorDBConnector {
     embedder: BaseEmbedding;
     private SCHEMA_DEFINITION;
     private INDEX_PARAMS;
+    private nkvConnector;
     constructor(_settings: MilvusConfig);
     protected createNamespace(acRequest: AccessRequest, namespace: string, metadata?: {
         [key: string]: any;

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

@@ -7,13 +7,20 @@ import { DatasourceDto, IStorageVectorDataSource, IVectorDataSourceDto, QueryOpt
 import { BaseEmbedding, TEmbeddings } from '../embed/BaseEmbedding';
 export type PineconeConfig = {
     /**
-     * The Pinecone API key
+     * The Pinecone API key [LEGACY]
      */
-    apiKey: string;
+    apiKey?: string;
     /**
-     * The Pinecone index name
+     * The Pinecone index name [LEGACY]
      */
-    indexName: string;
+    indexName?: string;
+    /**
+     * The Pinecone credentials [New unified format]
+     */
+    credentials?: {
+        apiKey: string;
+        indexName: string;
+    };
     /**
      * The embeddings model to use
      */

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

@@ -20,5 +20,10 @@ export declare class EmbeddingsFactory {
     static create(provider?: SupportedProviders, config?: TEmbeddings & {
         model?: SupportedModels[SupportedProviders] | TLLMModel;
     }): OpenAIEmbeds | GoogleEmbeds;
+    static getProviderByModel(model: SupportedModels): SupportedProviders;
+    static getModels(): {
+        provider: SupportedProviders;
+        model: SupportedModels[SupportedProviders];
+    }[];
 }
 export {};

package/dist/types/subsystems/LLMManager/ModelsProvider.service/connectors/JSONModelsProvider.class.d.ts

@@ -35,6 +35,41 @@ export declare class JSONModelsProvider extends ModelsProviderConnector {
     private getValidModels;
     private isValidSingleModel;
     private isValidModel;
+    /**
+     * Determines whether a file path should be ignored by the directory watcher.
+     *
+     * This method implements a sophisticated filtering strategy for dot-segment paths
+     * (paths containing directories that start with a dot, like .git, .env, .cache).
+     *
+     * **Filtering Strategy:**
+     * 1. Paths WITHOUT dot segments: Never ignored
+     * 2. Paths WITH dot segments:
+     *    - If SMYTH_PATH is not configured: All ignored
+     *    - If SMYTH_PATH is configured:
+     *      - Allow the watched directory even if SMYTH_PATH contains dot-segments
+     *        (e.g., /home/user/.smyth/models/OpenAI/default.json is allowed)
+     *      - Ignore dot-segments INSIDE the models directory
+     *        (e.g., /home/user/.smyth/models/.hidden/model.json is ignored)
+     *      - Paths outside watched directory: Ignored
+     *
+     * @param filePath - The file path to check
+     * @param watchedDir - The absolute path of the directory being watched (models folder)
+     * @param smythPath - The resolved SMYTH_PATH, or null if not configured
+     * @returns true if the path should be ignored, false if it should be watched
+     *
+     * @example
+     * ```typescript
+     * // Path without dot-segment (allowed)
+     * shouldIgnorePath('/models/OpenAI/default.json', '/models', '/home/.smyth') // => false
+     *
+     * // Dot-segment inside models directory (ignored)
+     * shouldIgnorePath('/models/.git/config', '/models', '/home/.smyth') // => true
+     *
+     * // Dot-segment in parent path only (allowed)
+     * shouldIgnorePath('/home/.smyth/models/OpenAI/default.json', '/home/.smyth/models', '/home/.smyth') // => false
+     * ```
+     */
+    private shouldIgnorePath;
     private initDirWatcher;
 }
 export {};

package/dist/types/subsystems/Security/Account.service/AccountConnector.d.ts

@@ -9,7 +9,7 @@ export interface ISmythAccountRequest {
     getCandidateTeam(): Promise<string | undefined>;
     getAllTeamSettings(): Promise<KeyValueObject>;
     getAllUserSettings(): Promise<KeyValueObject>;
-    getTeamSetting(settingKey: string): Promise<string>;
+    getTeamSetting(settingKey: string, group?: string): Promise<string>;
     getUserSetting(settingKey: string): Promise<string>;
     getAgentSetting(settingKey: string): Promise<string>;
     getTeam(): Promise<string>;
@@ -23,7 +23,7 @@ export declare abstract class AccountConnector extends Connector {
     abstract getCandidateTeam(candidate: IAccessCandidate): Promise<string | undefined>;
     abstract getAllTeamSettings(acRequest: AccessRequest, teamId: string): Promise<KeyValueObject>;
     abstract getAllUserSettings(acRequest: AccessRequest, accountId: string): Promise<KeyValueObject>;
-    abstract getTeamSetting(acRequest: AccessRequest, teamId: string, settingKey: string): Promise<string>;
+    abstract getTeamSetting(acRequest: AccessRequest, teamId: string, settingKey: string, group?: string): Promise<string>;
     abstract getUserSetting(acRequest: AccessRequest, accountId: string, settingKey: string): Promise<string>;
     abstract getAgentSetting(acRequest: AccessRequest, agentId: string, settingKey: string): Promise<string>;
 }

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

@@ -14,12 +14,11 @@ export declare class SecretsManager extends VaultConnector {
     private secretsManager;
     private prefix;
     constructor(_settings: SecretsManagerConfig);
-    protected get(acRequest: AccessRequest, secretName: string): Promise<any>;
+    protected get(acRequest: AccessRequest, secretName: string): Promise<string>;
     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;
+    private extractSecretName;
 }

package/dist/types/types/VectorDB.types.d.ts

@@ -42,6 +42,10 @@ export interface IStorageVectorDataSource {
     id: string;
     candidateId: string;
     candidateRole: string;
+    datasourceSizeMb?: number;
+    createdAt?: Date;
+    chunkSize?: number;
+    chunkOverlap?: number;
 }
 export interface IStorageVectorNamespace {
     namespace: string;

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

@@ -22,3 +22,4 @@ export declare const kebabToCapitalize: (input: any) => any;
  * @param input
  */
 export declare const identifyMimetypeFromString: (input: string) => "application/json" | "text/plain" | "application/xml" | "text/html" | "text/css" | "text/csv" | "text/markdown" | "" | "image/svg+xml" | "application/javascript" | "application/yaml" | "application/sql";
+export declare function calcSizeMb(text: string): number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smythos/sre",
-  "version": "1.7.20",
+  "version": "1.7.40",
   "description": "Smyth Runtime Environment",
   "author": "Alaa-eddine KADDOURI",
   "license": "MIT",
@@ -68,7 +68,7 @@
     "@pinecone-database/pinecone": "^3.0.0",
     "@runware/sdk-js": "^1.1.36",
     "@smithy/smithy-client": "^4.4.3",
-    "@zilliz/milvus2-sdk-node": "^2.6.2",
+    "@zilliz/milvus2-sdk-node": "^2.6.4",
     "acorn": "^8.14.1",
     "axios": "^1.7.2",
     "chokidar": "^4.0.3",
@@ -117,7 +117,7 @@
   "scripts": {
     "gen:barrel": "ctix build",
     "build:types": "tsc --emitDeclarationOnly --declaration --outDir dist/types -p tsconfig.dts.json",
-    "build:jsbundle": "cross-env rollup -c",
+    "build:jsbundle": "cross-env NODE_OPTIONS='--max-old-space-size=8192' 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",

package/src/Components/APIEndpoint.class.ts

@@ -246,12 +246,7 @@ async function resolveTemplateVariables(data: any, input: any, agent: Agent): Pr
         if (isKeyTemplateVar(value as string)) {
             data[key] = await parseKey(value as string, agent.teamId);
         } else if (isTemplateVar(value as string)) {
-            // 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}}" }.
-            data[key] = TemplateString(value as string)
-                .parse(input)
-                .parse(agent.agentVariables).result;
+            data[key] = TemplateString(value as string).parse(input).result;
         }
     }
 

package/src/Components/Component.class.ts

@@ -3,6 +3,7 @@ import { IAgent as Agent } from '@sre/types/Agent.types';
 import { Logger } from '@sre/helpers/Log.helper';
 import { performTypeInference } from '@sre/helpers/TypeChecker.helper';
 import { hookableClass, hookAsync } from '@sre/Core/HookService';
+import { TemplateString } from '@sre/helpers/TemplateString.helper';
 
 export type TComponentSchema = {
     name: string;
@@ -123,7 +124,19 @@ export class Component {
         if (agent.isKilled()) {
             throw new Error('Agent killed');
         }
-        const _input = await performTypeInference(input, config?.inputs, agent);
+
+        let _input = {};
+
+        // #region Resolve agent variables so that:
+        // - type inference works correctly
+        // - we don’t need a separate resolution step when the variable name
+        //   matches the component input name
+        for (let [key, value] of Object.entries(input)) {
+            _input[key] = TemplateString(value as string).parse(agent.agentVariables).result;
+        }
+        // #endregion
+
+        _input = await performTypeInference(_input, config?.inputs, agent);
 
         // modify the input object for component's process method
         for (const [key, value] of Object.entries(_input)) {

package/src/Components/DataSourceIndexer.class.ts

@@ -8,6 +8,9 @@ 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 { EmbeddingsFactory, SupportedModels } from '@sre/IO/VectorDB.service/embed';
+import { getLLMCredentials } from '@sre/LLMManager/LLM.service/LLMCredentials.helper';
 
 export class DataSourceIndexer extends Component {
     private MAX_ALLOWED_URLS_PER_INPUT = 20;
@@ -16,6 +19,9 @@ export class DataSourceIndexer extends Component {
         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();
@@ -23,6 +29,18 @@ export class DataSourceIndexer extends Component {
     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;
@@ -72,47 +90,13 @@ export class DataSourceIndexer extends Component {
                 throw new Error(`Invalid id. Accepted characters: 'a-z', 'A-Z', '0-9', '-', '_', '.'`);
             }
 
-            // check if the datasource already exists with the same id
-            // await this.checkForRecordDuplicate(dsId, token);
-
             let indexRes: any = null;
             let parsedUrlArray: string[] | null = null;
-
-            //! DISABLE URL ARRAY PARSING FOR NOW UNTIL WE HAVE A GOOD WAY TO HANDLE BULK INDEXING
-            // if ((parsedUrlArray = parseUrlArray(inputSchema.value.Source))) {
-            //     debugOutput += `STEP: Parsing input as url array\n\n`;
-            //     if (parsedUrlArray.length > this.MAX_ALLOWED_URLS_PER_INPUT) {
-            //         throw new Error(`Too many urls in input. Max allowed: ${this.MAX_ALLOWED_URLS_PER_INPUT}`);
-            //     }
-
-            //     for (let url of parsedUrlArray) {
-            //         indexRes = await this.addDSFromUrl({
-            //             teamId,
-            //             namespaceId,
-            //             dsId, // WILL OVERRIDE EACH OTHER
-            //             type: detectURLSourceType(url),
-            //             url,
-            //             name: _config.name || 'Untitled',
-            //         });
-
-            //         debugOutput += `STEP: Created datasource for url: ${url}\n\n`;
-            //     }
-            // } else
-
             const dsId = DataSourceIndexer.genDsId(providedId, teamId, namespaceId);
 
             if (isUrl(inputSchema.value.Source)) {
                 debugOutput += `STEP: Parsing input as url\n\n`;
                 throw new Error('URLs are not supported yet');
-                // indexRes = await this.addDSFromUrl({
-                //     teamId,
-                //     namespaceId,
-                //     dsId,
-                //     type: detectURLSourceType(inputSchema.value.Source),
-                //     url: inputSchema.value.Source,
-                //     name: _config.name || 'Untitled',
-                //     metadata: _config.metadata || null,
-                // });
             } else {
                 debugOutput += `STEP: Parsing input as text\n\n`;
                 indexRes = await this.addDSFromText({
@@ -144,6 +128,136 @@ export class DataSourceIndexer extends Component {
         }
     }
 
+    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 namespaceId = _config.namespace;
+            debugOutput += `[Selected namespace] \n${namespaceLabel}\n\n`;
+
+            // resolve the ns record, if not exist, throw an error (new in v2)
+            // then we also need to resolve the credentials
+            const nkvConnector = ConnectorService.getNKVConnector();
+            const nkvClient = nkvConnector.requester(AccessCandidate.team(teamId));
+            const rawNsRecord = await nkvClient.get(`vectorDB:namespaces`, namespaceId);
+
+            if (!rawNsRecord) {
+                return {
+                    _debug: debugOutput,
+                    _error: `Namespace ${namespaceLabel} does not exist`,
+                };
+            }
+
+            // const { credentialId, embeddings: embeddingsOptions } = JSON.parse(rawNsRecord.toString());
+            const namespaceRecord = JSON.parse(rawNsRecord.toString());
+            const accountConnector = ConnectorService.getAccountConnector();
+            const accountClient = accountConnector.requester(AccessCandidate.team(teamId));
+            const rawCredRecord = await accountClient.getTeamSetting(namespaceRecord.credentialId, 'vector_db_creds');
+            if (!rawCredRecord) {
+                throw new Error(`Credential ${namespaceRecord.credentialId} does not exist`);
+            }
+            const credRecord = JSON.parse(rawCredRecord);
+            await Promise.all(
+                Object.keys(credRecord.credentials).map(async (key) => {
+                    if (typeof credRecord.credentials[key] !== 'string') return;
+                    credRecord.credentials[key] = await TemplateString(credRecord.credentials[key]).parseTeamKeysAsync(teamId).asyncResult;
+                })
+            );
+
+            const vecDbConnector = ConnectorService.getVectorDBConnector(credRecord.provider).instance({
+                credentials: credRecord.credentials,
+                embeddings: await this.transformEmbedding(namespaceRecord.embeddings, config.data, teamId),
+            });
+            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.genDsId(providedId, teamId, namespaceLabel);
+
+            debugOutput += `STEP: Parsing input as text\n\n`;
+
+            const response = await vecDbClient.createDatasource(namespaceLabel, {
+                text: inputSchema.value.Source,
+                metadata: _config.metadata || null,
+                id: dsId,
+                label: _config.name || 'Untitled',
+            });
+
+            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",
+            };
+        }
+    }
+
+    private async transformEmbedding(embedding: { dimensions: string; modelId: string }, data: any, teamId: string): Promise<TEmbeddings> {
+        // we need to take this and return a proper TEmbeddings object
+
+        const provider = EmbeddingsFactory.getProviderByModel(embedding.modelId as any);
+
+        // based on the provider, we should be able to retreive the correct credentials
+        const modelsProvider = ConnectorService.getModelsProviderConnector();
+        const modelProviderCandidate = modelsProvider.requester(AccessCandidate.team(teamId));
+        const modelInfo = await modelProviderCandidate.getModelInfo(embedding.modelId);
+
+        const llmCreds = await getLLMCredentials(AccessCandidate.team(teamId), modelInfo);
+
+        return {
+            provider,
+            model: embedding.modelId,
+            credentials: llmCreds,
+            params: {
+                dimensions: parseInt(embedding.dimensions),
+                chunkSize: data.chunkSize,
+            },
+        };
+    }
+
     validateInput(input: any) {
         return Joi.object({
             Source: Joi.any().required(),

package/src/Components/GenAILLM.class.ts

@@ -528,26 +528,36 @@ export class GenAILLM extends Component {
             response = await contentPromise.catch((error) => {
                 return { error: error.message || error };
             });
-            // If the model stopped before completing the response, this is usually due to output token limit reached.
+
+            // #region Handle Response Errors
+            if (response?.error) {
+                const error = response?.error + ' ' + (response?.details || '');
+                logger.error(` LLM Error=`, error);
+
+                return { Output: response?.data, _error: error, _debug: logger.output };
+            }
+
+            const emptyResponseErrorMsg =
+                "Empty response. This is usually due to output token limit reached. Please try again with a higher 'Maximum Output Tokens'.";
+
+            // If the finish reason is not "stop", it means the model stopped before completing the response.
             if (finishReason !== 'stop') {
+                let errMsg = `The model stopped before completing the response.
+                \nReason: ${finishReason}.
+                \n${!response ? emptyResponseErrorMsg : ''}`;
+
                 return {
                     Reply: response,
-                    _error: 'The model stopped before completing the response, this is usually due to output token limit reached.',
+                    _error: errMsg,
                     _debug: logger.output,
                 };
             }
 
-            // in case we have the response but it's empty string, undefined or null
+            // If the finish reason is "stop" but there is still no response, it is usually caused by reaching the output token limit.
             if (!response) {
-                return { _error: ' LLM Error = Empty Response!', _debug: logger.output };
-            }
-
-            if (response?.error) {
-                const error = response?.error + ' ' + (response?.details || '');
-                logger.error(` LLM Error=`, error);
-
-                return { Output: response?.data, _error: error, _debug: logger.output };
+                return { _error: emptyResponseErrorMsg, _debug: logger.output };
             }
+            // #endregion
 
             const Reply = llmInference.connector.postProcess(response);
             if (Reply.error) {