@juspay/neurolink 9.15.0 → 9.16.0

package/dist/providers/googleAiStudio.js

@@ -1,6 +1,7 @@
 import { createGoogleGenerativeAI } from "@ai-sdk/google";
 import { streamText } from "ai";
 import { ErrorCategory, ErrorSeverity, GoogleAIModels, } from "../constants/enums.js";
+import { estimateTokens } from "../utils/tokenEstimation.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
@@ -8,6 +9,7 @@ import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } fro
 import { ERROR_CODES, NeuroLinkError } from "../utils/errorHandling.js";
 import { logger } from "../utils/logger.js";
 import { isGemini3Model } from "../utils/modelDetection.js";
+import { tracers, ATTR, withClientSpan } from "../telemetry/index.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { buildNativeToolDeclarations, buildNativeConfig, computeMaxSteps, collectStreamChunks, extractTextFromParts, executeNativeToolCalls, handleMaxStepsTermination, pushModelResponseToHistory, } from "./googleNativeGemini3.js";
 // Google AI Live API types now imported from ../types/providerSpecific.js
@@ -377,11 +379,10 @@ export class GoogleAIStudioProvider extends BaseProvider {
         return "image/png";
     }
     /**
-     * Estimate token count from text (simple character-based estimation)
+     * Estimate token count from text using centralized estimation with provider multipliers
      */
     estimateTokenCount(text) {
-        // Rough estimation: ~4 characters per token
-        return Math.ceil(text.length / 4);
+        return estimateTokens(text, "google-ai");
     }
     // executeGenerate removed - BaseProvider handles all generation with tools
     async executeStream(options, _analysisSchema) {
@@ -409,13 +410,21 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 logger.warn("[GoogleAIStudio] Gemini does not support tools and JSON schema output simultaneously. Disabling tools for this request.");
                 mergedOptions = { ...mergedOptions, disableTools: true, tools: {} };
             }
-            logger.info("[GoogleAIStudio] Routing Gemini 3 to native SDK for tool calling", {
-                model: gemini3CheckModelName,
-                optionToolCount: Object.keys(optionTools).length,
-                sdkToolCount: Object.keys(sdkTools).length,
-                totalToolCount: combinedToolCount,
-            });
-            return this.executeNativeGemini3Stream(mergedOptions);
+            // Only route to native path if tools are still active after conflict check
+            const hasActiveTools = !mergedOptions.disableTools &&
+                mergedOptions.tools &&
+                Object.keys(mergedOptions.tools).length > 0;
+            if (hasActiveTools) {
+                logger.info("[GoogleAIStudio] Routing Gemini 3 to native SDK for tool calling", {
+                    model: gemini3CheckModelName,
+                    optionToolCount: Object.keys(optionTools).length,
+                    sdkToolCount: Object.keys(sdkTools).length,
+                    totalToolCount: combinedToolCount,
+                });
+                return this.executeNativeGemini3Stream(mergedOptions);
+            }
+            // Fall through to standard stream path using merged options (tools disabled for schema)
+            options = mergedOptions;
         }
         // Phase 1: if audio input present, bridge to Gemini Live (Studio) using @google/genai
         if (options.input?.audio) {
@@ -508,232 +517,280 @@ export class GoogleAIStudioProvider extends BaseProvider {
      * This bypasses @ai-sdk/google to properly handle thought_signature
      */
     async executeNativeGemini3Stream(options) {
-        const startTime = Date.now();
-        const timeout = this.getTimeout(options);
-        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
-        const apiKey = this.getApiKey();
-        const client = await createGoogleGenAIClient(apiKey);
         const modelName = options.model || this.modelName;
-        logger.debug("[GoogleAIStudio] Using native @google/genai for Gemini 3", {
-            model: modelName,
-            hasTools: !!options.tools && Object.keys(options.tools).length > 0,
-        });
-        // Build contents from input
-        const currentContents = [{ role: "user", parts: [{ text: options.input.text }] }];
-        // Convert tools
-        let toolsConfig;
-        let executeMap = new Map();
-        if (options.tools &&
-            Object.keys(options.tools).length > 0 &&
-            !options.disableTools) {
-            const result = buildNativeToolDeclarations(options.tools);
-            toolsConfig = result.toolsConfig;
-            executeMap = result.executeMap;
-            logger.debug("[GoogleAIStudio] Converted tools for native SDK", {
-                toolCount: toolsConfig[0].functionDeclarations.length,
-                toolNames: toolsConfig[0].functionDeclarations.map((t) => t.name),
-            });
-        }
-        const config = buildNativeConfig(options, toolsConfig);
-        const maxSteps = computeMaxSteps(options.maxSteps);
-        let finalText = "";
-        let lastStepText = "";
-        let totalInputTokens = 0;
-        let totalOutputTokens = 0;
-        const allToolCalls = [];
-        let step = 0;
-        const failedTools = new Map();
-        // Compose abort signal from user signal + timeout
-        const composedSignal = composeAbortSignals(options.abortSignal, timeoutController?.controller.signal);
-        try {
-            // Agentic loop for tool calling
-            while (step < maxSteps) {
-                if (composedSignal?.aborted) {
-                    break;
-                }
-                step++;
-                logger.debug(`[GoogleAIStudio] Native SDK step ${step}/${maxSteps}`);
-                try {
-                    const stream = await client.models.generateContentStream({
-                        model: modelName,
-                        contents: currentContents,
-                        config,
-                        ...(composedSignal
-                            ? { httpOptions: { signal: composedSignal } }
-                            : {}),
+        return withClientSpan({
+            name: "neurolink.provider.stream",
+            tracer: tracers.provider,
+            attributes: {
+                [ATTR.GEN_AI_SYSTEM]: "google-ai",
+                [ATTR.GEN_AI_MODEL]: modelName,
+                [ATTR.GEN_AI_OPERATION]: "stream",
+                [ATTR.NL_PROVIDER]: this.providerName,
+            },
+        }, async (span) => {
+            const startTime = Date.now();
+            const timeout = this.getTimeout(options);
+            const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
+            try {
+                const apiKey = this.getApiKey();
+                const client = await createGoogleGenAIClient(apiKey);
+                logger.debug("[GoogleAIStudio] Using native @google/genai for Gemini 3", {
+                    model: modelName,
+                    hasTools: !!options.tools && Object.keys(options.tools).length > 0,
+                });
+                // Build contents from input
+                const currentContents = [{ role: "user", parts: [{ text: options.input.text }] }];
+                // Convert tools
+                let toolsConfig;
+                let executeMap = new Map();
+                if (options.tools &&
+                    Object.keys(options.tools).length > 0 &&
+                    !options.disableTools) {
+                    const result = buildNativeToolDeclarations(options.tools);
+                    toolsConfig = result.toolsConfig;
+                    executeMap = result.executeMap;
+                    logger.debug("[GoogleAIStudio] Converted tools for native SDK", {
+                        toolCount: toolsConfig[0].functionDeclarations.length,
+                        toolNames: toolsConfig[0].functionDeclarations.map((t) => t.name),
                     });
-                    const chunkResult = await collectStreamChunks(stream);
-                    totalInputTokens += chunkResult.inputTokens;
-                    totalOutputTokens += chunkResult.outputTokens;
-                    const stepText = extractTextFromParts(chunkResult.rawResponseParts);
-                    // If no function calls, we're done
-                    if (chunkResult.stepFunctionCalls.length === 0) {
-                        finalText = stepText;
-                        break;
+                }
+                const config = buildNativeConfig(options, toolsConfig);
+                const maxSteps = computeMaxSteps(options.maxSteps);
+                let finalText = "";
+                let lastStepText = "";
+                let totalInputTokens = 0;
+                let totalOutputTokens = 0;
+                const allToolCalls = [];
+                let step = 0;
+                const failedTools = new Map();
+                // Compose abort signal from user signal + timeout
+                const composedSignal = composeAbortSignals(options.abortSignal, timeoutController?.controller.signal);
+                // Agentic loop for tool calling
+                while (step < maxSteps) {
+                    if (composedSignal?.aborted) {
+                        throw composedSignal.reason instanceof Error
+                            ? composedSignal.reason
+                            : new Error("Request aborted");
+                    }
+                    step++;
+                    logger.debug(`[GoogleAIStudio] 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 no function calls, we're done
+                        if (chunkResult.stepFunctionCalls.length === 0) {
+                            finalText = stepText;
+                            break;
+                        }
+                        lastStepText = stepText;
+                        // Record tool call events on the span
+                        for (const fc of chunkResult.stepFunctionCalls) {
+                            span.addEvent("gen_ai.tool_call", {
+                                "tool.name": fc.name,
+                                "tool.step": step,
+                            });
+                        }
+                        logger.debug(`[GoogleAIStudio] Executing ${chunkResult.stepFunctionCalls.length} function calls`);
+                        // Add model response with ALL parts (including thoughtSignature) to history
+                        pushModelResponseToHistory(currentContents, chunkResult.rawResponseParts, chunkResult.stepFunctionCalls);
+                        const functionResponses = await executeNativeToolCalls("[GoogleAIStudio]", chunkResult.stepFunctionCalls, executeMap, failedTools, allToolCalls, { abortSignal: composedSignal });
+                        // Add function responses to history
+                        currentContents.push({
+                            role: "function",
+                            parts: functionResponses,
+                        });
+                    }
+                    catch (error) {
+                        logger.error("[GoogleAIStudio] Native SDK error", error);
+                        throw this.handleProviderError(error);
                     }
-                    lastStepText = stepText;
-                    logger.debug(`[GoogleAIStudio] Executing ${chunkResult.stepFunctionCalls.length} function calls`);
-                    // Add model response with ALL parts (including thoughtSignature) to history
-                    pushModelResponseToHistory(currentContents, chunkResult.rawResponseParts, chunkResult.stepFunctionCalls);
-                    const functionResponses = await executeNativeToolCalls("[GoogleAIStudio]", chunkResult.stepFunctionCalls, executeMap, failedTools, allToolCalls, { abortSignal: composedSignal });
-                    // Add function responses to history
-                    currentContents.push({
-                        role: "function",
-                        parts: functionResponses,
-                    });
                 }
-                catch (error) {
-                    logger.error("[GoogleAIStudio] Native SDK error", error);
-                    throw this.handleProviderError(error);
+                finalText = handleMaxStepsTermination("[GoogleAIStudio]", step, maxSteps, finalText, lastStepText);
+                const responseTime = Date.now() - startTime;
+                // Set token usage and finish reason on the span
+                span.setAttribute(ATTR.GEN_AI_INPUT_TOKENS, totalInputTokens);
+                span.setAttribute(ATTR.GEN_AI_OUTPUT_TOKENS, totalOutputTokens);
+                span.setAttribute(ATTR.GEN_AI_FINISH_REASON, step >= maxSteps ? "max_steps" : "stop");
+                // Create async iterable for streaming result
+                async function* createTextStream() {
+                    yield { content: finalText };
                 }
+                return {
+                    stream: createTextStream(),
+                    provider: this.providerName,
+                    model: modelName,
+                    toolCalls: allToolCalls.map((tc) => ({
+                        toolName: tc.toolName,
+                        args: tc.args,
+                    })),
+                    analytics: Promise.resolve({
+                        provider: this.providerName,
+                        model: modelName,
+                        tokenUsage: {
+                            input: totalInputTokens,
+                            output: totalOutputTokens,
+                            total: totalInputTokens + totalOutputTokens,
+                        },
+                        requestDuration: responseTime,
+                        timestamp: new Date().toISOString(),
+                    }),
+                    metadata: {
+                        streamId: `native-${Date.now()}`,
+                        startTime,
+                        responseTime,
+                        totalToolExecutions: allToolCalls.length,
+                    },
+                };
             }
-        }
-        finally {
-            timeoutController?.cleanup();
-        }
-        finalText = handleMaxStepsTermination("[GoogleAIStudio]", step, maxSteps, finalText, lastStepText);
-        const responseTime = Date.now() - startTime;
-        // Create async iterable for streaming result
-        async function* createTextStream() {
-            yield { content: finalText };
-        }
-        return {
-            stream: createTextStream(),
-            provider: this.providerName,
-            model: modelName,
-            toolCalls: allToolCalls.map((tc) => ({
-                toolName: tc.toolName,
-                args: tc.args,
-            })),
-            analytics: Promise.resolve({
-                provider: this.providerName,
-                model: modelName,
-                tokenUsage: {
-                    input: totalInputTokens,
-                    output: totalOutputTokens,
-                    total: totalInputTokens + totalOutputTokens,
-                },
-                requestDuration: responseTime,
-                timestamp: new Date().toISOString(),
-            }),
-            metadata: {
-                streamId: `native-${Date.now()}`,
-                startTime,
-                responseTime,
-                totalToolExecutions: allToolCalls.length,
-            },
-        };
+            finally {
+                timeoutController?.cleanup();
+            }
+        });
     }
     /**
      * Execute generate using native @google/genai SDK for Gemini 3 models
      * This bypasses @ai-sdk/google to properly handle thought_signature
      */
     async executeNativeGemini3Generate(options) {
-        const apiKey = this.getApiKey();
-        const client = await createGoogleGenAIClient(apiKey);
         const modelName = options.model || this.modelName;
-        logger.debug("[GoogleAIStudio] Using native @google/genai for Gemini 3 generate", {
-            model: modelName,
-            hasTools: !!options.tools && Object.keys(options.tools).length > 0,
-        });
-        // Build contents from input
-        const promptText = options.prompt || options.input?.text || "";
-        const currentContents = [{ role: "user", parts: [{ text: promptText }] }];
-        // Convert tools (merge SDK tools with options.tools)
-        let toolsConfig;
-        let executeMap = new Map();
-        const shouldUseTools = !options.disableTools;
-        if (shouldUseTools) {
-            const sdkTools = await this.getAllTools();
-            const mergedTools = { ...sdkTools, ...(options.tools || {}) };
-            if (Object.keys(mergedTools).length > 0) {
-                const result = buildNativeToolDeclarations(mergedTools);
-                toolsConfig = result.toolsConfig;
-                executeMap = result.executeMap;
-                logger.debug("[GoogleAIStudio] Converted tools for native SDK generate", {
-                    toolCount: toolsConfig[0].functionDeclarations.length,
-                    toolNames: toolsConfig[0].functionDeclarations.map((t) => t.name),
+        return withClientSpan({
+            name: "neurolink.provider.generate",
+            tracer: tracers.provider,
+            attributes: {
+                [ATTR.GEN_AI_SYSTEM]: "google-ai",
+                [ATTR.GEN_AI_MODEL]: modelName,
+                [ATTR.GEN_AI_OPERATION]: "generate",
+                [ATTR.NL_PROVIDER]: this.providerName,
+            },
+        }, async (span) => {
+            const startTime = Date.now();
+            const timeout = this.getTimeout(options);
+            const timeoutController = createTimeoutController(timeout, this.providerName, "generate");
+            try {
+                const apiKey = this.getApiKey();
+                const client = await createGoogleGenAIClient(apiKey);
+                logger.debug("[GoogleAIStudio] Using native @google/genai for Gemini 3 generate", {
+                    model: modelName,
+                    hasTools: !!options.tools && Object.keys(options.tools).length > 0,
                 });
-            }
-        }
-        const config = buildNativeConfig(options, toolsConfig);
-        const startTime = Date.now();
-        const timeout = this.getTimeout(options);
-        const timeoutController = createTimeoutController(timeout, this.providerName, "generate");
-        const composedSignal = composeAbortSignals(options.abortSignal, timeoutController?.controller.signal);
-        const maxSteps = computeMaxSteps(options.maxSteps);
-        let finalText = "";
-        let lastStepText = "";
-        let totalInputTokens = 0;
-        let totalOutputTokens = 0;
-        const allToolCalls = [];
-        const toolExecutions = [];
-        let step = 0;
-        const failedTools = new Map();
-        try {
-            // Agentic loop for tool calling
-            while (step < maxSteps) {
-                if (composedSignal?.aborted) {
-                    break;
-                }
-                step++;
-                logger.debug(`[GoogleAIStudio] Native SDK generate 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 no function calls, we're done
-                    if (chunkResult.stepFunctionCalls.length === 0) {
-                        finalText = stepText;
-                        break;
+                // Build contents from input
+                const promptText = options.prompt || options.input?.text || "";
+                const currentContents = [{ role: "user", parts: [{ text: promptText }] }];
+                // Convert tools (merge SDK tools with options.tools)
+                let toolsConfig;
+                let executeMap = new Map();
+                const shouldUseTools = !options.disableTools;
+                if (shouldUseTools) {
+                    const sdkTools = await this.getAllTools();
+                    const mergedTools = { ...sdkTools, ...(options.tools || {}) };
+                    if (Object.keys(mergedTools).length > 0) {
+                        const result = buildNativeToolDeclarations(mergedTools);
+                        toolsConfig = result.toolsConfig;
+                        executeMap = result.executeMap;
+                        logger.debug("[GoogleAIStudio] Converted tools for native SDK generate", {
+                            toolCount: toolsConfig[0].functionDeclarations.length,
+                            toolNames: toolsConfig[0].functionDeclarations.map((t) => t.name),
+                        });
                     }
-                    lastStepText = stepText;
-                    logger.debug(`[GoogleAIStudio] Executing ${chunkResult.stepFunctionCalls.length} function calls in generate`);
-                    // Add model response with ALL parts (including thoughtSignature) to history
-                    // This is critical for Gemini 3 - it requires thought signatures in subsequent turns
-                    pushModelResponseToHistory(currentContents, chunkResult.rawResponseParts, chunkResult.stepFunctionCalls);
-                    const functionResponses = await executeNativeToolCalls("[GoogleAIStudio]", chunkResult.stepFunctionCalls, executeMap, failedTools, allToolCalls, { toolExecutions, abortSignal: composedSignal });
-                    // Add function responses to history
-                    currentContents.push({
-                        role: "function",
-                        parts: functionResponses,
-                    });
                 }
-                catch (error) {
-                    logger.error("[GoogleAIStudio] Native SDK generate error", error);
-                    throw this.handleProviderError(error);
+                const config = buildNativeConfig(options, toolsConfig);
+                const composedSignal = composeAbortSignals(options.abortSignal, timeoutController?.controller.signal);
+                const maxSteps = computeMaxSteps(options.maxSteps);
+                let finalText = "";
+                let lastStepText = "";
+                let totalInputTokens = 0;
+                let totalOutputTokens = 0;
+                const allToolCalls = [];
+                const toolExecutions = [];
+                let step = 0;
+                const failedTools = new Map();
+                // Agentic loop for tool calling
+                while (step < maxSteps) {
+                    if (composedSignal?.aborted) {
+                        throw composedSignal.reason instanceof Error
+                            ? composedSignal.reason
+                            : new Error("Request aborted");
+                    }
+                    step++;
+                    logger.debug(`[GoogleAIStudio] Native SDK generate 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 no function calls, we're done
+                        if (chunkResult.stepFunctionCalls.length === 0) {
+                            finalText = stepText;
+                            break;
+                        }
+                        lastStepText = stepText;
+                        // Record tool call events on the span
+                        for (const fc of chunkResult.stepFunctionCalls) {
+                            span.addEvent("gen_ai.tool_call", {
+                                "tool.name": fc.name,
+                                "tool.step": step,
+                            });
+                        }
+                        logger.debug(`[GoogleAIStudio] Executing ${chunkResult.stepFunctionCalls.length} function calls in generate`);
+                        // Add model response with ALL parts (including thoughtSignature) to history
+                        // This is critical for Gemini 3 - it requires thought signatures in subsequent turns
+                        pushModelResponseToHistory(currentContents, chunkResult.rawResponseParts, chunkResult.stepFunctionCalls);
+                        const functionResponses = await executeNativeToolCalls("[GoogleAIStudio]", chunkResult.stepFunctionCalls, executeMap, failedTools, allToolCalls, { toolExecutions, abortSignal: composedSignal });
+                        // Add function responses to history
+                        currentContents.push({
+                            role: "function",
+                            parts: functionResponses,
+                        });
+                    }
+                    catch (error) {
+                        logger.error("[GoogleAIStudio] Native SDK generate error", error);
+                        throw this.handleProviderError(error);
+                    }
                 }
+                finalText = handleMaxStepsTermination("[GoogleAIStudio]", step, maxSteps, finalText, lastStepText);
+                const responseTime = Date.now() - startTime;
+                // Set token usage and finish reason on the span
+                span.setAttribute(ATTR.GEN_AI_INPUT_TOKENS, totalInputTokens);
+                span.setAttribute(ATTR.GEN_AI_OUTPUT_TOKENS, totalOutputTokens);
+                span.setAttribute(ATTR.GEN_AI_FINISH_REASON, step >= maxSteps ? "max_steps" : "stop");
+                // Build EnhancedGenerateResult
+                return {
+                    content: finalText,
+                    provider: this.providerName,
+                    model: modelName,
+                    usage: {
+                        input: totalInputTokens,
+                        output: totalOutputTokens,
+                        total: totalInputTokens + totalOutputTokens,
+                    },
+                    responseTime,
+                    toolsUsed: allToolCalls.map((tc) => tc.toolName),
+                    toolExecutions: toolExecutions,
+                    enhancedWithTools: allToolCalls.length > 0,
+                };
             }
-        }
-        finally {
-            timeoutController?.cleanup();
-        }
-        finalText = handleMaxStepsTermination("[GoogleAIStudio]", step, maxSteps, finalText, lastStepText);
-        const responseTime = Date.now() - startTime;
-        // Build EnhancedGenerateResult
-        return {
-            content: finalText,
-            provider: this.providerName,
-            model: modelName,
-            usage: {
-                input: totalInputTokens,
-                output: totalOutputTokens,
-                total: totalInputTokens + totalOutputTokens,
-            },
-            responseTime,
-            toolsUsed: allToolCalls.map((tc) => tc.toolName),
-            toolExecutions: toolExecutions,
-            enhancedWithTools: allToolCalls.length > 0,
-        };
+            finally {
+                timeoutController?.cleanup();
+            }
+        });
     }
     /**
      * Override generate to route Gemini 3 models with tools to native SDK
@@ -765,17 +822,25 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 logger.warn("[GoogleAIStudio] Gemini does not support tools and JSON schema output simultaneously. Disabling tools for this request.");
                 mergedOptions = { ...mergedOptions, disableTools: true, tools: {} };
             }
-            logger.info("[GoogleAIStudio] Routing Gemini 3 generate to native SDK for tool calling", {
-                model: modelName,
-                sdkToolCount: Object.keys(sdkTools).length,
-                optionToolCount: Object.keys(options.tools || {}).length,
-                totalToolCount: Object.keys(sdkTools).length +
-                    Object.keys(options.tools || {}).length,
-            });
-            return this.executeNativeGemini3Generate(mergedOptions);
+            // Only route to native path if tools are still active after conflict check
+            const hasActiveTools = !mergedOptions.disableTools &&
+                mergedOptions.tools &&
+                Object.keys(mergedOptions.tools).length > 0;
+            if (hasActiveTools) {
+                logger.info("[GoogleAIStudio] Routing Gemini 3 generate to native SDK for tool calling", {
+                    model: modelName,
+                    sdkToolCount: Object.keys(sdkTools).length,
+                    optionToolCount: Object.keys(options.tools || {}).length,
+                    totalToolCount: Object.keys(sdkTools).length +
+                        Object.keys(options.tools || {}).length,
+                });
+                return this.executeNativeGemini3Generate(mergedOptions);
+            }
+            // Fall through to standard generate path using merged options (tools disabled for schema)
+            return super.generate(mergedOptions);
         }
         // Fall back to BaseProvider implementation
-        return super.generate(optionsOrPrompt);
+        return super.generate(options);
     }
     // ===================
     // HELPER METHODS

package/dist/providers/googleVertex.d.ts

@@ -4,6 +4,21 @@ import { type AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import type { EnhancedGenerateResult, TextGenerationOptions } from "../types/generateTypes.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
+/**
+ * Vertex Model Aliases
+ *
+ * Maps shorthand model names to their full versioned IDs required by the
+ * Vertex AI API. This allows users to pass convenient names like
+ * "claude-sonnet-4-5" instead of "claude-sonnet-4-5@20250929".
+ *
+ * Alias resolution runs at the very start of getModel() so that all
+ * downstream code (isAnthropicModel, validateAnthropicModelName, etc.)
+ * sees the canonical versioned name.
+ *
+ * To add a new model: simply add an entry mapping the shorthand to the
+ * full versioned string. No other changes are needed.
+ */
+export declare const VERTEX_MODEL_ALIASES: Record<string, string>;
 /**
  * Google Vertex AI Provider v2 - BaseProvider Implementation
  *
@@ -74,6 +89,11 @@ export declare class GoogleVertexProvider extends BaseProvider {
      * Creates fresh model instances for each request
      */
     protected getAISDKModel(): Promise<LanguageModel>;
+    /**
+     * Resolve a raw model name through the alias map.
+     * Used internally to normalize model names before any API calls.
+     */
+    private resolveAlias;
     /**
      * Initialize model creation tracking
      */
@@ -156,6 +176,21 @@ export declare class GoogleVertexProvider extends BaseProvider {
      * @returns Promise<boolean> indicating if Anthropic support is available
      */
     hasAnthropicSupport(): Promise<boolean>;
+    /**
+     * Resolve a shorthand model name to its full versioned Vertex AI identifier.
+     * Returns the original name unchanged if no alias exists.
+     *
+     * @param modelName - A model name, possibly a shorthand alias
+     * @returns The resolved full versioned model name
+     *
+     * @example
+     * ```typescript
+     * provider.resolveModelAlias("claude-sonnet-4-5"); // "claude-sonnet-4-5@20250929"
+     * provider.resolveModelAlias("gemini-3-pro");      // "gemini-3-pro-latest"
+     * provider.resolveModelAlias("gemini-2.5-flash");  // "gemini-2.5-flash" (unchanged)
+     * ```
+     */
+    resolveModelAlias(modelName: string): string;
     /**
      * Create an Anthropic model instance using vertexAnthropic provider
      * Uses fresh vertex settings for each request with comprehensive validation
@@ -233,7 +268,7 @@ export declare class GoogleVertexProvider extends BaseProvider {
      */
     private detectImageType;
     /**
-     * Estimate token count from text (simple character-based estimation)
+     * Estimate token count from text using centralized estimation with provider multipliers
      */
     private estimateTokenCount;
     /**