@juspay/neurolink 7.29.2 → 7.30.0

package/dist/providers/googleVertex.js

@@ -101,7 +101,7 @@ const createVertexSettings = async () => {
                 return baseSettings;
             }
         }
-        catch (_error) {
+        catch {
             // Silent error handling for runtime credentials file creation
         }
     }
@@ -187,7 +187,7 @@ const createVertexSettings = async () => {
                 hasProjectId: !!requiredEnvVars.project_id,
                 hasType: !!requiredEnvVars.type,
                 missingFields: Object.entries(requiredEnvVars)
-                    .filter(([key, value]) => !value)
+                    .filter(([_key, value]) => !value)
                     .map(([key]) => key),
             },
         },
@@ -272,12 +272,9 @@ export class GoogleVertexProvider extends BaseProvider {
         return model;
     }
     /**
-     * Gets the appropriate model instance (Google or Anthropic)
-     * Uses dual provider architecture for proper model routing
-     * Creates fresh instances for each request to ensure proper authentication
+     * Initialize model creation logging and tracking
      */
-    async getModel() {
-        // 🚀 EXHAUSTIVE LOGGING POINT V001: MODEL CREATION ENTRY
+    initializeModelCreationLogging() {
         const modelCreationId = `vertex-model-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
         const modelCreationStartTime = Date.now();
         const modelCreationHrTimeStart = process.hrtime.bigint();
@@ -310,7 +307,17 @@ export class GoogleVertexProvider extends BaseProvider {
             cpuUsage: process.cpuUsage(),
             message: "Starting model creation with comprehensive environment analysis",
         });
-        // 🚀 EXHAUSTIVE LOGGING POINT V002: ANTHROPIC MODEL CHECK
+        return {
+            modelCreationId,
+            modelCreationStartTime,
+            modelCreationHrTimeStart,
+            modelName,
+        };
+    }
+    /**
+     * Check if model is Anthropic-based and attempt creation
+     */
+    async attemptAnthropicModelCreation(modelName, modelCreationId, modelCreationStartTime, modelCreationHrTimeStart) {
         const anthropicCheckStartTime = process.hrtime.bigint();
         const isAnthropic = isAnthropicModel(modelName);
         logger.debug(`[GoogleVertexProvider] 🤖 LOG_POINT_V002_ANTHROPIC_CHECK`, {
@@ -327,90 +334,93 @@ export class GoogleVertexProvider extends BaseProvider {
             anthropicModelPatterns: ["claude"],
             message: "Checking if model is Anthropic-based",
         });
-        // Check if this is an Anthropic model and use appropriate provider
-        if (isAnthropic) {
-            // 🚀 EXHAUSTIVE LOGGING POINT V003: ANTHROPIC MODEL CREATION START
-            const anthropicModelStartTime = process.hrtime.bigint();
-            logger.debug(`[GoogleVertexProvider] 🧠 LOG_POINT_V003_ANTHROPIC_MODEL_START`, {
-                logPoint: "V003_ANTHROPIC_MODEL_START",
+        if (!isAnthropic) {
+            return null;
+        }
+        const anthropicModelStartTime = process.hrtime.bigint();
+        logger.debug(`[GoogleVertexProvider] 🧠 LOG_POINT_V003_ANTHROPIC_MODEL_START`, {
+            logPoint: "V003_ANTHROPIC_MODEL_START",
+            modelCreationId,
+            timestamp: new Date().toISOString(),
+            elapsedMs: Date.now() - modelCreationStartTime,
+            elapsedNs: (process.hrtime.bigint() - modelCreationHrTimeStart).toString(),
+            anthropicModelStartTimeNs: anthropicModelStartTime.toString(),
+            modelName,
+            hasAnthropicSupport: hasAnthropicSupport(),
+            message: "Creating Anthropic model using vertexAnthropic provider",
+        });
+        logger.debug("Creating Anthropic model using vertexAnthropic provider", {
+            modelName,
+        });
+        if (!hasAnthropicSupport()) {
+            logger.warn(`[GoogleVertexProvider] Anthropic support not available, falling back to Google model`);
+            return null;
+        }
+        try {
+            const anthropicModel = await this.createAnthropicModel(modelName);
+            if (anthropicModel) {
+                const anthropicModelSuccessTime = process.hrtime.bigint();
+                const anthropicModelDurationNs = anthropicModelSuccessTime - anthropicModelStartTime;
+                logger.debug(`[GoogleVertexProvider] ✅ LOG_POINT_V004_ANTHROPIC_MODEL_SUCCESS`, {
+                    logPoint: "V004_ANTHROPIC_MODEL_SUCCESS",
+                    modelCreationId,
+                    timestamp: new Date().toISOString(),
+                    elapsedMs: Date.now() - modelCreationStartTime,
+                    elapsedNs: (process.hrtime.bigint() - modelCreationHrTimeStart).toString(),
+                    anthropicModelDurationNs: anthropicModelDurationNs.toString(),
+                    anthropicModelDurationMs: Number(anthropicModelDurationNs) / 1000000,
+                    modelName,
+                    hasAnthropicModel: !!anthropicModel,
+                    anthropicModelType: typeof anthropicModel,
+                    memoryUsageAfterAnthropicCreation: process.memoryUsage(),
+                    message: "Anthropic model created successfully via vertexAnthropic",
+                });
+                return anthropicModel;
+            }
+            // Anthropic model creation returned null
+            const anthropicModelNullTime = process.hrtime.bigint();
+            const anthropicModelDurationNs = anthropicModelNullTime - anthropicModelStartTime;
+            logger.warn(`[GoogleVertexProvider] ⚠️ LOG_POINT_V005_ANTHROPIC_MODEL_NULL`, {
+                logPoint: "V005_ANTHROPIC_MODEL_NULL",
                 modelCreationId,
                 timestamp: new Date().toISOString(),
                 elapsedMs: Date.now() - modelCreationStartTime,
                 elapsedNs: (process.hrtime.bigint() - modelCreationHrTimeStart).toString(),
-                anthropicModelStartTimeNs: anthropicModelStartTime.toString(),
+                anthropicModelDurationNs: anthropicModelDurationNs.toString(),
+                anthropicModelDurationMs: Number(anthropicModelDurationNs) / 1000000,
                 modelName,
-                hasAnthropicSupport: hasAnthropicSupport(),
-                message: "Creating Anthropic model using vertexAnthropic provider",
+                hasAnthropicModel: false,
+                fallbackToGoogle: true,
+                message: "Anthropic model creation returned null - falling back to Google model",
             });
-            logger.debug("Creating Anthropic model using vertexAnthropic provider", {
+        }
+        catch (error) {
+            const anthropicModelErrorTime = process.hrtime.bigint();
+            const anthropicModelDurationNs = anthropicModelErrorTime - anthropicModelStartTime;
+            logger.error(`[GoogleVertexProvider] ❌ LOG_POINT_V006_ANTHROPIC_MODEL_ERROR`, {
+                logPoint: "V006_ANTHROPIC_MODEL_ERROR",
+                modelCreationId,
+                timestamp: new Date().toISOString(),
+                elapsedMs: Date.now() - modelCreationStartTime,
+                elapsedNs: (process.hrtime.bigint() - modelCreationHrTimeStart).toString(),
+                anthropicModelDurationNs: anthropicModelDurationNs.toString(),
+                anthropicModelDurationMs: Number(anthropicModelDurationNs) / 1000000,
                 modelName,
+                error: error instanceof Error ? error.message : String(error),
+                errorName: error instanceof Error ? error.name : "UnknownError",
+                errorStack: error instanceof Error ? error.stack : undefined,
+                fallbackToGoogle: true,
+                message: "Anthropic model creation failed - falling back to Google model",
             });
-            if (!hasAnthropicSupport()) {
-                logger.warn(`[GoogleVertexProvider] Anthropic support not available, falling back to Google model`);
-            }
-            else {
-                try {
-                    const anthropicModel = await this.createAnthropicModel(modelName);
-                    if (anthropicModel) {
-                        const anthropicModelSuccessTime = process.hrtime.bigint();
-                        const anthropicModelDurationNs = anthropicModelSuccessTime - anthropicModelStartTime;
-                        logger.debug(`[GoogleVertexProvider] ✅ LOG_POINT_V004_ANTHROPIC_MODEL_SUCCESS`, {
-                            logPoint: "V004_ANTHROPIC_MODEL_SUCCESS",
-                            modelCreationId,
-                            timestamp: new Date().toISOString(),
-                            elapsedMs: Date.now() - modelCreationStartTime,
-                            elapsedNs: (process.hrtime.bigint() - modelCreationHrTimeStart).toString(),
-                            anthropicModelDurationNs: anthropicModelDurationNs.toString(),
-                            anthropicModelDurationMs: Number(anthropicModelDurationNs) / 1000000,
-                            modelName,
-                            hasAnthropicModel: !!anthropicModel,
-                            anthropicModelType: typeof anthropicModel,
-                            memoryUsageAfterAnthropicCreation: process.memoryUsage(),
-                            message: "Anthropic model created successfully via vertexAnthropic",
-                        });
-                        return anthropicModel;
-                    }
-                    // Anthropic model creation returned null
-                    const anthropicModelNullTime = process.hrtime.bigint();
-                    const anthropicModelDurationNs = anthropicModelNullTime - anthropicModelStartTime;
-                    logger.warn(`[GoogleVertexProvider] ⚠️ LOG_POINT_V005_ANTHROPIC_MODEL_NULL`, {
-                        logPoint: "V005_ANTHROPIC_MODEL_NULL",
-                        modelCreationId,
-                        timestamp: new Date().toISOString(),
-                        elapsedMs: Date.now() - modelCreationStartTime,
-                        elapsedNs: (process.hrtime.bigint() - modelCreationHrTimeStart).toString(),
-                        anthropicModelDurationNs: anthropicModelDurationNs.toString(),
-                        anthropicModelDurationMs: Number(anthropicModelDurationNs) / 1000000,
-                        modelName,
-                        hasAnthropicModel: false,
-                        fallbackToGoogle: true,
-                        message: "Anthropic model creation returned null - falling back to Google model",
-                    });
-                }
-                catch (error) {
-                    const anthropicModelErrorTime = process.hrtime.bigint();
-                    const anthropicModelDurationNs = anthropicModelErrorTime - anthropicModelStartTime;
-                    logger.error(`[GoogleVertexProvider] ❌ LOG_POINT_V006_ANTHROPIC_MODEL_ERROR`, {
-                        logPoint: "V006_ANTHROPIC_MODEL_ERROR",
-                        modelCreationId,
-                        timestamp: new Date().toISOString(),
-                        elapsedMs: Date.now() - modelCreationStartTime,
-                        elapsedNs: (process.hrtime.bigint() - modelCreationHrTimeStart).toString(),
-                        anthropicModelDurationNs: anthropicModelDurationNs.toString(),
-                        anthropicModelDurationMs: Number(anthropicModelDurationNs) / 1000000,
-                        modelName,
-                        error: error instanceof Error ? error.message : String(error),
-                        errorName: error instanceof Error ? error.name : "UnknownError",
-                        errorStack: error instanceof Error ? error.stack : undefined,
-                        fallbackToGoogle: true,
-                        message: "Anthropic model creation failed - falling back to Google model",
-                    });
-                }
-            }
-            // Fall back to regular model if Anthropic not available
-            logger.warn(`Anthropic model ${modelName} requested but not available, falling back to Google model`);
         }
-        // 🚀 EXHAUSTIVE LOGGING POINT V007: GOOGLE VERTEX MODEL CREATION START
+        // Fall back to regular model if Anthropic not available
+        logger.warn(`Anthropic model ${modelName} requested but not available, falling back to Google model`);
+        return null;
+    }
+    /**
+     * Create Google Vertex model with comprehensive logging and error handling
+     */
+    async createGoogleVertexModel(modelName, modelCreationId, modelCreationStartTime, modelCreationHrTimeStart, isAnthropic) {
         const googleModelStartTime = process.hrtime.bigint();
         logger.debug(`[GoogleVertexProvider] 🌐 LOG_POINT_V007_GOOGLE_MODEL_START`, {
             logPoint: "V007_GOOGLE_MODEL_START",
@@ -425,13 +435,11 @@ export class GoogleVertexProvider extends BaseProvider {
             reason: isAnthropic ? "ANTHROPIC_FALLBACK" : "DIRECT_GOOGLE_MODEL",
             message: "Creating fresh Google Vertex model with current settings",
         });
-        // Create fresh Google Vertex model with current settings
         logger.debug("Creating Google Vertex model", {
             modelName,
             project: this.projectId,
             location: this.location,
         });
-        // 🚀 EXHAUSTIVE LOGGING POINT V008: VERTEX SETTINGS CREATION
         const vertexSettingsStartTime = process.hrtime.bigint();
         logger.debug(`[GoogleVertexProvider] ⚙️ LOG_POINT_V008_VERTEX_SETTINGS_START`, {
             logPoint: "V008_VERTEX_SETTINGS_START",
@@ -482,122 +490,7 @@ export class GoogleVertexProvider extends BaseProvider {
                 },
                 message: "Vertex settings created successfully",
             });
-            // 🚀 EXHAUSTIVE LOGGING POINT V010: VERTEX INSTANCE CREATION
-            const vertexInstanceStartTime = process.hrtime.bigint();
-            logger.debug(`[GoogleVertexProvider] 🏗️ LOG_POINT_V010_VERTEX_INSTANCE_START`, {
-                logPoint: "V010_VERTEX_INSTANCE_START",
-                modelCreationId,
-                timestamp: new Date().toISOString(),
-                elapsedMs: Date.now() - modelCreationStartTime,
-                elapsedNs: (process.hrtime.bigint() - modelCreationHrTimeStart).toString(),
-                vertexInstanceStartTimeNs: vertexInstanceStartTime.toString(),
-                // Pre-creation network environment
-                networkEnvironment: {
-                    dnsServers: (() => {
-                        try {
-                            return dns.getServers ? dns.getServers() : "NOT_AVAILABLE";
-                        }
-                        catch {
-                            return "NOT_AVAILABLE";
-                        }
-                    })(),
-                    networkInterfaces: (() => {
-                        try {
-                            return Object.keys(os.networkInterfaces());
-                        }
-                        catch {
-                            return [];
-                        }
-                    })(),
-                    hostname: (() => {
-                        try {
-                            return os.hostname();
-                        }
-                        catch {
-                            return "UNKNOWN";
-                        }
-                    })(),
-                    platform: (() => {
-                        try {
-                            return os.platform();
-                        }
-                        catch {
-                            return "UNKNOWN";
-                        }
-                    })(),
-                    release: (() => {
-                        try {
-                            return os.release();
-                        }
-                        catch {
-                            return "UNKNOWN";
-                        }
-                    })(),
-                },
-                message: "Creating Vertex AI instance",
-            });
-            const vertex = createVertex(vertexSettings);
-            const vertexInstanceEndTime = process.hrtime.bigint();
-            const vertexInstanceDurationNs = vertexInstanceEndTime - vertexInstanceStartTime;
-            logger.debug(`[GoogleVertexProvider] ✅ LOG_POINT_V011_VERTEX_INSTANCE_SUCCESS`, {
-                logPoint: "V011_VERTEX_INSTANCE_SUCCESS",
-                modelCreationId,
-                timestamp: new Date().toISOString(),
-                elapsedMs: Date.now() - modelCreationStartTime,
-                elapsedNs: (process.hrtime.bigint() - modelCreationHrTimeStart).toString(),
-                vertexInstanceDurationNs: vertexInstanceDurationNs.toString(),
-                vertexInstanceDurationMs: Number(vertexInstanceDurationNs) / 1000000,
-                hasVertexInstance: !!vertex,
-                vertexInstanceType: typeof vertex,
-                message: "Vertex AI instance created successfully",
-            });
-            // 🚀 EXHAUSTIVE LOGGING POINT V012: MODEL INSTANCE CREATION
-            const modelInstanceStartTime = process.hrtime.bigint();
-            logger.debug(`[GoogleVertexProvider] 🎯 LOG_POINT_V012_MODEL_INSTANCE_START`, {
-                logPoint: "V012_MODEL_INSTANCE_START",
-                modelCreationId,
-                timestamp: new Date().toISOString(),
-                elapsedMs: Date.now() - modelCreationStartTime,
-                elapsedNs: (process.hrtime.bigint() - modelCreationHrTimeStart).toString(),
-                modelInstanceStartTimeNs: modelInstanceStartTime.toString(),
-                modelName,
-                hasVertexInstance: !!vertex,
-                message: "Creating model instance from Vertex AI instance",
-            });
-            const model = vertex(modelName);
-            const modelInstanceEndTime = process.hrtime.bigint();
-            const modelInstanceDurationNs = modelInstanceEndTime - modelInstanceStartTime;
-            const totalModelCreationDurationNs = modelInstanceEndTime - modelCreationHrTimeStart;
-            logger.info(`[GoogleVertexProvider] 🏁 LOG_POINT_V013_MODEL_CREATION_COMPLETE`, {
-                logPoint: "V013_MODEL_CREATION_COMPLETE",
-                modelCreationId,
-                timestamp: new Date().toISOString(),
-                totalElapsedMs: Date.now() - modelCreationStartTime,
-                totalElapsedNs: totalModelCreationDurationNs.toString(),
-                totalDurationMs: Number(totalModelCreationDurationNs) / 1000000,
-                modelInstanceDurationNs: modelInstanceDurationNs.toString(),
-                modelInstanceDurationMs: Number(modelInstanceDurationNs) / 1000000,
-                // Final model analysis
-                finalModel: {
-                    hasModel: !!model,
-                    modelType: typeof model,
-                    modelName,
-                    isAnthropicModel: isAnthropic,
-                    projectId: this.projectId,
-                    location: this.location,
-                },
-                // Performance summary
-                performanceSummary: {
-                    vertexSettingsDurationMs: Number(vertexSettingsDurationNs) / 1000000,
-                    vertexInstanceDurationMs: Number(vertexInstanceDurationNs) / 1000000,
-                    modelInstanceDurationMs: Number(modelInstanceDurationNs) / 1000000,
-                    totalDurationMs: Number(totalModelCreationDurationNs) / 1000000,
-                },
-                // Memory usage
-                finalMemoryUsage: process.memoryUsage(),
-                message: "Model creation completed successfully - ready for API calls",
-            });
-            return model;
+            return await this.createVertexInstance(vertexSettings, modelName, modelCreationId, modelCreationStartTime, modelCreationHrTimeStart);
         }
         catch (error) {
             const vertexSettingsErrorTime = process.hrtime.bigint();
@@ -654,14 +547,146 @@ export class GoogleVertexProvider extends BaseProvider {
             throw error;
         }
     }
+    /**
+     * Create Vertex AI instance and model with comprehensive logging
+     */
+    async createVertexInstance(vertexSettings, modelName, modelCreationId, modelCreationStartTime, modelCreationHrTimeStart) {
+        const vertexInstanceStartTime = process.hrtime.bigint();
+        logger.debug(`[GoogleVertexProvider] 🏗️ LOG_POINT_V010_VERTEX_INSTANCE_START`, {
+            logPoint: "V010_VERTEX_INSTANCE_START",
+            modelCreationId,
+            timestamp: new Date().toISOString(),
+            elapsedMs: Date.now() - modelCreationStartTime,
+            elapsedNs: (process.hrtime.bigint() - modelCreationHrTimeStart).toString(),
+            vertexInstanceStartTimeNs: vertexInstanceStartTime.toString(),
+            // Pre-creation network environment
+            networkEnvironment: {
+                dnsServers: (() => {
+                    try {
+                        return dns.getServers ? dns.getServers() : "NOT_AVAILABLE";
+                    }
+                    catch {
+                        return "NOT_AVAILABLE";
+                    }
+                })(),
+                networkInterfaces: (() => {
+                    try {
+                        return Object.keys(os.networkInterfaces());
+                    }
+                    catch {
+                        return [];
+                    }
+                })(),
+                hostname: (() => {
+                    try {
+                        return os.hostname();
+                    }
+                    catch {
+                        return "UNKNOWN";
+                    }
+                })(),
+                platform: (() => {
+                    try {
+                        return os.platform();
+                    }
+                    catch {
+                        return "UNKNOWN";
+                    }
+                })(),
+                release: (() => {
+                    try {
+                        return os.release();
+                    }
+                    catch {
+                        return "UNKNOWN";
+                    }
+                })(),
+            },
+            message: "Creating Vertex AI instance",
+        });
+        const vertex = createVertex(vertexSettings);
+        const vertexInstanceEndTime = process.hrtime.bigint();
+        const vertexInstanceDurationNs = vertexInstanceEndTime - vertexInstanceStartTime;
+        logger.debug(`[GoogleVertexProvider] ✅ LOG_POINT_V011_VERTEX_INSTANCE_SUCCESS`, {
+            logPoint: "V011_VERTEX_INSTANCE_SUCCESS",
+            modelCreationId,
+            timestamp: new Date().toISOString(),
+            elapsedMs: Date.now() - modelCreationStartTime,
+            elapsedNs: (process.hrtime.bigint() - modelCreationHrTimeStart).toString(),
+            vertexInstanceDurationNs: vertexInstanceDurationNs.toString(),
+            vertexInstanceDurationMs: Number(vertexInstanceDurationNs) / 1000000,
+            hasVertexInstance: !!vertex,
+            vertexInstanceType: typeof vertex,
+            message: "Vertex AI instance created successfully",
+        });
+        const modelInstanceStartTime = process.hrtime.bigint();
+        logger.debug(`[GoogleVertexProvider] 🎯 LOG_POINT_V012_MODEL_INSTANCE_START`, {
+            logPoint: "V012_MODEL_INSTANCE_START",
+            modelCreationId,
+            timestamp: new Date().toISOString(),
+            elapsedMs: Date.now() - modelCreationStartTime,
+            elapsedNs: (process.hrtime.bigint() - modelCreationHrTimeStart).toString(),
+            modelInstanceStartTimeNs: modelInstanceStartTime.toString(),
+            modelName,
+            hasVertexInstance: !!vertex,
+            message: "Creating model instance from Vertex AI instance",
+        });
+        const model = vertex(modelName);
+        const modelInstanceEndTime = process.hrtime.bigint();
+        const modelInstanceDurationNs = modelInstanceEndTime - modelInstanceStartTime;
+        const totalModelCreationDurationNs = modelInstanceEndTime - modelCreationHrTimeStart;
+        logger.info(`[GoogleVertexProvider] 🏁 LOG_POINT_V013_MODEL_CREATION_COMPLETE`, {
+            logPoint: "V013_MODEL_CREATION_COMPLETE",
+            modelCreationId,
+            timestamp: new Date().toISOString(),
+            totalElapsedMs: Date.now() - modelCreationStartTime,
+            totalElapsedNs: totalModelCreationDurationNs.toString(),
+            totalDurationMs: Number(totalModelCreationDurationNs) / 1000000,
+            modelInstanceDurationNs: modelInstanceDurationNs.toString(),
+            modelInstanceDurationMs: Number(modelInstanceDurationNs) / 1000000,
+            // Final model analysis
+            finalModel: {
+                hasModel: !!model,
+                modelType: typeof model,
+                modelName,
+                isAnthropicModel: isAnthropicModel(modelName),
+                projectId: this.projectId,
+                location: this.location,
+            },
+            // Performance summary
+            performanceSummary: {
+                vertexSettingsDurationMs: Number(vertexInstanceDurationNs) / 1000000,
+                vertexInstanceDurationMs: Number(vertexInstanceDurationNs) / 1000000,
+                modelInstanceDurationMs: Number(modelInstanceDurationNs) / 1000000,
+                totalDurationMs: Number(totalModelCreationDurationNs) / 1000000,
+            },
+            // Memory usage
+            finalMemoryUsage: process.memoryUsage(),
+            message: "Model creation completed successfully - ready for API calls",
+        });
+        return model;
+    }
+    /**
+     * Gets the appropriate model instance (Google or Anthropic)
+     * Uses dual provider architecture for proper model routing
+     * Creates fresh instances for each request to ensure proper authentication
+     */
+    async getModel() {
+        // Initialize logging and setup
+        const { modelCreationId, modelCreationStartTime, modelCreationHrTimeStart, modelName, } = this.initializeModelCreationLogging();
+        // Check if this is an Anthropic model and attempt creation
+        const anthropicModel = await this.attemptAnthropicModelCreation(modelName, modelCreationId, modelCreationStartTime, modelCreationHrTimeStart);
+        if (anthropicModel) {
+            return anthropicModel;
+        }
+        // Fall back to Google Vertex model creation
+        return await this.createGoogleVertexModel(modelName, modelCreationId, modelCreationStartTime, modelCreationHrTimeStart, isAnthropicModel(modelName));
+    }
     // executeGenerate removed - BaseProvider handles all generation with tools
-    async executeStream(options, analysisSchema) {
-        // 🚀 EXHAUSTIVE LOGGING POINT S001: STREAM EXECUTION ENTRY
-        const streamExecutionId = `vertex-stream-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-        const streamExecutionStartTime = Date.now();
-        const streamExecutionHrTimeStart = process.hrtime.bigint();
-        const functionTag = "GoogleVertexProvider.executeStream";
-        let chunkCount = 0;
+    /**
+     * Log stream execution start with comprehensive analysis
+     */
+    logStreamExecutionStart(streamExecutionId, streamExecutionStartTime, streamExecutionHrTimeStart, functionTag, options, analysisSchema) {
         logger.info(`[GoogleVertexProvider] 🎬 LOG_POINT_S001_STREAM_EXECUTION_START`, {
             logPoint: "S001_STREAM_EXECUTION_START",
             streamExecutionId,
@@ -708,9 +733,11 @@ export class GoogleVertexProvider extends BaseProvider {
             cpuUsage: process.cpuUsage(),
             message: "Stream execution starting with comprehensive analysis",
         });
-        // 🚀 EXHAUSTIVE LOGGING POINT S002: TIMEOUT CONTROLLER SETUP
-        const timeoutSetupStartTime = process.hrtime.bigint();
-        const timeout = this.getTimeout(options);
+    }
+    /**
+     * Log timeout setup process
+     */
+    logTimeoutSetup(streamExecutionId, streamExecutionStartTime, streamExecutionHrTimeStart, timeoutSetupStartTime, timeout) {
         logger.debug(`[GoogleVertexProvider] ⏰ LOG_POINT_S002_TIMEOUT_SETUP`, {
             logPoint: "S002_TIMEOUT_SETUP",
             streamExecutionId,
@@ -723,8 +750,11 @@ export class GoogleVertexProvider extends BaseProvider {
             streamType: "stream",
             message: "Setting up timeout controller for stream execution",
         });
-        // Add timeout controller for consistency with other providers
-        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
+    }
+    /**
+     * Log successful timeout setup
+     */
+    logTimeoutSetupSuccess(streamExecutionId, streamExecutionStartTime, streamExecutionHrTimeStart, timeoutSetupStartTime, timeoutController, timeout) {
         const timeoutSetupEndTime = process.hrtime.bigint();
         const timeoutSetupDurationNs = timeoutSetupEndTime - timeoutSetupStartTime;
         logger.debug(`[GoogleVertexProvider] ✅ LOG_POINT_S003_TIMEOUT_SETUP_SUCCESS`, {
@@ -739,83 +769,109 @@ export class GoogleVertexProvider extends BaseProvider {
             timeoutValue: timeout,
             message: "Timeout controller setup completed",
         });
+    }
+    /**
+     * Log and perform stream options validation
+     */
+    logAndValidateStreamOptions(streamExecutionId, streamExecutionStartTime, streamExecutionHrTimeStart, options) {
+        const validationStartTime = process.hrtime.bigint();
+        logger.debug(`[GoogleVertexProvider] ✔️ LOG_POINT_S004_VALIDATION_START`, {
+            logPoint: "S004_VALIDATION_START",
+            streamExecutionId,
+            timestamp: new Date().toISOString(),
+            elapsedMs: Date.now() - streamExecutionStartTime,
+            elapsedNs: (process.hrtime.bigint() - streamExecutionHrTimeStart).toString(),
+            validationStartTimeNs: validationStartTime.toString(),
+            message: "Starting stream options validation",
+        });
+        this.validateStreamOptions(options);
+        const validationEndTime = process.hrtime.bigint();
+        const validationDurationNs = validationEndTime - validationStartTime;
+        logger.debug(`[GoogleVertexProvider] ✅ LOG_POINT_S005_VALIDATION_SUCCESS`, {
+            logPoint: "S005_VALIDATION_SUCCESS",
+            streamExecutionId,
+            timestamp: new Date().toISOString(),
+            elapsedMs: Date.now() - streamExecutionStartTime,
+            elapsedNs: (process.hrtime.bigint() - streamExecutionHrTimeStart).toString(),
+            validationDurationNs: validationDurationNs.toString(),
+            validationDurationMs: Number(validationDurationNs) / 1000000,
+            message: "Stream options validation successful",
+        });
+    }
+    /**
+     * Log start of message building process
+     */
+    logMessageBuildStart(streamExecutionId, streamExecutionStartTime, streamExecutionHrTimeStart) {
+        const messagesBuildStartTime = process.hrtime.bigint();
+        logger.debug(`[GoogleVertexProvider] 📝 LOG_POINT_S006_MESSAGES_BUILD_START`, {
+            logPoint: "S006_MESSAGES_BUILD_START",
+            streamExecutionId,
+            timestamp: new Date().toISOString(),
+            elapsedMs: Date.now() - streamExecutionStartTime,
+            elapsedNs: (process.hrtime.bigint() - streamExecutionHrTimeStart).toString(),
+            messagesBuildStartTimeNs: messagesBuildStartTime.toString(),
+            message: "Starting message array building",
+        });
+        return messagesBuildStartTime;
+    }
+    /**
+     * Log successful message building
+     */
+    logMessageBuildSuccess(streamExecutionId, streamExecutionStartTime, streamExecutionHrTimeStart, messagesBuildStartTime, messages) {
+        const messagesBuildEndTime = process.hrtime.bigint();
+        const messagesBuildDurationNs = messagesBuildEndTime - messagesBuildStartTime;
+        logger.debug(`[GoogleVertexProvider] ✅ LOG_POINT_S007_MESSAGES_BUILD_SUCCESS`, {
+            logPoint: "S007_MESSAGES_BUILD_SUCCESS",
+            streamExecutionId,
+            timestamp: new Date().toISOString(),
+            elapsedMs: Date.now() - streamExecutionStartTime,
+            elapsedNs: (process.hrtime.bigint() - streamExecutionHrTimeStart).toString(),
+            messagesBuildDurationNs: messagesBuildDurationNs.toString(),
+            messagesBuildDurationMs: Number(messagesBuildDurationNs) / 1000000,
+            messagesCount: Array.isArray(messages) ? messages.length : 0,
+            messagesType: typeof messages,
+            hasMessages: !!messages,
+            message: "Message array built successfully",
+        });
+    }
+    async executeStream(options, analysisSchema) {
+        // Initialize stream execution tracking
+        const streamExecutionId = `vertex-stream-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+        const streamExecutionStartTime = Date.now();
+        const streamExecutionHrTimeStart = process.hrtime.bigint();
+        const functionTag = "GoogleVertexProvider.executeStream";
+        let chunkCount = 0;
+        // Log stream execution start
+        this.logStreamExecutionStart(streamExecutionId, streamExecutionStartTime, streamExecutionHrTimeStart, functionTag, options, analysisSchema);
+        // Setup timeout controller
+        const timeoutSetupStartTime = process.hrtime.bigint();
+        const timeout = this.getTimeout(options);
+        this.logTimeoutSetup(streamExecutionId, streamExecutionStartTime, streamExecutionHrTimeStart, timeoutSetupStartTime, timeout);
+        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
+        this.logTimeoutSetupSuccess(streamExecutionId, streamExecutionStartTime, streamExecutionHrTimeStart, timeoutSetupStartTime, timeoutController, timeout);
         try {
-            // 🚀 EXHAUSTIVE LOGGING POINT S004: STREAM OPTIONS VALIDATION
-            const validationStartTime = process.hrtime.bigint();
-            logger.debug(`[GoogleVertexProvider] ✔️ LOG_POINT_S004_VALIDATION_START`, {
-                logPoint: "S004_VALIDATION_START",
-                streamExecutionId,
-                timestamp: new Date().toISOString(),
-                elapsedMs: Date.now() - streamExecutionStartTime,
-                elapsedNs: (process.hrtime.bigint() - streamExecutionHrTimeStart).toString(),
-                validationStartTimeNs: validationStartTime.toString(),
-                message: "Starting stream options validation",
-            });
-            this.validateStreamOptions(options);
-            const validationEndTime = process.hrtime.bigint();
-            const validationDurationNs = validationEndTime - validationStartTime;
-            logger.debug(`[GoogleVertexProvider] ✅ LOG_POINT_S005_VALIDATION_SUCCESS`, {
-                logPoint: "S005_VALIDATION_SUCCESS",
-                streamExecutionId,
-                timestamp: new Date().toISOString(),
-                elapsedMs: Date.now() - streamExecutionStartTime,
-                elapsedNs: (process.hrtime.bigint() - streamExecutionHrTimeStart).toString(),
-                validationDurationNs: validationDurationNs.toString(),
-                validationDurationMs: Number(validationDurationNs) / 1000000,
-                message: "Stream options validation successful",
-            });
-            // 🚀 EXHAUSTIVE LOGGING POINT S006: MESSAGE ARRAY BUILDING
-            const messagesBuildStartTime = process.hrtime.bigint();
-            logger.debug(`[GoogleVertexProvider] 📝 LOG_POINT_S006_MESSAGES_BUILD_START`, {
-                logPoint: "S006_MESSAGES_BUILD_START",
-                streamExecutionId,
-                timestamp: new Date().toISOString(),
-                elapsedMs: Date.now() - streamExecutionStartTime,
-                elapsedNs: (process.hrtime.bigint() - streamExecutionHrTimeStart).toString(),
-                messagesBuildStartTimeNs: messagesBuildStartTime.toString(),
-                message: "Building message array from stream options",
-            });
+            // Validate stream options with logging
+            this.logAndValidateStreamOptions(streamExecutionId, streamExecutionStartTime, streamExecutionHrTimeStart, options);
+            // Build messages with logging
+            const messagesBuildStartTime = this.logMessageBuildStart(streamExecutionId, streamExecutionStartTime, streamExecutionHrTimeStart);
             // Build message array from options
             const messages = buildMessagesArray(options);
-            const messagesBuildEndTime = process.hrtime.bigint();
-            const messagesBuildDurationNs = messagesBuildEndTime - messagesBuildStartTime;
-            logger.debug(`[GoogleVertexProvider] ✅ LOG_POINT_S007_MESSAGES_BUILD_SUCCESS`, {
-                logPoint: "S007_MESSAGES_BUILD_SUCCESS",
-                streamExecutionId,
-                timestamp: new Date().toISOString(),
-                elapsedMs: Date.now() - streamExecutionStartTime,
-                elapsedNs: (process.hrtime.bigint() - streamExecutionHrTimeStart).toString(),
-                messagesBuildDurationNs: messagesBuildDurationNs.toString(),
-                messagesBuildDurationMs: Number(messagesBuildDurationNs) / 1000000,
-                messagesCount: messages?.length || 0,
-                messagesType: typeof messages,
-                hasMessages: !!messages,
-                message: "Message array built successfully",
-            });
-            // 🚀 EXHAUSTIVE LOGGING POINT S008: INITIAL STREAM REQUEST LOG
+            this.logMessageBuildSuccess(streamExecutionId, streamExecutionStartTime, streamExecutionHrTimeStart, messagesBuildStartTime, messages);
+            // Log stream request details
             logger.debug(`[GoogleVertexProvider] 🚀 LOG_POINT_S008_STREAM_REQUEST_DETAILS`, {
                 logPoint: "S008_STREAM_REQUEST_DETAILS",
                 streamExecutionId,
-                timestamp: new Date().toISOString(),
-                elapsedMs: Date.now() - streamExecutionStartTime,
-                elapsedNs: (process.hrtime.bigint() - streamExecutionHrTimeStart).toString(),
-                // Detailed request information
                 streamRequestDetails: {
                     modelName: this.modelName,
                     promptLength: options.input.text.length,
                     hasSchema: !!analysisSchema,
-                    messagesCount: messages?.length || 0,
+                    messagesCount: Array.isArray(messages) ? messages.length : 0,
                     temperature: options?.temperature,
                     maxTokens: options?.maxTokens,
                     disableTools: options?.disableTools || false,
                 },
                 message: "Starting comprehensive stream request processing",
             });
-            logger.debug(`${functionTag}: Starting stream request`, {
-                modelName: this.modelName,
-                promptLength: options.input.text.length,
-                hasSchema: !!analysisSchema,
-            });
             // 🚀 EXHAUSTIVE LOGGING POINT S009: MODEL CREATION FOR STREAM
             const modelCreationStartTime = process.hrtime.bigint();
             logger.debug(`[GoogleVertexProvider] 🏭 LOG_POINT_S009_MODEL_CREATION_FOR_STREAM`, {