@juspay/neurolink 9.6.0 → 9.8.0

package/dist/lib/providers/googleVertex.js

@@ -7,7 +7,7 @@ import os from "os";
 import path from "path";
 import { ErrorCategory, ErrorSeverity, } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
-import { DEFAULT_MAX_STEPS, DEFAULT_TOOL_MAX_RETRIES, GLOBAL_LOCATION_MODELS, } from "../core/constants.js";
+import { DEFAULT_MAX_STEPS, GLOBAL_LOCATION_MODELS, } from "../core/constants.js";
 import { ModelConfigurationManager } from "../core/modelConfiguration.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { AuthenticationError, ProviderError } from "../types/errors.js";
@@ -17,8 +17,8 @@ import { logger } from "../utils/logger.js";
 import { isGemini3Model } from "../utils/modelDetection.js";
 import { createGoogleAuthConfig, createVertexProjectConfig, validateApiKey, } from "../utils/providerConfig.js";
 import { convertZodToJsonSchema, inlineJsonSchema, } from "../utils/schemaConversion.js";
-import { createNativeThinkingConfig, } from "../utils/thinkingConfig.js";
-import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { buildNativeToolDeclarations, buildNativeConfig, computeMaxSteps as computeMaxStepsShared, collectStreamChunks, extractTextFromParts, executeNativeToolCalls, handleMaxStepsTermination, pushModelResponseToHistory, } from "./googleNativeGemini3.js";
 // Import proper types for multimodal message handling
 // Enhanced Anthropic support with direct imports
 // Using the dual provider architecture from Vercel AI SDK
@@ -744,7 +744,7 @@ export class GoogleVertexProvider extends BaseProvider {
                     toolChoice: "auto",
                     maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 }),
-                abortSignal: timeoutController?.controller.signal,
+                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 // Gemini 3: use thinkingLevel via providerOptions (Vertex AI)
                 // Gemini 2.5: use thinkingBudget via providerOptions
@@ -810,7 +810,8 @@ export class GoogleVertexProvider extends BaseProvider {
                 }
             }
             const result = streamText(streamOptions);
-            timeoutController?.cleanup();
+            // Defer timeout cleanup until the stream completes or errors
+            result.text.finally(() => timeoutController?.cleanup());
             // Transform string stream to content object stream using BaseProvider method
             const transformedStream = this.createTextStream(result);
             // Track tool calls and results for streaming
@@ -948,233 +949,7 @@ export class GoogleVertexProvider extends BaseProvider {
             },
         ];
     }
-    /**
-     * Convert Vercel AI SDK tools to @google/genai FunctionDeclarations and build an execute map.
-     * Shared by both stream and generate native Gemini 3 paths.
-     */
-    convertToolsToNativeFunctionDeclarations(toolsMap, logLabel) {
-        if (Object.keys(toolsMap).length === 0) {
-            return { tools: undefined, executeMap: new Map() };
-        }
-        const functionDeclarations = [];
-        const executeMap = new Map();
-        for (const [name, tool] of Object.entries(toolsMap)) {
-            const decl = {
-                name,
-                description: tool.description || `Tool: ${name}`,
-            };
-            if (tool.parameters) {
-                const rawSchema = convertZodToJsonSchema(tool.parameters);
-                decl.parametersJsonSchema = inlineJsonSchema(rawSchema);
-                if (decl.parametersJsonSchema.$schema) {
-                    delete decl.parametersJsonSchema.$schema;
-                }
-            }
-            functionDeclarations.push(decl);
-            if (tool.execute) {
-                executeMap.set(name, tool.execute);
-            }
-        }
-        logger.debug(`[GoogleVertex] Converted tools for ${logLabel}`, {
-            toolCount: functionDeclarations.length,
-            toolNames: functionDeclarations.map((t) => t.name),
-        });
-        return {
-            tools: [{ functionDeclarations }],
-            executeMap,
-        };
-    }
-    /**
-     * Build the native @google/genai config object for generate/stream calls.
-     * Shared by both stream and generate native Gemini 3 paths.
-     */
-    buildNativeGenerateConfig(options, tools) {
-        const config = {
-            temperature: options.temperature ?? 1.0,
-            maxOutputTokens: options.maxTokens,
-        };
-        if (tools) {
-            config.tools = tools;
-        }
-        if (options.systemPrompt) {
-            config.systemInstruction = options.systemPrompt;
-        }
-        const nativeThinkingConfig = createNativeThinkingConfig(options.thinkingConfig);
-        if (nativeThinkingConfig) {
-            config.thinkingConfig = nativeThinkingConfig;
-        }
-        return config;
-    }
-    /**
-     * Compute a safe maxSteps value from raw input.
-     */
-    computeMaxSteps(rawMaxSteps) {
-        const raw = rawMaxSteps || DEFAULT_MAX_STEPS;
-        return Number.isFinite(raw) && raw > 0
-            ? Math.min(Math.floor(raw), 100)
-            : Math.min(DEFAULT_MAX_STEPS, 100);
-    }
-    /**
-     * Extract text from raw native SDK response parts, filtering out non-text parts
-     * (thoughtSignature, functionCall) to avoid SDK warnings.
-     */
-    extractTextFromRawParts(rawParts) {
-        return rawParts
-            .filter((part) => typeof part.text === "string")
-            .map((part) => part.text)
-            .join("");
-    }
-    /**
-     * Execute a set of function calls from the model, tracking failures and retries.
-     * Returns function response parts to be added to conversation history.
-     * Shared by both stream and generate native Gemini 3 paths.
-     */
-    async executeNativeFunctionCalls(calls, executeMap, failedTools, allToolCalls, toolExecutions) {
-        const functionResponses = [];
-        for (const call of calls) {
-            allToolCalls.push({ toolName: call.name, args: call.args });
-            // Check if this tool has already exceeded retry limit
-            const failedInfo = failedTools.get(call.name);
-            if (failedInfo && failedInfo.count >= DEFAULT_TOOL_MAX_RETRIES) {
-                logger.warn(`[GoogleVertex] Tool "${call.name}" has exceeded retry limit (${DEFAULT_TOOL_MAX_RETRIES}), skipping execution`);
-                const errorOutput = {
-                    error: `TOOL_PERMANENTLY_FAILED: The tool "${call.name}" has failed ${failedInfo.count} times and will not be retried. Last error: ${failedInfo.lastError}. Please proceed without using this tool or inform the user that this functionality is unavailable.`,
-                    status: "permanently_failed",
-                    do_not_retry: true,
-                };
-                toolExecutions?.push({
-                    name: call.name,
-                    input: call.args,
-                    output: errorOutput,
-                });
-                functionResponses.push({
-                    functionResponse: { name: call.name, response: errorOutput },
-                });
-                continue;
-            }
-            const execute = executeMap.get(call.name);
-            if (execute) {
-                try {
-                    const toolOptions = {
-                        toolCallId: `${call.name}-${Date.now()}`,
-                        messages: [],
-                        abortSignal: undefined,
-                    };
-                    const result = await execute(call.args, toolOptions);
-                    toolExecutions?.push({
-                        name: call.name,
-                        input: call.args,
-                        output: result,
-                    });
-                    functionResponses.push({
-                        functionResponse: {
-                            name: call.name,
-                            response: { result },
-                        },
-                    });
-                }
-                catch (error) {
-                    const errorMessage = error instanceof Error ? error.message : "Unknown error";
-                    const currentFailInfo = failedTools.get(call.name) || {
-                        count: 0,
-                        lastError: "",
-                    };
-                    currentFailInfo.count++;
-                    currentFailInfo.lastError = errorMessage;
-                    failedTools.set(call.name, currentFailInfo);
-                    logger.warn(`[GoogleVertex] Tool "${call.name}" failed (attempt ${currentFailInfo.count}/${DEFAULT_TOOL_MAX_RETRIES}): ${errorMessage}`);
-                    const isPermanentFailure = currentFailInfo.count >= DEFAULT_TOOL_MAX_RETRIES;
-                    const errorOutput = {
-                        error: isPermanentFailure
-                            ? `TOOL_PERMANENTLY_FAILED: The tool "${call.name}" has failed ${currentFailInfo.count} times with error: ${errorMessage}. This tool will not be retried. Please proceed without using this tool or inform the user that this functionality is unavailable.`
-                            : `TOOL_EXECUTION_ERROR: ${errorMessage}. Retry attempt ${currentFailInfo.count}/${DEFAULT_TOOL_MAX_RETRIES}.`,
-                        status: isPermanentFailure ? "permanently_failed" : "failed",
-                        do_not_retry: isPermanentFailure,
-                        retry_count: currentFailInfo.count,
-                        max_retries: DEFAULT_TOOL_MAX_RETRIES,
-                    };
-                    toolExecutions?.push({
-                        name: call.name,
-                        input: call.args,
-                        output: errorOutput,
-                    });
-                    functionResponses.push({
-                        functionResponse: { name: call.name, response: errorOutput },
-                    });
-                }
-            }
-            else {
-                // Tool not found is a permanent error
-                const errorOutput = {
-                    error: `TOOL_NOT_FOUND: The tool "${call.name}" does not exist. Do not attempt to call this tool again.`,
-                    status: "permanently_failed",
-                    do_not_retry: true,
-                };
-                toolExecutions?.push({
-                    name: call.name,
-                    input: call.args,
-                    output: errorOutput,
-                });
-                functionResponses.push({
-                    functionResponse: { name: call.name, response: errorOutput },
-                });
-            }
-        }
-        return functionResponses;
-    }
-    /**
-     * Collect raw response parts and function calls from a native SDK content stream chunk.
-     * Also accumulates token usage metadata.
-     * Returns updated token counts.
-     */
-    processNativeStreamChunk(chunk, rawResponseParts, stepFunctionCalls, tokenUsage) {
-        const chunkRecord = chunk;
-        const candidates = chunkRecord.candidates;
-        const firstCandidate = candidates?.[0];
-        const chunkContent = firstCandidate?.content;
-        if (chunkContent && Array.isArray(chunkContent.parts)) {
-            rawResponseParts.push(...chunkContent.parts);
-        }
-        if (chunk.functionCalls) {
-            stepFunctionCalls.push(...chunk.functionCalls);
-        }
-        const usageMetadata = chunkRecord.usageMetadata;
-        if (usageMetadata) {
-            if (usageMetadata.promptTokenCount !== undefined &&
-                usageMetadata.promptTokenCount > 0) {
-                tokenUsage.input = usageMetadata.promptTokenCount;
-            }
-            if (usageMetadata.candidatesTokenCount !== undefined &&
-                usageMetadata.candidatesTokenCount > 0) {
-                tokenUsage.output = usageMetadata.candidatesTokenCount;
-            }
-        }
-    }
-    /**
-     * Push model response parts to conversation history, preserving thoughtSignature
-     * for Gemini 3 multi-turn tool calling.
-     */
-    pushModelResponseToHistory(currentContents, rawResponseParts, stepFunctionCalls) {
-        currentContents.push({
-            role: "model",
-            parts: rawResponseParts.length > 0
-                ? rawResponseParts
-                : stepFunctionCalls.map((fc) => ({ functionCall: fc })),
-        });
-    }
-    /**
-     * Compute final text for maxSteps termination when the model was still calling tools.
-     */
-    computeMaxStepsTerminationText(step, maxSteps, finalText, lastStepText) {
-        if (step >= maxSteps && !finalText) {
-            logger.warn(`[GoogleVertex] Tool call loop terminated after reaching maxSteps (${maxSteps}). ` +
-                `Model was still calling tools. Using accumulated text from last step.`);
-            return (lastStepText ||
-                `[Tool execution limit reached after ${maxSteps} steps. The model continued requesting tool calls beyond the limit.]`);
-        }
-        return finalText;
-    }
-    // ── End shared helpers ──
+    // ── Shared Gemini 3 helpers are now in ./googleNativeGemini3.ts ──
     /**
      * Execute stream using native @google/genai SDK for Gemini 3 models on Vertex AI
      * This bypasses @ai-sdk/google-vertex to properly handle thought_signature
@@ -1193,16 +968,30 @@ export class GoogleVertexProvider extends BaseProvider {
         const multimodalInput = options.input;
         const contents = this.buildNativeContentParts(options.input.text, multimodalInput, "native stream");
         // Convert tools to native format
-        const toolsInput = options.tools &&
+        let hasToolsInput = options.tools &&
             Object.keys(options.tools).length > 0 &&
-            !options.disableTools
-            ? options.tools
-            : {};
-        const { tools, executeMap } = this.convertToolsToNativeFunctionDeclarations(toolsInput, "native SDK");
+            !options.disableTools;
+        // Guard: Gemini cannot use tools + JSON schema simultaneously
+        const streamOptions = options;
+        const wantsJsonOutput = streamOptions.output?.format === "json" || streamOptions.schema;
+        if (wantsJsonOutput && hasToolsInput) {
+            logger.warn("[GoogleVertex] Gemini does not support tools and JSON schema output simultaneously. Disabling tools for this request.");
+            hasToolsInput = false;
+        }
+        let toolsConfig;
+        let executeMap = new Map();
+        if (hasToolsInput) {
+            const result = buildNativeToolDeclarations(options.tools);
+            toolsConfig = result.toolsConfig;
+            executeMap = result.executeMap;
+            logger.debug("[GoogleVertex] Converted tools for native SDK", {
+                toolCount: toolsConfig[0].functionDeclarations.length,
+                toolNames: toolsConfig[0].functionDeclarations.map((t) => t.name),
+            });
+        }
         // Build config
-        const config = this.buildNativeGenerateConfig(options, tools);
+        const config = buildNativeConfig(options, toolsConfig);
         // Add JSON output format support for native SDK stream
-        const streamOptions = options;
         if (streamOptions.output?.format === "json" || streamOptions.schema) {
             config.responseMimeType = "application/json";
             if (streamOptions.schema) {
@@ -1218,50 +1007,63 @@ export class GoogleVertexProvider extends BaseProvider {
             }
         }
         const startTime = Date.now();
-        const maxSteps = this.computeMaxSteps(options.maxSteps);
+        const timeout = this.getTimeout(options);
+        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
+        const composedSignal = composeAbortSignals(options.abortSignal, timeoutController?.controller.signal);
+        const maxSteps = computeMaxStepsShared(options.maxSteps);
         const currentContents = [...contents];
         let finalText = "";
         let lastStepText = "";
+        let totalInputTokens = 0;
+        let totalOutputTokens = 0;
         const allToolCalls = [];
         let step = 0;
         const failedTools = new Map();
-        const tokenUsage = { input: 0, output: 0 };
         // Agentic loop for tool calling
-        while (step < maxSteps) {
-            step++;
-            logger.debug(`[GoogleVertex] Native SDK step ${step}/${maxSteps}`);
-            try {
-                const stream = await client.models.generateContentStream({
-                    model: modelName,
-                    contents: currentContents,
-                    config,
-                });
-                const stepFunctionCalls = [];
-                const rawResponseParts = [];
-                for await (const chunk of stream) {
-                    this.processNativeStreamChunk(chunk, rawResponseParts, stepFunctionCalls, tokenUsage);
-                }
-                const stepText = this.extractTextFromRawParts(rawResponseParts);
-                if (stepFunctionCalls.length === 0) {
-                    finalText = stepText;
+        try {
+            while (step < maxSteps) {
+                if (timeoutController?.controller.signal.aborted) {
                     break;
                 }
-                lastStepText = stepText;
-                logger.debug(`[GoogleVertex] Executing ${stepFunctionCalls.length} function calls`);
-                this.pushModelResponseToHistory(currentContents, rawResponseParts, stepFunctionCalls);
-                const functionResponses = await this.executeNativeFunctionCalls(stepFunctionCalls, executeMap, failedTools, allToolCalls);
-                // Add function responses to history
-                currentContents.push({
-                    role: "function",
-                    parts: functionResponses,
-                });
-            }
-            catch (error) {
-                logger.error("[GoogleVertex] Native SDK error", error);
-                throw this.handleProviderError(error);
+                step++;
+                logger.debug(`[GoogleVertex] Native SDK step ${step}/${maxSteps}`);
+                try {
+                    const stream = await client.models.generateContentStream({
+                        model: modelName,
+                        contents: currentContents,
+                        config,
+                        ...(composedSignal
+                            ? { httpOptions: { signal: composedSignal } }
+                            : {}),
+                    });
+                    const chunkResult = await collectStreamChunks(stream);
+                    totalInputTokens += chunkResult.inputTokens;
+                    totalOutputTokens += chunkResult.outputTokens;
+                    const stepText = extractTextFromParts(chunkResult.rawResponseParts);
+                    if (chunkResult.stepFunctionCalls.length === 0) {
+                        finalText = stepText;
+                        break;
+                    }
+                    lastStepText = stepText;
+                    logger.debug(`[GoogleVertex] Executing ${chunkResult.stepFunctionCalls.length} function calls`);
+                    pushModelResponseToHistory(currentContents, chunkResult.rawResponseParts, chunkResult.stepFunctionCalls);
+                    const functionResponses = await executeNativeToolCalls("[GoogleVertex]", chunkResult.stepFunctionCalls, executeMap, failedTools, allToolCalls, { abortSignal: composedSignal });
+                    // Add function responses to history
+                    currentContents.push({
+                        role: "function",
+                        parts: functionResponses,
+                    });
+                }
+                catch (error) {
+                    logger.error("[GoogleVertex] Native SDK error", error);
+                    throw this.handleProviderError(error);
+                }
             }
         }
-        finalText = this.computeMaxStepsTerminationText(step, maxSteps, finalText, lastStepText);
+        finally {
+            timeoutController?.cleanup();
+        }
+        finalText = handleMaxStepsTermination("[GoogleVertex]", step, maxSteps, finalText, lastStepText);
         const responseTime = Date.now() - startTime;
         // Create async iterable for streaming result
         async function* createTextStream() {
@@ -1272,9 +1074,9 @@ export class GoogleVertexProvider extends BaseProvider {
             provider: this.providerName,
             model: modelName,
             usage: {
-                input: tokenUsage.input,
-                output: tokenUsage.output,
-                total: tokenUsage.input + tokenUsage.output,
+                input: totalInputTokens,
+                output: totalOutputTokens,
+                total: totalInputTokens + totalOutputTokens,
             },
             toolCalls: allToolCalls.map((tc) => ({
                 toolName: tc.toolName,
@@ -1306,62 +1108,93 @@ export class GoogleVertexProvider extends BaseProvider {
         const multimodalInput = options.input;
         const contents = this.buildNativeContentParts(inputText, multimodalInput, "native generate");
         // Get tools from SDK and options
-        const shouldUseTools = !options.disableTools && this.supportsTools();
+        let shouldUseTools = !options.disableTools && this.supportsTools();
+        // Guard: Gemini cannot use tools + JSON schema simultaneously
+        const wantsJsonOutputGen = options.output?.format === "json" || options.schema;
+        if (wantsJsonOutputGen && shouldUseTools) {
+            logger.warn("[GoogleVertex] Gemini does not support tools and JSON schema output simultaneously. Disabling tools for this request.");
+            shouldUseTools = false;
+        }
         const sdkTools = shouldUseTools ? await this.getAllTools() : {};
-        const combinedTools = { ...sdkTools, ...(options.tools || {}) };
-        const { tools, executeMap } = this.convertToolsToNativeFunctionDeclarations(combinedTools, "native SDK generate");
+        const combinedTools = shouldUseTools
+            ? { ...sdkTools, ...(options.tools || {}) }
+            : {};
+        let toolsConfig;
+        let executeMap = new Map();
+        if (Object.keys(combinedTools).length > 0) {
+            const result = buildNativeToolDeclarations(combinedTools);
+            toolsConfig = result.toolsConfig;
+            executeMap = result.executeMap;
+            logger.debug("[GoogleVertex] Converted tools for native SDK generate", {
+                toolCount: toolsConfig[0].functionDeclarations.length,
+                toolNames: toolsConfig[0].functionDeclarations.map((t) => t.name),
+            });
+        }
         // Build config
-        const config = this.buildNativeGenerateConfig(options, tools);
+        const config = buildNativeConfig(options, toolsConfig);
         // Note: Schema/JSON output for Gemini 3 native SDK is complex due to $ref resolution issues
         // For now, schemas are handled via the AI SDK fallback path, not native SDK
         // TODO: Implement proper $ref resolution for complex nested schemas
         const startTime = Date.now();
-        const maxSteps = this.computeMaxSteps(options.maxSteps);
+        const timeout = this.getTimeout(options);
+        const timeoutController = createTimeoutController(timeout, this.providerName, "generate");
+        const composedSignal = composeAbortSignals(options.abortSignal, timeoutController?.controller.signal);
+        const maxSteps = computeMaxStepsShared(options.maxSteps);
         const currentContents = [...contents];
         let finalText = "";
         let lastStepText = "";
+        let totalInputTokens = 0;
+        let totalOutputTokens = 0;
         const allToolCalls = [];
         const toolExecutions = [];
         let step = 0;
         const failedTools = new Map();
-        const tokenUsage = { input: 0, output: 0 };
-        // Agentic loop for tool calling
-        while (step < maxSteps) {
-            step++;
-            logger.debug(`[GoogleVertex] Native SDK generate step ${step}/${maxSteps}`);
-            try {
-                // Use generateContentStream and collect all chunks (same as GoogleAIStudio)
-                const stream = await client.models.generateContentStream({
-                    model: modelName,
-                    contents: currentContents,
-                    config,
-                });
-                const stepFunctionCalls = [];
-                const rawResponseParts = [];
-                for await (const chunk of stream) {
-                    this.processNativeStreamChunk(chunk, rawResponseParts, stepFunctionCalls, tokenUsage);
-                }
-                const stepText = this.extractTextFromRawParts(rawResponseParts);
-                if (stepFunctionCalls.length === 0) {
-                    finalText = stepText;
+        try {
+            // Agentic loop for tool calling
+            while (step < maxSteps) {
+                if (timeoutController?.controller.signal.aborted) {
                     break;
                 }
-                lastStepText = stepText;
-                logger.debug(`[GoogleVertex] Generate executing ${stepFunctionCalls.length} function calls`);
-                this.pushModelResponseToHistory(currentContents, rawResponseParts, stepFunctionCalls);
-                const functionResponses = await this.executeNativeFunctionCalls(stepFunctionCalls, executeMap, failedTools, allToolCalls, toolExecutions);
-                // Add function responses to history
-                currentContents.push({
-                    role: "function",
-                    parts: functionResponses,
-                });
-            }
-            catch (error) {
-                logger.error("[GoogleVertex] Native SDK generate error", error);
-                throw this.handleProviderError(error);
+                step++;
+                logger.debug(`[GoogleVertex] Native SDK generate step ${step}/${maxSteps}`);
+                try {
+                    // Use generateContentStream and collect all chunks (same as GoogleAIStudio)
+                    const stream = await client.models.generateContentStream({
+                        model: modelName,
+                        contents: currentContents,
+                        config,
+                        ...(composedSignal
+                            ? { httpOptions: { signal: composedSignal } }
+                            : {}),
+                    });
+                    const chunkResult = await collectStreamChunks(stream);
+                    totalInputTokens += chunkResult.inputTokens;
+                    totalOutputTokens += chunkResult.outputTokens;
+                    const stepText = extractTextFromParts(chunkResult.rawResponseParts);
+                    if (chunkResult.stepFunctionCalls.length === 0) {
+                        finalText = stepText;
+                        break;
+                    }
+                    lastStepText = stepText;
+                    logger.debug(`[GoogleVertex] Generate executing ${chunkResult.stepFunctionCalls.length} function calls`);
+                    pushModelResponseToHistory(currentContents, chunkResult.rawResponseParts, chunkResult.stepFunctionCalls);
+                    const functionResponses = await executeNativeToolCalls("[GoogleVertex]", chunkResult.stepFunctionCalls, executeMap, failedTools, allToolCalls, { toolExecutions, abortSignal: composedSignal });
+                    // Add function responses to history
+                    currentContents.push({
+                        role: "function",
+                        parts: functionResponses,
+                    });
+                }
+                catch (error) {
+                    logger.error("[GoogleVertex] Native SDK generate error", error);
+                    throw this.handleProviderError(error);
+                }
             }
         }
-        finalText = this.computeMaxStepsTerminationText(step, maxSteps, finalText, lastStepText);
+        finally {
+            timeoutController?.cleanup();
+        }
+        finalText = handleMaxStepsTermination("[GoogleVertex]", step, maxSteps, finalText, lastStepText);
         const responseTime = Date.now() - startTime;
         // Build EnhancedGenerateResult
         return {
@@ -1369,9 +1202,9 @@ export class GoogleVertexProvider extends BaseProvider {
             provider: this.providerName,
             model: modelName,
             usage: {
-                input: tokenUsage.input,
-                output: tokenUsage.output,
-                total: tokenUsage.input + tokenUsage.output,
+                input: totalInputTokens,
+                output: totalOutputTokens,
+                total: totalInputTokens + totalOutputTokens,
             },
             responseTime,
             toolsUsed: allToolCalls.map((tc) => tc.toolName),

package/dist/lib/providers/huggingFace.js

@@ -3,7 +3,7 @@ import { streamText, } from "ai";
 import { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
-import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { validateApiKey, createHuggingFaceConfig, getProviderModel, } from "../utils/providerConfig.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
@@ -112,20 +112,35 @@ export class HuggingFaceProvider extends BaseProvider {
         const timeout = this.getTimeout(options);
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
+            // Get tools - options.tools is pre-merged by BaseProvider.stream()
+            const shouldUseTools = !options.disableTools && this.supportsTools();
+            const allTools = shouldUseTools
+                ? options.tools || (await this.getAllTools())
+                : {};
             // Enhanced tool handling for HuggingFace models
             const streamOptions = this.prepareStreamOptions(options, analysisSchema);
             // Build message array from options with multimodal support
             // Using protected helper from BaseProvider to eliminate code duplication
-            const messages = await this.buildMessagesForStream(options);
+            // Pass the enhanced system prompt (with tool-calling instructions) so it
+            // actually reaches the model instead of being silently discarded.
+            const messagesOptions = streamOptions.system
+                ? { ...options, systemPrompt: streamOptions.system }
+                : options;
+            const messages = await this.buildMessagesForStream(messagesOptions);
             const result = await streamText({
                 model: this.model,
                 messages: messages,
                 temperature: options.temperature,
                 maxTokens: options.maxTokens, // No default limit - unlimited unless specified
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
-                tools: streamOptions.tools, // Tools format conversion handled by prepareStreamOptions
-                toolChoice: streamOptions.toolChoice, // Tool choice handled by prepareStreamOptions
-                abortSignal: timeoutController?.controller.signal,
+                tools: (shouldUseTools
+                    ? streamOptions.tools || allTools
+                    : {}),
+                toolChoice: (shouldUseTools
+                    ? streamOptions.toolChoice || "auto"
+                    : "none"),
+                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
+                experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 onStepFinish: ({ toolCalls, toolResults }) => {
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                         logger.warn("[HuggingFaceProvider] Failed to store tool executions", {

package/dist/lib/providers/litellm.js

@@ -4,9 +4,10 @@ import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { isAbortError } from "../utils/errorHandling.js";
 import { logger } from "../utils/logger.js";
 import { getProviderModel } from "../utils/providerConfig.js";
-import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 // Configuration helpers
 const getLiteLLMConfig = () => {
     return {
@@ -157,7 +158,8 @@ export class LiteLLMProvider extends BaseProvider {
                     toolChoice: "auto",
                     maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 }),
-                abortSignal: timeoutController?.controller.signal,
+                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
+                experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 onError: (event) => {
                     const error = event.error;
                     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -180,7 +182,7 @@ export class LiteLLMProvider extends BaseProvider {
                 onStepFinish: ({ toolCalls, toolResults }) => {
                     logger.info("Tool execution completed", { toolResults, toolCalls });
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
-                        logger.warn("LiteLLMProvider] Failed to store tool executions", {
+                        logger.warn("[LiteLLMProvider] Failed to store tool executions", {
                             provider: this.providerName,
                             error: error instanceof Error ? error.message : String(error),
                         });
@@ -361,7 +363,7 @@ export class LiteLLMProvider extends BaseProvider {
         }
         catch (error) {
             clearTimeout(timeoutId);
-            if (error instanceof Error && error.name === "AbortError") {
+            if (isAbortError(error)) {
                 throw new Error("Request timed out after 5 seconds");
             }
             throw error;