@juspay/neurolink 9.6.0 → 9.7.0

package/dist/lib/providers/googleAiStudio.js

@@ -2,15 +2,14 @@ import { createGoogleGenerativeAI } from "@ai-sdk/google";
 import { streamText } from "ai";
 import { ErrorCategory, ErrorSeverity, GoogleAIModels, } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
-import { DEFAULT_MAX_STEPS, DEFAULT_TOOL_MAX_RETRIES, } from "../core/constants.js";
+import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } from "../types/errors.js";
 import { ERROR_CODES, NeuroLinkError } from "../utils/errorHandling.js";
 import { logger } from "../utils/logger.js";
 import { isGemini3Model } from "../utils/modelDetection.js";
-import { convertZodToJsonSchema, inlineJsonSchema, isZodSchema, } 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, collectStreamChunks, extractTextFromParts, executeNativeToolCalls, handleMaxStepsTermination, pushModelResponseToHistory, } from "./googleNativeGemini3.js";
 // Google AI Live API types now imported from ../types/providerSpecific.js
 // Import proper types for multimodal message handling
 // Create Google GenAI client
@@ -397,10 +396,19 @@ export class GoogleAIStudioProvider extends BaseProvider {
         const hasTools = gemini3CheckShouldUseTools && combinedToolCount > 0;
         if (isGemini3Model(gemini3CheckModelName) && hasTools) {
             // Merge SDK tools into options for native SDK path
-            const mergedOptions = {
+            let mergedOptions = {
                 ...options,
                 tools: { ...sdkTools, ...optionTools },
             };
+            // Check for tools + JSON schema conflict (Gemini limitation)
+            const wantsJsonOutput = options.output?.format === "json" || options.schema;
+            if (wantsJsonOutput &&
+                mergedOptions.tools &&
+                Object.keys(mergedOptions.tools).length > 0 &&
+                !mergedOptions.disableTools) {
+                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,
@@ -441,7 +449,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 tools,
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",
-                abortSignal: timeoutController?.controller.signal,
+                abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 // Gemini 3: use thinkingLevel via providerOptions
                 // Gemini 2.5: use thinkingBudget via providerOptions
@@ -470,7 +478,8 @@ export class GoogleAIStudioProvider extends BaseProvider {
                     });
                 },
             });
-            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);
             // Create analytics promise that resolves after stream completion
@@ -517,7 +526,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
         if (options.tools &&
             Object.keys(options.tools).length > 0 &&
             !options.disableTools) {
-            const result = this.buildNativeToolDeclarations(options.tools);
+            const result = buildNativeToolDeclarations(options.tools);
             toolsConfig = result.toolsConfig;
             executeMap = result.executeMap;
             logger.debug("[GoogleAIStudio] Converted tools for native SDK", {
@@ -525,8 +534,8 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 toolNames: toolsConfig[0].functionDeclarations.map((t) => t.name),
             });
         }
-        const config = this.buildNativeConfig(options, toolsConfig);
-        const maxSteps = this.computeMaxSteps(options.maxSteps);
+        const config = buildNativeConfig(options, toolsConfig);
+        const maxSteps = computeMaxSteps(options.maxSteps);
         let finalText = "";
         let lastStepText = "";
         let totalInputTokens = 0;
@@ -534,50 +543,55 @@ export class GoogleAIStudioProvider extends BaseProvider {
         const allToolCalls = [];
         let step = 0;
         const failedTools = new Map();
-        // Agentic loop for tool calling
-        while (step < maxSteps) {
-            step++;
-            logger.debug(`[GoogleAIStudio] Native SDK step ${step}/${maxSteps}`);
-            try {
-                const stream = await client.models.generateContentStream({
-                    model: modelName,
-                    contents: currentContents,
-                    config,
-                });
-                const chunkResult = await this.collectStreamChunks(stream);
-                totalInputTokens = Math.max(totalInputTokens, chunkResult.inputTokens);
-                totalOutputTokens = Math.max(totalOutputTokens, chunkResult.outputTokens);
-                const stepText = this.extractTextFromParts(chunkResult.rawResponseParts);
-                // If no function calls, we're done
-                if (chunkResult.stepFunctionCalls.length === 0) {
-                    finalText = stepText;
+        // 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;
                 }
-                lastStepText = stepText;
-                logger.debug(`[GoogleAIStudio] Executing ${chunkResult.stepFunctionCalls.length} function calls`);
-                // Add model response with ALL parts (including thoughtSignature) to history
-                currentContents.push({
-                    role: "model",
-                    parts: chunkResult.rawResponseParts.length > 0
-                        ? chunkResult.rawResponseParts
-                        : chunkResult.stepFunctionCalls.map((fc) => ({
-                            functionCall: fc,
-                        })),
-                });
-                const functionResponses = await this.executeNativeToolCalls(chunkResult.stepFunctionCalls, executeMap, failedTools, allToolCalls);
-                // Add function responses to history
-                currentContents.push({
-                    role: "function",
-                    parts: functionResponses,
-                });
-            }
-            catch (error) {
-                logger.error("[GoogleAIStudio] Native SDK error", error);
-                throw this.handleProviderError(error);
+                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;
+                    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);
+                }
             }
         }
-        timeoutController?.cleanup();
-        finalText = this.handleMaxStepsTermination(step, maxSteps, finalText, lastStepText);
+        finally {
+            timeoutController?.cleanup();
+        }
+        finalText = handleMaxStepsTermination("[GoogleAIStudio]", step, maxSteps, finalText, lastStepText);
         const responseTime = Date.now() - startTime;
         // Create async iterable for streaming result
         async function* createTextStream() {
@@ -633,7 +647,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
             const sdkTools = await this.getAllTools();
             const mergedTools = { ...sdkTools, ...(options.tools || {}) };
             if (Object.keys(mergedTools).length > 0) {
-                const result = this.buildNativeToolDeclarations(mergedTools);
+                const result = buildNativeToolDeclarations(mergedTools);
                 toolsConfig = result.toolsConfig;
                 executeMap = result.executeMap;
                 logger.debug("[GoogleAIStudio] Converted tools for native SDK generate", {
@@ -642,9 +656,12 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 });
             }
         }
-        const config = this.buildNativeConfig(options, toolsConfig);
+        const config = buildNativeConfig(options, toolsConfig);
         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 = computeMaxSteps(options.maxSteps);
         let finalText = "";
         let lastStepText = "";
         let totalInputTokens = 0;
@@ -653,50 +670,54 @@ export class GoogleAIStudioProvider extends BaseProvider {
         const toolExecutions = [];
         let step = 0;
         const failedTools = new Map();
-        // Agentic loop for tool calling
-        while (step < maxSteps) {
-            step++;
-            logger.debug(`[GoogleAIStudio] Native SDK generate step ${step}/${maxSteps}`);
-            try {
-                const stream = await client.models.generateContentStream({
-                    model: modelName,
-                    contents: currentContents,
-                    config,
-                });
-                const chunkResult = await this.collectStreamChunks(stream);
-                totalInputTokens = Math.max(totalInputTokens, chunkResult.inputTokens);
-                totalOutputTokens = Math.max(totalOutputTokens, chunkResult.outputTokens);
-                const stepText = this.extractTextFromParts(chunkResult.rawResponseParts);
-                // If no function calls, we're done
-                if (chunkResult.stepFunctionCalls.length === 0) {
-                    finalText = stepText;
+        try {
+            // Agentic loop for tool calling
+            while (step < maxSteps) {
+                if (composedSignal?.aborted) {
                     break;
                 }
-                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
-                currentContents.push({
-                    role: "model",
-                    parts: chunkResult.rawResponseParts.length > 0
-                        ? chunkResult.rawResponseParts
-                        : chunkResult.stepFunctionCalls.map((fc) => ({
-                            functionCall: fc,
-                        })),
-                });
-                const functionResponses = await this.executeNativeToolCalls(chunkResult.stepFunctionCalls, executeMap, failedTools, allToolCalls, toolExecutions);
-                // 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);
+                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;
+                    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 = this.handleMaxStepsTermination(step, maxSteps, finalText, lastStepText);
+        finally {
+            timeoutController?.cleanup();
+        }
+        finalText = handleMaxStepsTermination("[GoogleAIStudio]", step, maxSteps, finalText, lastStepText);
         const responseTime = Date.now() - startTime;
         // Build EnhancedGenerateResult
         return {
@@ -731,10 +752,19 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 (options.tools && Object.keys(options.tools).length > 0));
         if (isGemini3Model(modelName) && hasTools) {
             // Merge SDK tools into options for native SDK path
-            const mergedOptions = {
+            let mergedOptions = {
                 ...options,
                 tools: { ...sdkTools, ...(options.tools || {}) },
             };
+            // Check for tools + JSON schema conflict (Gemini limitation)
+            const wantsJsonOutput = options.output?.format === "json" || options.schema;
+            if (wantsJsonOutput &&
+                mergedOptions.tools &&
+                Object.keys(mergedOptions.tools).length > 0 &&
+                !mergedOptions.disableTools) {
+                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,
@@ -748,227 +778,6 @@ export class GoogleAIStudioProvider extends BaseProvider {
         return super.generate(optionsOrPrompt);
     }
     // ===================
-    // NATIVE GEMINI 3 HELPER METHODS
-    // ===================
-    /**
-     * Convert Vercel AI SDK tools to @google/genai FunctionDeclarations and an execute map.
-     * Shared by executeNativeGemini3Stream and executeNativeGemini3Generate.
-     */
-    buildNativeToolDeclarations(tools) {
-        const functionDeclarations = [];
-        const executeMap = new Map();
-        for (const [name, tool] of Object.entries(tools)) {
-            const decl = {
-                name,
-                description: tool.description || `Tool: ${name}`,
-            };
-            if (tool.parameters) {
-                let rawSchema;
-                if (isZodSchema(tool.parameters)) {
-                    rawSchema = convertZodToJsonSchema(tool.parameters);
-                }
-                else if (typeof tool.parameters === "object") {
-                    rawSchema = tool.parameters;
-                }
-                else {
-                    rawSchema = { type: "object", properties: {} };
-                }
-                decl.parametersJsonSchema = inlineJsonSchema(rawSchema);
-                if (decl.parametersJsonSchema.$schema) {
-                    delete decl.parametersJsonSchema.$schema;
-                }
-            }
-            functionDeclarations.push(decl);
-            if (tool.execute) {
-                executeMap.set(name, tool.execute);
-            }
-        }
-        return { toolsConfig: [{ functionDeclarations }], executeMap };
-    }
-    /**
-     * Build the native @google/genai config object shared by stream and generate.
-     */
-    buildNativeConfig(options, toolsConfig) {
-        const config = {
-            temperature: options.temperature ?? 1.0, // Gemini 3 requires 1.0 for tool calling
-            maxOutputTokens: options.maxTokens,
-        };
-        if (toolsConfig) {
-            config.tools = toolsConfig;
-        }
-        if (options.systemPrompt) {
-            config.systemInstruction = options.systemPrompt;
-        }
-        // Add thinking config for Gemini 3
-        const nativeThinkingConfig = createNativeThinkingConfig(options.thinkingConfig);
-        if (nativeThinkingConfig) {
-            config.thinkingConfig = nativeThinkingConfig;
-        }
-        return config;
-    }
-    /**
-     * Compute a safe, clamped maxSteps value.
-     */
-    computeMaxSteps(rawMaxSteps) {
-        const value = rawMaxSteps || DEFAULT_MAX_STEPS;
-        return Number.isFinite(value) && value > 0
-            ? Math.min(Math.floor(value), 100)
-            : Math.min(DEFAULT_MAX_STEPS, 100);
-    }
-    /**
-     * Process stream chunks to extract raw response parts, function calls, and usage metadata.
-     * Shared by executeNativeGemini3Stream and executeNativeGemini3Generate.
-     */
-    async collectStreamChunks(stream) {
-        const rawResponseParts = [];
-        const stepFunctionCalls = [];
-        let inputTokens = 0;
-        let outputTokens = 0;
-        for await (const chunk of stream) {
-            // Extract raw parts from candidates FIRST
-            // This avoids using chunk.text which triggers SDK warning when
-            // non-text parts (thoughtSignature, functionCall) are present
-            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);
-            }
-            // Accumulate usage metadata from chunks
-            const usage = chunkRecord.usageMetadata;
-            if (usage) {
-                inputTokens = Math.max(inputTokens, usage.promptTokenCount || 0);
-                outputTokens = Math.max(outputTokens, usage.candidatesTokenCount || 0);
-            }
-        }
-        return { rawResponseParts, stepFunctionCalls, inputTokens, outputTokens };
-    }
-    /**
-     * Extract text from raw response parts. Used after collectStreamChunks.
-     */
-    extractTextFromParts(rawResponseParts) {
-        return rawResponseParts
-            .filter((part) => typeof part.text === "string")
-            .map((part) => part.text)
-            .join("");
-    }
-    /**
-     * Execute a batch of function calls with retry tracking and permanent failure detection.
-     * Shared by executeNativeGemini3Stream and executeNativeGemini3Generate.
-     *
-     * Returns function responses for history and optional tool execution records for generate.
-     */
-    async executeNativeToolCalls(stepFunctionCalls, executeMap, failedTools, allToolCalls, toolExecutions) {
-        const functionResponses = [];
-        for (const call of stepFunctionCalls) {
-            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(`[GoogleAIStudio] 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,
-                };
-                functionResponses.push({
-                    functionResponse: { name: call.name, response: errorOutput },
-                });
-                toolExecutions?.push({
-                    name: call.name,
-                    input: call.args,
-                    output: errorOutput,
-                });
-                continue;
-            }
-            const execute = executeMap.get(call.name);
-            if (execute) {
-                try {
-                    // AI SDK Tool execute requires (args, options) - provide minimal options
-                    const toolOptions = {
-                        toolCallId: `${call.name}-${Date.now()}`,
-                        messages: [],
-                        abortSignal: undefined,
-                    };
-                    const result = await execute(call.args, toolOptions);
-                    functionResponses.push({
-                        functionResponse: { name: call.name, response: { result } },
-                    });
-                    toolExecutions?.push({
-                        name: call.name,
-                        input: call.args,
-                        output: result,
-                    });
-                }
-                catch (error) {
-                    const errorMessage = error instanceof Error ? error.message : "Unknown error";
-                    // Track this failure
-                    const currentFailInfo = failedTools.get(call.name) || {
-                        count: 0,
-                        lastError: "",
-                    };
-                    currentFailInfo.count++;
-                    currentFailInfo.lastError = errorMessage;
-                    failedTools.set(call.name, currentFailInfo);
-                    logger.warn(`[GoogleAIStudio] Tool "${call.name}" failed (attempt ${currentFailInfo.count}/${DEFAULT_TOOL_MAX_RETRIES}): ${errorMessage}`);
-                    // Determine if this is a permanent failure
-                    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,
-                    };
-                    functionResponses.push({
-                        functionResponse: { name: call.name, response: errorOutput },
-                    });
-                    toolExecutions?.push({
-                        name: call.name,
-                        input: call.args,
-                        output: 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,
-                };
-                functionResponses.push({
-                    functionResponse: { name: call.name, response: errorOutput },
-                });
-                toolExecutions?.push({
-                    name: call.name,
-                    input: call.args,
-                    output: errorOutput,
-                });
-            }
-        }
-        return functionResponses;
-    }
-    /**
-     * Handle maxSteps termination by producing a final text when the model
-     * was still calling tools when the step limit was reached.
-     */
-    handleMaxStepsTermination(step, maxSteps, finalText, lastStepText) {
-        if (step >= maxSteps && !finalText) {
-            logger.warn(`[GoogleAIStudio] 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;
-    }
-    // ===================
     // HELPER METHODS
     // ===================
     async executeAudioStreamViaGeminiLive(options) {

package/dist/lib/providers/googleNativeGemini3.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Shared utilities for Gemini 3 native SDK support.
+ *
+ * Both GoogleAIStudioProvider and GoogleVertexProvider route Gemini 3 models
+ * with tools to the native @google/genai SDK (bypassing the Vercel AI SDK)
+ * in order to properly handle thought_signature in multi-turn tool calling.
+ *
+ * This module extracts the functions that are duplicated between the two
+ * providers so they can share a single implementation.
+ */
+import type { Tool } from "ai";
+import type { ThinkingConfig } from "../utils/thinkingConfig.js";
+/** A single native @google/genai function declaration. */
+export type NativeFunctionDeclaration = {
+    name: string;
+    description: string;
+    parametersJsonSchema?: Record<string, unknown>;
+};
+/** The tools config array expected by the @google/genai SDK. */
+export type NativeToolsConfig = Array<{
+    functionDeclarations: NativeFunctionDeclaration[];
+}>;
+/** Return value of buildNativeToolDeclarations. */
+export type NativeToolDeclarationsResult = {
+    toolsConfig: NativeToolsConfig;
+    executeMap: Map<string, Tool["execute"]>;
+};
+/** A single function call returned by the Gemini model. */
+export type NativeFunctionCall = {
+    name: string;
+    args: Record<string, unknown>;
+};
+/** A single function response to feed back into the conversation. */
+export type NativeFunctionResponse = {
+    functionResponse: {
+        name: string;
+        response: unknown;
+    };
+};
+/** Result from collectStreamChunks. */
+export type CollectedChunkResult = {
+    rawResponseParts: unknown[];
+    stepFunctionCalls: NativeFunctionCall[];
+    inputTokens: number;
+    outputTokens: number;
+};
+/**
+ * Convert Vercel AI SDK tools to @google/genai FunctionDeclarations and an execute map.
+ *
+ * This handles both Zod schemas and plain JSON Schema objects for tool parameters.
+ */
+export declare function buildNativeToolDeclarations(tools: Record<string, Tool>): NativeToolDeclarationsResult;
+/**
+ * Build the native @google/genai config object shared by stream and generate.
+ */
+export declare function buildNativeConfig(options: {
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+    thinkingConfig?: ThinkingConfig;
+}, toolsConfig?: NativeToolsConfig): Record<string, unknown>;
+/**
+ * Compute a safe, clamped maxSteps value.
+ */
+export declare function computeMaxSteps(rawMaxSteps?: number): number;
+/**
+ * Process stream chunks to extract raw response parts, function calls, and usage metadata.
+ *
+ * Consumes the full async iterable and returns all collected data.
+ */
+export declare function collectStreamChunks(stream: AsyncIterable<{
+    functionCalls?: NativeFunctionCall[];
+    [key: string]: unknown;
+}>): Promise<CollectedChunkResult>;
+/**
+ * Extract text from raw response parts, filtering out non-text parts
+ * (thoughtSignature, functionCall) to avoid SDK warnings.
+ */
+export declare function extractTextFromParts(rawResponseParts: unknown[]): string;
+/**
+ * Execute a batch of native function calls with retry tracking and permanent failure detection.
+ *
+ * @param logLabel - Label for log messages (e.g. "[GoogleAIStudio]" or "[GoogleVertex]")
+ * @param stepFunctionCalls - The function calls from the model
+ * @param executeMap - Map of tool name to execute function
+ * @param failedTools - Mutable map tracking per-tool failure counts
+ * @param allToolCalls - Mutable array accumulating all tool call records
+ * @param options - Optional settings for execution tracking and cancellation
+ * @returns Array of function responses for conversation history
+ */
+export declare function executeNativeToolCalls(logLabel: string, stepFunctionCalls: NativeFunctionCall[], executeMap: Map<string, Tool["execute"]>, failedTools: Map<string, {
+    count: number;
+    lastError: string;
+}>, allToolCalls: Array<{
+    toolName: string;
+    args: Record<string, unknown>;
+}>, options?: {
+    toolExecutions?: Array<{
+        name: string;
+        input: Record<string, unknown>;
+        output: unknown;
+    }>;
+    abortSignal?: AbortSignal;
+}): Promise<NativeFunctionResponse[]>;
+/**
+ * Handle maxSteps termination by producing a final text when the model
+ * was still calling tools when the step limit was reached.
+ *
+ * @param logLabel - Label for log messages (e.g. "[GoogleAIStudio]" or "[GoogleVertex]")
+ */
+export declare function handleMaxStepsTermination(logLabel: string, step: number, maxSteps: number, finalText: string, lastStepText: string): string;
+/**
+ * Push model response parts to conversation history, preserving thoughtSignature
+ * for Gemini 3 multi-turn tool calling.
+ */
+export declare function pushModelResponseToHistory(currentContents: Array<{
+    role: string;
+    parts: unknown[];
+}>, rawResponseParts: unknown[], stepFunctionCalls: NativeFunctionCall[]): void;