@smythos/sre 1.5.60 → 1.5.63

package/dist/types/subsystems/LLMManager/LLM.service/LLMConnector.d.ts

@@ -1,6 +1,6 @@
 import { Connector } from '@sre/Core/Connector.class';
 import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
-import type { TLLMConnectorParams, TLLMMessageBlock, TLLMToolResultMessageBlock, ToolData, APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TLLMRequestBody } from '@sre/types/LLM.types';
+import type { APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TLLMConnectorParams, TLLMMessageBlock, TLLMRequestBody, TLLMToolResultMessageBlock, ToolData } from '@sre/types/LLM.types';
 import EventEmitter from 'events';
 import { Readable } from 'stream';
 export interface ILLMConnectorRequest {

package/package.json

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

package/src/subsystems/LLMManager/LLM.service/LLMConnector.ts

@@ -1,33 +1,32 @@
 import { Connector } from '@sre/Core/Connector.class';
 import { ConnectorService } from '@sre/Core/ConnectorsService';
+import { JSONContent } from '@sre/helpers/JsonContent.helper';
 import { Logger } from '@sre/helpers/Log.helper';
+import { ModelsProviderConnector } from '@sre/LLMManager/ModelsProvider.service/ModelsProviderConnector';
 import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
-import { JSONContent } from '@sre/helpers/JsonContent.helper';
+import { AccountConnector } from '@sre/Security/Account.service/AccountConnector';
+import { VaultConnector } from '@sre/Security/Vault.service/VaultConnector';
 import type {
-    TLLMConnectorParams,
-    TLLMMessageBlock,
-    TLLMToolResultMessageBlock,
-    ToolData,
     APIKeySource,
-    TLLMModel,
     ILLMRequestFuncParams,
     TLLMChatResponse,
+    TLLMConnectorParams,
+    TLLMMessageBlock,
+    TLLMModel,
+    TLLMPreparedParams,
     TLLMRequestBody,
+    TLLMToolResultMessageBlock,
+    ToolData,
     TOpenAIToolsInfo,
-    TxAIToolsInfo,
-    TLLMPreparedParams,
     TToolsInfo,
+    TxAIToolsInfo,
 } from '@sre/types/LLM.types';
+import { TCustomLLMModel } from '@sre/types/LLM.types';
 import EventEmitter from 'events';
 import { Readable } from 'stream';
-import { AccountConnector } from '@sre/Security/Account.service/AccountConnector';
-import { VaultConnector } from '@sre/Security/Vault.service/VaultConnector';
-import { TCustomLLMModel } from '@sre/types/LLM.types';
-import config from '@sre/config';
-import { ModelsProviderConnector } from '@sre/LLMManager/ModelsProvider.service/ModelsProviderConnector';
 import { getLLMCredentials } from './LLMCredentials.helper';
 
-const console = Logger('LLMConnector');
+const logger = Logger('LLMConnector');
 
 export interface ILLMConnectorRequest {
     // chatRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<any>;
@@ -100,11 +99,12 @@ export abstract class LLMConnector extends Connector {
         this.vaultConnector = ConnectorService.getVaultConnector();
 
         if (!this.vaultConnector || !this.vaultConnector.valid) {
-            console.warn(`Vault Connector unavailable for ${candidate.id} `);
+            logger.warn(`Vault Connector unavailable for ${candidate.id} `);
         }
 
         const _request: ILLMConnectorRequest = {
             request: async (params: TLLMConnectorParams) => {
+                logger.debug(`request ${this.name}`, candidate);
                 const preparedParams = await this.prepareParams(candidate, params);
 
                 const provider = preparedParams.modelInfo.provider;
@@ -129,6 +129,7 @@ export abstract class LLMConnector extends Connector {
                 return response;
             },
             streamRequest: async (params: TLLMConnectorParams) => {
+                logger.debug(`streamRequest ${this.name}`, candidate);
                 const preparedParams = await this.prepareParams(candidate, params);
 
                 const provider = preparedParams.modelInfo.provider?.toLowerCase();
@@ -156,6 +157,7 @@ export abstract class LLMConnector extends Connector {
             },
 
             imageGenRequest: async (params: any) => {
+                logger.debug(`imageGenRequest ${this.name}`, candidate);
                 const preparedParams = await this.prepareParams(candidate, params);
 
                 const response = await this.imageGenRequest({
@@ -175,6 +177,7 @@ export abstract class LLMConnector extends Connector {
                 return response;
             },
             imageEditRequest: async (params: any) => {
+                logger.debug(`imageEditRequest ${this.name}`, candidate);
                 const preparedParams = await this.prepareParams(candidate, params);
 
                 const response = await this.imageEditRequest({

package/src/subsystems/LLMManager/LLM.service/connectors/Anthropic.class.ts

@@ -25,6 +25,9 @@ import { JSONContent } from '@sre/helpers/JsonContent.helper';
 import { LLMConnector } from '../LLMConnector';
 import { SystemEvents } from '@sre/Core/SystemEvents';
 import { SUPPORTED_MIME_TYPES_MAP } from '@sre/constants';
+import { Logger } from '@sre/helpers/Log.helper';
+
+const logger = Logger('AnthropicConnector');
 
 const PREFILL_TEXT_FOR_JSON_RESPONSE = '{';
 const LEGACY_THINKING_MODELS = ['smythos/claude-3.7-sonnet-thinking', 'claude-3.7-sonnet-thinking'];
@@ -49,6 +52,7 @@ export class AnthropicConnector extends LLMConnector {
 
     protected async request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
         try {
+            logger.debug(`request ${this.name}`, acRequest.candidate);
             const anthropic = await this.getClient(context);
             const result = await anthropic.messages.create(body);
             const message: Anthropic.MessageParam = {
@@ -104,12 +108,14 @@ export class AnthropicConnector extends LLMConnector {
                 usage,
             };
         } catch (error) {
+            logger.error(`request ${this.name}`, error, acRequest.candidate);
             throw error;
         }
     }
 
     protected async streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter> {
         try {
+            logger.debug(`streamRequest ${this.name}`, acRequest.candidate);
             const emitter = new EventEmitter();
             const usage_data = [];
 
@@ -199,6 +205,7 @@ export class AnthropicConnector extends LLMConnector {
 
             return emitter;
         } catch (error: any) {
+            logger.error(`streamRequest ${this.name}`, error, acRequest.candidate);
             throw error;
         }
     }

package/src/subsystems/LLMManager/LLM.service/connectors/Bedrock.class.ts

@@ -30,6 +30,9 @@ import { isJSONString } from '@sre/utils/general.utils';
 import { LLMConnector } from '../LLMConnector';
 import { JSONContent } from '@sre/helpers/JsonContent.helper';
 import { SystemEvents } from '@sre/Core/SystemEvents';
+import { Logger } from '@sre/helpers/Log.helper';
+
+const logger = Logger('BedrockConnector');
 
 // TODO [Forhad]: Need to adjust some type definitions
 
@@ -50,6 +53,7 @@ export class BedrockConnector extends LLMConnector {
 
     protected async request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
         try {
+            logger.debug(`request ${this.name}`, acRequest.candidate);
             const bedrock = await this.getClient(context);
             const command = new ConverseCommand(body);
             const response: ConverseCommandOutput = await bedrock.send(command);
@@ -91,6 +95,7 @@ export class BedrockConnector extends LLMConnector {
                 usage,
             };
         } catch (error: any) {
+            logger.error(`request ${this.name}`, error, acRequest.candidate);
             throw error?.error || error;
         }
     }
@@ -99,6 +104,7 @@ export class BedrockConnector extends LLMConnector {
         const emitter = new EventEmitter();
 
         try {
+            logger.debug(`streamRequest ${this.name}`, acRequest.candidate);
             const bedrock = await this.getClient(context);
             const command = new ConverseStreamCommand(body);
             const response: ConverseStreamCommandOutput = await bedrock.send(command);
@@ -189,6 +195,7 @@ export class BedrockConnector extends LLMConnector {
             return emitter;
         } catch (error: unknown) {
             const typedError = error as Error;
+            logger.error(`streamRequest ${this.name}`, typedError, acRequest.candidate);
             emitter.emit(TLLMEvent.Error, typedError?.['error'] || typedError);
             return emitter;
         }

package/src/subsystems/LLMManager/LLM.service/connectors/Echo.class.ts

@@ -2,54 +2,69 @@ import { JSONContent } from '@sre/helpers/JsonContent.helper';
 import { LLMConnector } from '../LLMConnector';
 import EventEmitter from 'events';
 import { APIKeySource, ILLMRequestFuncParams, TLLMChatResponse, TLLMPreparedParams } from '@sre/types/LLM.types';
+import { Logger } from '@sre/helpers/Log.helper';
+
+const logger = Logger('EchoConnector');
 
 export class EchoConnector extends LLMConnector {
     public name = 'LLM:Echo';
 
     protected async request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
-        const content = body?.messages?.[0]?.content; // As Echo model only used in PromptGenerator so we can assume the first message is the user message to echo
-        return {
-            content,
-            finishReason: 'stop',
-            useTool: false,
-            toolsData: [],
-            message: { content, role: 'assistant' },
-            usage: {},
-        } as TLLMChatResponse;
+        try {
+            logger.debug(`request ${this.name}`, acRequest.candidate);
+            const content = body?.messages?.[0]?.content; // As Echo model only used in PromptGenerator so we can assume the first message is the user message to echo
+            return {
+                content,
+                finishReason: 'stop',
+                useTool: false,
+                toolsData: [],
+                message: { content, role: 'assistant' },
+                usage: {},
+            } as TLLMChatResponse;
+        } catch (error) {
+            logger.error(`request ${this.name}`, error, acRequest.candidate);
+            throw error;
+        }
     }
 
     protected async streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter> {
-        const emitter = new EventEmitter();
-        let content = '';
+        try {
+            logger.debug(`streamRequest ${this.name}`, acRequest.candidate);
+            const emitter = new EventEmitter();
+            let content = '';
 
-        if (Array.isArray(body?.messages)) {
-            content = body?.messages?.filter((m) => m.role === 'user').pop()?.content;
-        }
-        //params?.messages?.[0]?.content;
+            if (Array.isArray(body?.messages)) {
+                content = body?.messages?.filter((m) => m.role === 'user').pop()?.content;
+            }
+            //params?.messages?.[0]?.content;
 
-        // Process stream asynchronously as we need to return emitter immediately
-        (async () => {
-            // Simulate streaming by splitting content into chunks
-            const chunks = content.split(' ');
+            // Process stream asynchronously as we need to return emitter immediately
+            (async () => {
+                // Simulate streaming by splitting content into chunks
+                const chunks = content.split(' ');
 
-            for (let i = 0; i < chunks.length; i++) {
-                // Simulate network delay
-                await new Promise((resolve) => setTimeout(resolve, 50));
+                for (let i = 0; i < chunks.length; i++) {
+                    // Simulate network delay
+                    await new Promise((resolve) => setTimeout(resolve, 50));
 
-                const isLastChunk = i === chunks.length - 1;
-                // Add space between chunks except for the last one to avoid trailing space in file URLs
-                const delta = { content: chunks[i] + (isLastChunk ? '' : ' ') };
-                emitter.emit('data', delta);
-                emitter.emit('content', delta.content);
-            }
+                    const isLastChunk = i === chunks.length - 1;
+                    // Add space between chunks except for the last one to avoid trailing space in file URLs
+                    const delta = { content: chunks[i] + (isLastChunk ? '' : ' ') };
+                    emitter.emit('data', delta);
+                    emitter.emit('content', delta.content);
+                }
 
-            // Emit end event after all chunks are processed
-            setTimeout(() => {
-                emitter.emit('end', [], []); // Empty arrays for toolsData and usage_data
-            }, 100);
-        })();
+                // Emit end event after all chunks are processed
+                setTimeout(() => {
+                    emitter.emit('end', [], []); // Empty arrays for toolsData and usage_data
+                }, 100);
+            })();
 
-        return emitter;
+            return emitter;
+        } catch (error) {
+            logger.error(`streamRequest ${this.name}`, error, acRequest.candidate);
+            throw error;
+        }
     }
 
     protected async reqBodyAdapter(params: TLLMPreparedParams): Promise<any> {

package/src/subsystems/LLMManager/LLM.service/connectors/GoogleAI.class.ts

@@ -32,9 +32,12 @@ import { LLMHelper } from '@sre/LLMManager/LLM.helper';
 
 import { SystemEvents } from '@sre/Core/SystemEvents';
 import { SUPPORTED_MIME_TYPES_MAP } from '@sre/constants';
+import { Logger } from '@sre/helpers/Log.helper';
 
 import { LLMConnector } from '../LLMConnector';
 
+const logger = Logger('GoogleAIConnector');
+
 const MODELS_SUPPORT_SYSTEM_INSTRUCTION = [
     'gemini-1.5-pro-exp-0801',
     'gemini-1.5-pro-latest',
@@ -76,6 +79,7 @@ export class GoogleAIConnector extends LLMConnector {
 
     protected async request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
         try {
+            logger.debug(`request ${this.name}`, acRequest.candidate);
             const prompt = body.messages;
             delete body.messages;
 
@@ -121,11 +125,13 @@ export class GoogleAIConnector extends LLMConnector {
                 usage,
             };
         } catch (error: any) {
+            logger.error(`request ${this.name}`, error, acRequest.candidate);
             throw error;
         }
     }
 
     protected async streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter> {
+        logger.debug(`streamRequest ${this.name}`, acRequest.candidate);
         const emitter = new EventEmitter();
 
         const prompt = body.messages;
@@ -189,6 +195,7 @@ export class GoogleAIConnector extends LLMConnector {
 
             return emitter;
         } catch (error: any) {
+            logger.error(`streamRequest ${this.name}`, error, acRequest.candidate);
             throw error;
         }
     }

package/src/subsystems/LLMManager/LLM.service/connectors/Groq.class.ts

@@ -19,6 +19,9 @@ import { LLMHelper } from '@sre/LLMManager/LLM.helper';
 
 import { LLMConnector } from '../LLMConnector';
 import { SystemEvents } from '@sre/Core/SystemEvents';
+import { Logger } from '@sre/helpers/Log.helper';
+
+const logger = Logger('GroqConnector');
 
 type ChatCompletionCreateParams = {
     model: string;
@@ -48,105 +51,117 @@ export class GroqConnector extends LLMConnector {
     }
 
     protected async request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
-        const groq = await this.getClient(context);
-        const result = await groq.chat.completions.create(body);
-        const message = result?.choices?.[0]?.message;
-        const finishReason = result?.choices?.[0]?.finish_reason;
-        const toolCalls = message?.tool_calls;
-        const usage = result.usage;
-        this.reportUsage(usage, {
-            modelEntryName: context.modelEntryName,
-            keySource: context.isUserKey ? APIKeySource.User : APIKeySource.Smyth,
-            agentId: context.agentId,
-            teamId: context.teamId,
-        });
+        try {
+            logger.debug(`request ${this.name}`, acRequest.candidate);
+            const groq = await this.getClient(context);
+            const result = await groq.chat.completions.create(body);
+            const message = result?.choices?.[0]?.message;
+            const finishReason = result?.choices?.[0]?.finish_reason;
+            const toolCalls = message?.tool_calls;
+            const usage = result.usage;
+            this.reportUsage(usage, {
+                modelEntryName: context.modelEntryName,
+                keySource: context.isUserKey ? APIKeySource.User : APIKeySource.Smyth,
+                agentId: context.agentId,
+                teamId: context.teamId,
+            });
 
-        let toolsData: ToolData[] = [];
-        let useTool = false;
-
-        if (toolCalls) {
-            toolsData = toolCalls.map((tool, index) => ({
-                index,
-                id: tool.id,
-                type: tool.type,
-                name: tool.function.name,
-                arguments: tool.function.arguments,
-                role: TLLMMessageRole.Assistant,
-            }));
-            useTool = true;
-        }
+            let toolsData: ToolData[] = [];
+            let useTool = false;
+
+            if (toolCalls) {
+                toolsData = toolCalls.map((tool, index) => ({
+                    index,
+                    id: tool.id,
+                    type: tool.type,
+                    name: tool.function.name,
+                    arguments: tool.function.arguments,
+                    role: TLLMMessageRole.Assistant,
+                }));
+                useTool = true;
+            }
 
-        return {
-            content: message?.content ?? '',
-            finishReason,
-            useTool,
-            toolsData,
-            message,
-            usage,
-        };
+            return {
+                content: message?.content ?? '',
+                finishReason,
+                useTool,
+                toolsData,
+                message,
+                usage,
+            };
+        } catch (error) {
+            logger.error(`request ${this.name}`, error, acRequest.candidate);
+            throw error;
+        }
     }
 
     protected async streamRequest({ acRequest, body, context }: ILLMRequestFuncParams): Promise<EventEmitter> {
-        const emitter = new EventEmitter();
-        const usage_data = [];
-
-        const groq = await this.getClient(context);
-        const stream = await groq.chat.completions.create({ ...body, stream: true, stream_options: { include_usage: true } });
-
-        let toolsData: ToolData[] = [];
-
-        (async () => {
-            for await (const chunk of stream as any) {
-                const delta = chunk.choices[0]?.delta;
-                const usage = chunk['x_groq']?.usage || chunk['usage'];
-
-                if (usage) {
-                    usage_data.push(usage);
+        try {
+            logger.debug(`streamRequest ${this.name}`, acRequest.candidate);
+            const emitter = new EventEmitter();
+            const usage_data = [];
+
+            const groq = await this.getClient(context);
+            const stream = await groq.chat.completions.create({ ...body, stream: true, stream_options: { include_usage: true } });
+
+            let toolsData: ToolData[] = [];
+
+            (async () => {
+                for await (const chunk of stream as any) {
+                    const delta = chunk.choices[0]?.delta;
+                    const usage = chunk['x_groq']?.usage || chunk['usage'];
+
+                    if (usage) {
+                        usage_data.push(usage);
+                    }
+                    emitter.emit('data', delta);
+
+                    if (delta?.content) {
+                        emitter.emit('content', delta.content);
+                    }
+
+                    if (delta?.tool_calls) {
+                        delta.tool_calls.forEach((toolCall, index) => {
+                            if (!toolsData[index]) {
+                                toolsData[index] = {
+                                    index,
+                                    id: toolCall.id,
+                                    type: toolCall.type,
+                                    name: toolCall.function?.name,
+                                    arguments: toolCall.function?.arguments,
+                                    role: 'assistant',
+                                };
+                            } else {
+                                toolsData[index].arguments += toolCall.function?.arguments || '';
+                            }
+                        });
+                    }
                 }
-                emitter.emit('data', delta);
 
-                if (delta?.content) {
-                    emitter.emit('content', delta.content);
+                if (toolsData.length > 0) {
+                    emitter.emit(TLLMEvent.ToolInfo, toolsData);
                 }
 
-                if (delta?.tool_calls) {
-                    delta.tool_calls.forEach((toolCall, index) => {
-                        if (!toolsData[index]) {
-                            toolsData[index] = {
-                                index,
-                                id: toolCall.id,
-                                type: toolCall.type,
-                                name: toolCall.function?.name,
-                                arguments: toolCall.function?.arguments,
-                                role: 'assistant',
-                            };
-                        } else {
-                            toolsData[index].arguments += toolCall.function?.arguments || '';
-                        }
+                usage_data.forEach((usage) => {
+                    // probably we can acc them and send them as one event
+                    this.reportUsage(usage, {
+                        modelEntryName: context.modelEntryName,
+                        keySource: context.isUserKey ? APIKeySource.User : APIKeySource.Smyth,
+                        agentId: context.agentId,
+                        teamId: context.teamId,
                     });
-                }
-            }
-
-            if (toolsData.length > 0) {
-                emitter.emit(TLLMEvent.ToolInfo, toolsData);
-            }
-
-            usage_data.forEach((usage) => {
-                // probably we can acc them and send them as one event
-                this.reportUsage(usage, {
-                    modelEntryName: context.modelEntryName,
-                    keySource: context.isUserKey ? APIKeySource.User : APIKeySource.Smyth,
-                    agentId: context.agentId,
-                    teamId: context.teamId,
                 });
-            });
 
-            setTimeout(() => {
-                emitter.emit('end', toolsData);
-            }, 100);
-        })();
+                setTimeout(() => {
+                    emitter.emit('end', toolsData);
+                }, 100);
+            })();
 
-        return emitter;
+            return emitter;
+        } catch (error: any) {
+            logger.error(`streamRequest ${this.name}`, error, acRequest.candidate);
+            throw error;
+        }
     }
 
     protected async reqBodyAdapter(params: TLLMPreparedParams): Promise<ChatCompletionCreateParams> {

package/src/subsystems/LLMManager/LLM.service/connectors/Perplexity.class.ts

@@ -19,6 +19,9 @@ import { LLMHelper } from '@sre/LLMManager/LLM.helper';
 
 import { LLMConnector } from '../LLMConnector';
 import { SystemEvents } from '@sre/Core/SystemEvents';
+import { Logger } from '@sre/helpers/Log.helper';
+
+const logger = Logger('PerplexityConnector');
 
 type ChatCompletionParams = {
     model: string;
@@ -57,6 +60,7 @@ export class PerplexityConnector extends LLMConnector {
 
     protected async request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
         try {
+            logger.debug(`request ${this.name}`, acRequest.candidate);
             const perplexity = await this.getClient(context);
             const response = await perplexity.post('/chat/completions', body);
 
@@ -80,6 +84,7 @@ export class PerplexityConnector extends LLMConnector {
                 usage,
             };
         } catch (error) {
+            logger.error(`request ${this.name}`, error, acRequest.candidate);
             throw error;
         }
     }
@@ -91,6 +96,7 @@ export class PerplexityConnector extends LLMConnector {
 
         setTimeout(() => {
             try {
+                logger.debug(`streamRequest ${this.name}`, acRequest.candidate);
                 this.request({ acRequest, body, context })
                     .then((respose) => {
                         const finishReason = respose.finishReason;
@@ -105,6 +111,7 @@ export class PerplexityConnector extends LLMConnector {
                     });
                 //emitter.emit('finishReason', respose.finishReason);
             } catch (error) {
+                logger.error(`streamRequest ${this.name}`, error, acRequest.candidate);
                 emitter.emit('error', error.message || error.toString());
             }
         }, 100);

package/src/subsystems/LLMManager/LLM.service/connectors/VertexAI.class.ts

@@ -23,6 +23,9 @@ import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.cla
 
 import { LLMConnector } from '../LLMConnector';
 import { SystemEvents } from '@sre/Core/SystemEvents';
+import { Logger } from '@sre/helpers/Log.helper';
+
+const logger = Logger('VertexAIConnector');
 
 //TODO: [AHMED/FORHAD]: test the usage reporting for VertexAI because by the time we were implementing the feature of usage reporting
 // we had no access to VertexAI so we assumed it is working (potential bug)
@@ -48,6 +51,7 @@ export class VertexAIConnector extends LLMConnector {
 
     protected async request({ acRequest, body, context }: ILLMRequestFuncParams): Promise<TLLMChatResponse> {
         try {
+            logger.debug(`request ${this.name}`, acRequest.candidate);
             const vertexAI = await this.getClient(context);
 
             // Separate contents from model configuration
@@ -101,6 +105,7 @@ export class VertexAIConnector extends LLMConnector {
                 useTool,
             };
         } catch (error) {
+            logger.error(`request ${this.name}`, error, acRequest.candidate);
             throw error;
         }
     }
@@ -110,6 +115,7 @@ export class VertexAIConnector extends LLMConnector {
 
         setTimeout(async () => {
             try {
+                logger.debug(`streamRequest ${this.name}`, acRequest.candidate);
                 const vertexAI = await this.getClient(context);
 
                 // Separate contents from model configuration
@@ -174,6 +180,7 @@ export class VertexAIConnector extends LLMConnector {
                     emitter.emit('end', toolsData, usageData, finishReason);
                 }, 100);
             } catch (error) {
+                logger.error(`streamRequest ${this.name}`, error, acRequest.candidate);
                 emitter.emit('error', error);
             }
         }, 100);