@juspay/neurolink 7.37.0 → 7.38.0

package/dist/providers/amazonBedrock.js

@@ -2,7 +2,7 @@ import { BedrockRuntimeClient, ConverseCommand, ConverseStreamCommand, } from "@
 import { BedrockClient, ListFoundationModelsCommand, } from "@aws-sdk/client-bedrock";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
-import { zodToJsonSchema } from "zod-to-json-schema";
+import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
 export class AmazonBedrockProvider extends BaseProvider {
     bedrockClient;
     conversationHistory = [];
@@ -481,7 +481,7 @@ export class AmazonBedrockProvider extends BaseProvider {
                 // Check if it's a Zod schema
                 if ("_def" in tool.parameters) {
                     // It's a Zod schema, convert to JSON schema
-                    schema = zodToJsonSchema(tool.parameters);
+                    schema = convertZodToJsonSchema(tool.parameters);
                 }
                 else {
                     // It's already a plain object schema

package/dist/providers/anthropic.js

@@ -103,6 +103,14 @@ export class AnthropicProvider extends BaseProvider {
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",
                 abortSignal: timeoutController?.controller.signal,
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[AnthropicProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             });
             timeoutController?.cleanup();
             const transformedStream = this.createTextStream(result);

package/dist/providers/anthropicBaseProvider.js

@@ -73,6 +73,14 @@ export class AnthropicProviderV2 extends BaseProvider {
                 tools: options.tools,
                 toolChoice: "auto",
                 abortSignal: timeoutController?.controller.signal,
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[AnthropicBaseProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             });
             timeoutController?.cleanup();
             // Transform string stream to content object stream (match Google AI pattern)

package/dist/providers/azureOpenai.js

@@ -122,6 +122,14 @@ export class AzureOpenAIProvider extends BaseProvider {
                     : {}),
                 tools,
                 toolChoice: shouldUseTools ? "auto" : "none",
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[AzureOpenaiProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
             });
             // Transform string stream to content object stream using BaseProvider method

package/dist/providers/googleAiStudio.js

@@ -101,6 +101,14 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",
                 abortSignal: timeoutController?.controller.signal,
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[GoogleAiStudioProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             });
             timeoutController?.cleanup();
             // Transform string stream to content object stream using BaseProvider method

package/dist/providers/googleVertex.d.ts

@@ -34,7 +34,7 @@ export declare class GoogleVertexProvider extends BaseProvider {
      */
     protected getAISDKModel(): Promise<LanguageModel>;
     /**
-     * Initialize model creation logging and tracking
+     * Initialize model creation tracking
      */
     private initializeModelCreationLogging;
     /**
@@ -56,29 +56,9 @@ export declare class GoogleVertexProvider extends BaseProvider {
      */
     private getModel;
     /**
-     * Log stream execution start with comprehensive analysis
+     * Validate stream options
      */
-    private logStreamExecutionStart;
-    /**
-     * Log timeout setup process
-     */
-    private logTimeoutSetup;
-    /**
-     * Log successful timeout setup
-     */
-    private logTimeoutSetupSuccess;
-    /**
-     * Log and perform stream options validation
-     */
-    private logAndValidateStreamOptions;
-    /**
-     * Log start of message building process
-     */
-    private logMessageBuildStart;
-    /**
-     * Log successful message building
-     */
-    private logMessageBuildSuccess;
+    private validateStreamOptionsOnly;
     protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
     protected handleProviderError(error: unknown): Error;
     /**

package/dist/providers/googleVertex.js

@@ -272,41 +272,13 @@ export class GoogleVertexProvider extends BaseProvider {
         return model;
     }
     /**
-     * Initialize model creation logging and tracking
+     * Initialize model creation tracking
      */
     initializeModelCreationLogging() {
         const modelCreationId = `vertex-model-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
         const modelCreationStartTime = Date.now();
         const modelCreationHrTimeStart = process.hrtime.bigint();
         const modelName = this.modelName || getDefaultVertexModel();
-        logger.debug(`[GoogleVertexProvider] 🏭 LOG_POINT_V001_MODEL_CREATION_START`, {
-            logPoint: "V001_MODEL_CREATION_START",
-            modelCreationId,
-            timestamp: new Date().toISOString(),
-            modelCreationStartTime,
-            modelCreationHrTimeStart: modelCreationHrTimeStart.toString(),
-            requestedModel: this.modelName,
-            resolvedModel: modelName,
-            defaultModel: getDefaultVertexModel(),
-            projectId: this.projectId,
-            location: this.location,
-            // Environment analysis for network issues
-            environmentAnalysis: {
-                httpProxy: process.env.HTTP_PROXY || process.env.http_proxy || "NOT_SET",
-                httpsProxy: process.env.HTTPS_PROXY || process.env.https_proxy || "NOT_SET",
-                googleAppCreds: process.env.GOOGLE_APPLICATION_CREDENTIALS || "NOT_SET",
-                googleServiceKey: process.env.GOOGLE_SERVICE_ACCOUNT_KEY
-                    ? "SET"
-                    : "NOT_SET",
-                nodeVersion: process.version,
-                platform: process.platform,
-                arch: process.arch,
-            },
-            // Memory and performance baseline
-            memoryUsage: process.memoryUsage(),
-            cpuUsage: process.cpuUsage(),
-            message: "Starting model creation with comprehensive environment analysis",
-        });
         return {
             modelCreationId,
             modelCreationStartTime,
@@ -318,37 +290,10 @@ export class GoogleVertexProvider extends BaseProvider {
      * 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`, {
-            logPoint: "V002_ANTHROPIC_CHECK",
-            modelCreationId,
-            timestamp: new Date().toISOString(),
-            elapsedMs: Date.now() - modelCreationStartTime,
-            elapsedNs: (process.hrtime.bigint() - modelCreationHrTimeStart).toString(),
-            anthropicCheckStartTimeNs: anthropicCheckStartTime.toString(),
-            modelName,
-            isAnthropicModel: isAnthropic,
-            modelNameLowerCase: modelName.toLowerCase(),
-            containsClaude: modelName.toLowerCase().includes("claude"),
-            anthropicModelPatterns: ["claude"],
-            message: "Checking if model is Anthropic-based",
-        });
         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,
         });
@@ -359,52 +304,17 @@ export class GoogleVertexProvider extends BaseProvider {
         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",
-            });
+            // 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",
@@ -420,21 +330,7 @@ export class GoogleVertexProvider extends BaseProvider {
     /**
      * 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",
-            modelCreationId,
-            timestamp: new Date().toISOString(),
-            elapsedMs: Date.now() - modelCreationStartTime,
-            elapsedNs: (process.hrtime.bigint() - modelCreationHrTimeStart).toString(),
-            googleModelStartTimeNs: googleModelStartTime.toString(),
-            modelName,
-            projectId: this.projectId,
-            location: this.location,
-            reason: isAnthropic ? "ANTHROPIC_FALLBACK" : "DIRECT_GOOGLE_MODEL",
-            message: "Creating fresh Google Vertex model with current settings",
-        });
+    async createGoogleVertexModel(modelName, modelCreationId, modelCreationStartTime, modelCreationHrTimeStart) {
         logger.debug("Creating Google Vertex model", {
             modelName,
             project: this.projectId,
@@ -680,260 +576,31 @@ export class GoogleVertexProvider extends BaseProvider {
             return anthropicModel;
         }
         // Fall back to Google Vertex model creation
-        return await this.createGoogleVertexModel(modelName, modelCreationId, modelCreationStartTime, modelCreationHrTimeStart, isAnthropicModel(modelName));
+        return await this.createGoogleVertexModel(modelName, modelCreationId, modelCreationStartTime, modelCreationHrTimeStart);
     }
     // executeGenerate removed - BaseProvider handles all generation with tools
     /**
-     * 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,
-            timestamp: new Date().toISOString(),
-            streamExecutionStartTime,
-            streamExecutionHrTimeStart: streamExecutionHrTimeStart.toString(),
-            functionTag,
-            // Input analysis
-            inputAnalysis: {
-                hasOptions: !!options,
-                optionsType: typeof options,
-                optionsKeys: options ? Object.keys(options) : [],
-                hasInputText: !!options?.input?.text,
-                inputTextLength: options?.input?.text?.length || 0,
-                inputTextPreview: options?.input?.text?.substring(0, 200) || "NO_TEXT",
-                hasAnalysisSchema: !!analysisSchema,
-                schemaType: analysisSchema ? typeof analysisSchema : "NO_SCHEMA",
-                disableTools: options?.disableTools || false,
-                temperature: options?.temperature,
-                maxTokens: options?.maxTokens,
-            },
-            // Provider context
-            providerContext: {
-                modelName: this.modelName,
-                providerName: this.providerName,
-                projectId: this.projectId,
-                location: this.location,
-                defaultTimeout: this.defaultTimeout,
-            },
-            // Network environment
-            networkEnvironment: {
-                httpProxy: process.env.HTTP_PROXY || process.env.http_proxy || "NOT_SET",
-                httpsProxy: process.env.HTTPS_PROXY || process.env.https_proxy || "NOT_SET",
-                googleAppCreds: process.env.GOOGLE_APPLICATION_CREDENTIALS || "NOT_SET",
-                hasGoogleServiceKey: !!process.env.GOOGLE_SERVICE_ACCOUNT_KEY,
-                expectedEndpoint: `https://${this.location}-aiplatform.googleapis.com`,
-                proxyConfigured: !!(process.env.HTTP_PROXY ||
-                    process.env.HTTPS_PROXY ||
-                    process.env.http_proxy ||
-                    process.env.https_proxy),
-            },
-            // Performance baseline
-            memoryUsage: process.memoryUsage(),
-            cpuUsage: process.cpuUsage(),
-            message: "Stream execution starting with comprehensive analysis",
-        });
-    }
-    /**
-     * Log timeout setup process
-     */
-    logTimeoutSetup(streamExecutionId, streamExecutionStartTime, streamExecutionHrTimeStart, timeoutSetupStartTime, timeout) {
-        logger.debug(`[GoogleVertexProvider] ⏰ LOG_POINT_S002_TIMEOUT_SETUP`, {
-            logPoint: "S002_TIMEOUT_SETUP",
-            streamExecutionId,
-            timestamp: new Date().toISOString(),
-            elapsedMs: Date.now() - streamExecutionStartTime,
-            elapsedNs: (process.hrtime.bigint() - streamExecutionHrTimeStart).toString(),
-            timeoutSetupStartTimeNs: timeoutSetupStartTime.toString(),
-            timeout,
-            providerName: this.providerName,
-            streamType: "stream",
-            message: "Setting up timeout controller for stream execution",
-        });
-    }
-    /**
-     * 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`, {
-            logPoint: "S003_TIMEOUT_SETUP_SUCCESS",
-            streamExecutionId,
-            timestamp: new Date().toISOString(),
-            elapsedMs: Date.now() - streamExecutionStartTime,
-            elapsedNs: (process.hrtime.bigint() - streamExecutionHrTimeStart).toString(),
-            timeoutSetupDurationNs: timeoutSetupDurationNs.toString(),
-            timeoutSetupDurationMs: Number(timeoutSetupDurationNs) / 1000000,
-            hasTimeoutController: !!timeoutController,
-            timeoutValue: timeout,
-            message: "Timeout controller setup completed",
-        });
-    }
-    /**
-     * Log and perform stream options validation
+     * Validate stream options
      */
-    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",
-        });
+    validateStreamOptionsOnly(options) {
         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",
-        });
     }
-    /* eslint-disable-next-line max-lines-per-function */
     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 {
-            // Validate stream options with logging
-            this.logAndValidateStreamOptions(streamExecutionId, streamExecutionStartTime, streamExecutionHrTimeStart, options);
-            // Build messages with logging
-            const messagesBuildStartTime = this.logMessageBuildStart(streamExecutionId, streamExecutionStartTime, streamExecutionHrTimeStart);
+            // Validate stream options
+            this.validateStreamOptionsOnly(options);
             // Build message array from options
             const messages = buildMessagesArray(options);
-            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,
-                streamRequestDetails: {
-                    modelName: this.modelName,
-                    promptLength: typeof options.input?.text === "string"
-                        ? options.input.text.length
-                        : 0,
-                    hasSchema: !!analysisSchema,
-                    messagesCount: Array.isArray(messages) ? messages.length : 0,
-                    temperature: options?.temperature,
-                    maxTokens: options?.maxTokens,
-                    disableTools: options?.disableTools || false,
-                },
-                message: "Starting comprehensive stream request processing",
-            });
-            // 🚀 EXHAUSTIVE LOGGING POINT S009: MODEL CREATION FOR STREAM
-            const modelCreationStartTime = process.hrtime.bigint();
-            logger.debug(`[GoogleVertexProvider] 🏭 LOG_POINT_S009_MODEL_CREATION_FOR_STREAM`, {
-                logPoint: "S009_MODEL_CREATION_FOR_STREAM",
-                streamExecutionId,
-                timestamp: new Date().toISOString(),
-                elapsedMs: Date.now() - streamExecutionStartTime,
-                elapsedNs: (process.hrtime.bigint() - streamExecutionHrTimeStart).toString(),
-                modelCreationStartTimeNs: modelCreationStartTime.toString(),
-                requestedModel: this.modelName,
-                message: "Starting model creation for stream execution (this will include network setup)",
-            });
             const model = await this.getModel(); // This is where network connection happens!
-            const modelCreationEndTime = process.hrtime.bigint();
-            const modelCreationDurationNs = modelCreationEndTime - modelCreationStartTime;
-            logger.info(`[GoogleVertexProvider] ✅ LOG_POINT_S010_MODEL_CREATION_SUCCESS`, {
-                logPoint: "S010_MODEL_CREATION_SUCCESS",
-                streamExecutionId,
-                timestamp: new Date().toISOString(),
-                elapsedMs: Date.now() - streamExecutionStartTime,
-                elapsedNs: (process.hrtime.bigint() - streamExecutionHrTimeStart).toString(),
-                modelCreationDurationNs: modelCreationDurationNs.toString(),
-                modelCreationDurationMs: Number(modelCreationDurationNs) / 1000000,
-                hasModel: !!model,
-                modelType: typeof model,
-                message: "Model creation completed successfully - network connection established",
-            });
-            // 🚀 EXHAUSTIVE LOGGING POINT S011: TOOLS SETUP FOR STREAMING
-            const toolsSetupStartTime = process.hrtime.bigint();
-            logger.debug(`[GoogleVertexProvider] 🛠️ LOG_POINT_S011_TOOLS_SETUP_START`, {
-                logPoint: "S011_TOOLS_SETUP_START",
-                streamExecutionId,
-                timestamp: new Date().toISOString(),
-                elapsedMs: Date.now() - streamExecutionStartTime,
-                elapsedNs: (process.hrtime.bigint() - streamExecutionHrTimeStart).toString(),
-                toolsSetupStartTimeNs: toolsSetupStartTime.toString(),
-                disableTools: options?.disableTools || false,
-                supportsTools: this.supportsTools(),
-                message: "Setting up tools for streaming",
-            });
             // Get all available tools (direct + MCP + external) for streaming
             const shouldUseTools = !options.disableTools && this.supportsTools();
             const tools = shouldUseTools ? await this.getAllTools() : {};
-            const toolsSetupEndTime = process.hrtime.bigint();
-            const toolsSetupDurationNs = toolsSetupEndTime - toolsSetupStartTime;
-            logger.debug(`[GoogleVertexProvider] ✅ LOG_POINT_S012_TOOLS_SETUP_SUCCESS`, {
-                logPoint: "S012_TOOLS_SETUP_SUCCESS",
-                streamExecutionId,
-                timestamp: new Date().toISOString(),
-                elapsedMs: Date.now() - streamExecutionStartTime,
-                elapsedNs: (process.hrtime.bigint() - streamExecutionHrTimeStart).toString(),
-                toolsSetupDurationNs: toolsSetupDurationNs.toString(),
-                toolsSetupDurationMs: Number(toolsSetupDurationNs) / 1000000,
-                shouldUseTools,
-                toolCount: Object.keys(tools).length,
-                toolNames: Object.keys(tools),
-                hasTools: Object.keys(tools).length > 0,
-                message: "Tools setup completed for streaming",
-            });
             logger.debug(`${functionTag}: Tools for streaming`, {
                 shouldUseTools,
                 toolCount: Object.keys(tools).length,
@@ -953,7 +620,6 @@ export class GoogleVertexProvider extends BaseProvider {
                 messages: messages,
                 temperature: options.temperature,
                 ...(maxTokens && { maxTokens }),
-                // Add tools support for streaming
                 ...(shouldUseTools &&
                     Object.keys(tools).length > 0 && {
                     tools,
@@ -980,6 +646,16 @@ export class GoogleVertexProvider extends BaseProvider {
                 onChunk: () => {
                     chunkCount++;
                 },
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    logger.info("Tool execution completed", { toolResults, toolCalls });
+                    // Handle tool execution storage
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[GoogleVertexProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             };
             if (analysisSchema) {
                 try {
@@ -1208,8 +884,13 @@ export class GoogleVertexProvider extends BaseProvider {
                 supportedRegions: [
                     "us-central1",
                     "us-east4",
+                    "us-east5",
+                    "us-west1",
+                    "us-west4",
                     "europe-west1",
+                    "europe-west4",
                     "asia-southeast1",
+                    "asia-northeast1",
                 ],
                 solution: "Set GOOGLE_CLOUD_LOCATION to a supported region",
             });
@@ -1425,6 +1106,7 @@ export class GoogleVertexProvider extends BaseProvider {
         const supportedRegions = [
             "us-central1",
             "us-east4",
+            "us-east5",
             "us-west1",
             "us-west4",
             "europe-west1",

package/dist/providers/huggingFace.js

@@ -123,6 +123,14 @@ export class HuggingFaceProvider extends BaseProvider {
                 tools: streamOptions.tools, // Tools format conversion handled by prepareStreamOptions
                 toolChoice: streamOptions.toolChoice, // Tool choice handled by prepareStreamOptions
                 abortSignal: timeoutController?.controller.signal,
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[HuggingFaceProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             });
             timeoutController?.cleanup();
             // Transform stream to match StreamResult interface with enhanced tool call parsing

package/dist/providers/litellm.js

@@ -130,6 +130,14 @@ export class LiteLLMProvider extends BaseProvider {
                 tools: options.tools,
                 toolChoice: "auto",
                 abortSignal: timeoutController?.controller.signal,
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("LiteLLMProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             });
             timeoutController?.cleanup();
             // Transform stream to match StreamResult interface

package/dist/providers/mistral.js

@@ -59,6 +59,14 @@ export class MistralProvider extends BaseProvider {
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",
                 abortSignal: timeoutController?.controller.signal,
+                onStepFinish: ({ toolCalls, toolResults }) => {
+                    this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                        logger.warn("[MistralProvider] Failed to store tool executions", {
+                            provider: this.providerName,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                },
             });
             timeoutController?.cleanup();
             // Transform string stream to content object stream using BaseProvider method