@juspay/neurolink 9.5.3 → 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
@@ -510,240 +519,79 @@ export class GoogleAIStudioProvider extends BaseProvider {
             hasTools: !!options.tools && Object.keys(options.tools).length > 0,
         });
         // Build contents from input
-        const contents = [];
-        contents.push({
-            role: "user",
-            parts: [{ text: options.input.text }],
-        });
-        let tools;
-        const executeMap = new Map();
+        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 functionDeclarations = [];
-            for (const [name, tool] of Object.entries(options.tools)) {
-                const decl = {
-                    name,
-                    description: tool.description || `Tool: ${name}`,
-                };
-                if (tool.parameters) {
-                    let rawSchema;
-                    if (isZodSchema(tool.parameters)) {
-                        // It's a Zod schema - convert it
-                        rawSchema = convertZodToJsonSchema(tool.parameters);
-                    }
-                    else if (typeof tool.parameters === "object") {
-                        // Already JSON schema (jsonSchema() wrapper) - use directly
-                        rawSchema = tool.parameters;
-                    }
-                    else {
-                        rawSchema = { type: "object", properties: {} };
-                    }
-                    decl.parametersJsonSchema = inlineJsonSchema(rawSchema);
-                    // Remove $schema if present - @google/genai doesn't need it
-                    if (decl.parametersJsonSchema.$schema) {
-                        delete decl.parametersJsonSchema.$schema;
-                    }
-                }
-                functionDeclarations.push(decl);
-                if (tool.execute) {
-                    executeMap.set(name, tool.execute);
-                }
-            }
-            tools = [{ functionDeclarations }];
+            const result = buildNativeToolDeclarations(options.tools);
+            toolsConfig = result.toolsConfig;
+            executeMap = result.executeMap;
             logger.debug("[GoogleAIStudio] Converted tools for native SDK", {
-                toolCount: functionDeclarations.length,
-                toolNames: functionDeclarations.map((t) => t.name),
+                toolCount: toolsConfig[0].functionDeclarations.length,
+                toolNames: toolsConfig[0].functionDeclarations.map((t) => t.name),
             });
         }
-        // Build config
-        const config = {
-            temperature: options.temperature ?? 1.0, // Gemini 3 requires 1.0 for tool calling
-            maxOutputTokens: options.maxTokens,
-        };
-        if (tools) {
-            config.tools = tools;
-        }
-        if (options.systemPrompt) {
-            config.systemInstruction = options.systemPrompt;
-        }
-        // Add thinking config for Gemini 3
-        const nativeThinkingConfig = createNativeThinkingConfig(options.thinkingConfig);
-        if (nativeThinkingConfig) {
-            config.thinkingConfig = nativeThinkingConfig;
-        }
-        // Ensure maxSteps is a valid positive integer to prevent infinite loops
-        const rawMaxSteps = options.maxSteps || DEFAULT_MAX_STEPS;
-        const maxSteps = Number.isFinite(rawMaxSteps) && rawMaxSteps > 0
-            ? Math.min(Math.floor(rawMaxSteps), 100) // Cap at 100 for safety
-            : Math.min(DEFAULT_MAX_STEPS, 100);
-        const currentContents = [...contents];
+        const config = buildNativeConfig(options, toolsConfig);
+        const maxSteps = computeMaxSteps(options.maxSteps);
         let finalText = "";
-        let lastStepText = ""; // Track text from last step for maxSteps termination
+        let lastStepText = "";
         let totalInputTokens = 0;
         let totalOutputTokens = 0;
         const allToolCalls = [];
         let step = 0;
-        // Track failed tools to prevent infinite retry loops
-        // Key: tool name, Value: { count: retry attempts, lastError: error message }
         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 stepFunctionCalls = [];
-                // Capture all raw parts including thoughtSignature for history
-                const rawResponseParts = [];
-                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) {
-                        totalInputTokens = Math.max(totalInputTokens, usage.promptTokenCount || 0);
-                        totalOutputTokens = Math.max(totalOutputTokens, usage.candidatesTokenCount || 0);
-                    }
-                }
-                // Extract text from raw parts after stream completes
-                // This avoids SDK warning about non-text parts (thoughtSignature, functionCall)
-                const stepText = rawResponseParts
-                    .filter((part) => typeof part.text === "string")
-                    .map((part) => part.text)
-                    .join("");
-                // If no function calls, we're done
-                if (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;
                 }
-                // Track the last step text for maxSteps termination
-                lastStepText = stepText;
-                // Execute function calls
-                logger.debug(`[GoogleAIStudio] Executing ${stepFunctionCalls.length} function calls`);
-                // Add model response with ALL parts (including thoughtSignature) to history
-                currentContents.push({
-                    role: "model",
-                    parts: rawResponseParts.length > 0
-                        ? rawResponseParts
-                        : stepFunctionCalls.map((fc) => ({
-                            functionCall: fc,
-                        })),
-                });
-                // Execute each function and collect responses
-                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`);
-                        functionResponses.push({
-                            functionResponse: {
-                                name: call.name,
-                                response: {
-                                    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,
-                                },
-                            },
-                        });
-                        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 } },
-                            });
-                        }
-                        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;
-                            functionResponses.push({
-                                functionResponse: {
-                                    name: call.name,
-                                    response: {
-                                        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,
-                                    },
-                                },
-                            });
-                        }
-                    }
-                    else {
-                        // Tool not found is a permanent error
-                        functionResponses.push({
-                            functionResponse: {
-                                name: call.name,
-                                response: {
-                                    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,
-                                },
-                            },
-                        });
+                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);
                 }
-                // 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();
-        // Handle maxSteps termination - if we exited the loop due to maxSteps being reached
-        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.`);
-            finalText =
-                lastStepText ||
-                    `[Tool execution limit reached after ${maxSteps} steps. The model continued requesting tool calls beyond the limit.]`;
+        finally {
+            timeoutController?.cleanup();
         }
+        finalText = handleMaxStepsTermination("[GoogleAIStudio]", step, maxSteps, finalText, lastStepText);
         const responseTime = Date.now() - startTime;
         // Create async iterable for streaming result
         async function* createTextStream() {
@@ -789,265 +637,87 @@ export class GoogleAIStudioProvider extends BaseProvider {
             hasTools: !!options.tools && Object.keys(options.tools).length > 0,
         });
         // Build contents from input
-        const contents = [];
         const promptText = options.prompt || options.input?.text || "";
-        contents.push({
-            role: "user",
-            parts: [{ text: promptText }],
-        });
-        let tools;
-        const executeMap = new Map();
-        const allToolsForResult = {};
-        // Merge SDK tools with options.tools
+        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 functionDeclarations = [];
-                for (const [name, tool] of Object.entries(mergedTools)) {
-                    allToolsForResult[name] = tool;
-                    const decl = {
-                        name,
-                        description: tool.description || `Tool: ${name}`,
-                    };
-                    if (tool.parameters) {
-                        let rawSchema;
-                        if (isZodSchema(tool.parameters)) {
-                            // It's a Zod schema - convert it
-                            rawSchema = convertZodToJsonSchema(tool.parameters);
-                        }
-                        else if (typeof tool.parameters === "object") {
-                            // Already JSON schema (jsonSchema() wrapper) - use directly
-                            rawSchema = tool.parameters;
-                        }
-                        else {
-                            rawSchema = { type: "object", properties: {} };
-                        }
-                        decl.parametersJsonSchema = inlineJsonSchema(rawSchema);
-                        // Remove $schema if present - @google/genai doesn't need it
-                        if (decl.parametersJsonSchema.$schema) {
-                            delete decl.parametersJsonSchema.$schema;
-                        }
-                    }
-                    functionDeclarations.push(decl);
-                    if (tool.execute) {
-                        executeMap.set(name, tool.execute);
-                    }
-                }
-                tools = [{ functionDeclarations }];
+                const result = buildNativeToolDeclarations(mergedTools);
+                toolsConfig = result.toolsConfig;
+                executeMap = result.executeMap;
                 logger.debug("[GoogleAIStudio] Converted tools for native SDK generate", {
-                    toolCount: functionDeclarations.length,
-                    toolNames: functionDeclarations.map((t) => t.name),
+                    toolCount: toolsConfig[0].functionDeclarations.length,
+                    toolNames: toolsConfig[0].functionDeclarations.map((t) => t.name),
                 });
             }
         }
-        // Build config
-        const config = {
-            temperature: options.temperature ?? 1.0, // Gemini 3 requires 1.0 for tool calling
-            maxOutputTokens: options.maxTokens,
-        };
-        if (tools) {
-            config.tools = tools;
-        }
-        if (options.systemPrompt) {
-            config.systemInstruction = options.systemPrompt;
-        }
+        const config = buildNativeConfig(options, toolsConfig);
         const startTime = Date.now();
-        // Ensure maxSteps is a valid positive integer to prevent infinite loops
-        const rawMaxSteps = options.maxSteps || DEFAULT_MAX_STEPS;
-        const maxSteps = Number.isFinite(rawMaxSteps) && rawMaxSteps > 0
-            ? Math.min(Math.floor(rawMaxSteps), 100) // Cap at 100 for safety
-            : Math.min(DEFAULT_MAX_STEPS, 100);
-        const currentContents = [...contents];
+        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 = ""; // Track text from last step for maxSteps termination
+        let lastStepText = "";
         let totalInputTokens = 0;
         let totalOutputTokens = 0;
         const allToolCalls = [];
         const toolExecutions = [];
         let step = 0;
-        // Track failed tools to prevent infinite retry loops
-        // Key: tool name, Value: { count: retry attempts, lastError: error message }
         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 stepFunctionCalls = [];
-                // Capture all raw parts including thoughtSignature for history
-                const rawResponseParts = [];
-                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) {
-                        totalInputTokens = Math.max(totalInputTokens, usage.promptTokenCount || 0);
-                        totalOutputTokens = Math.max(totalOutputTokens, usage.candidatesTokenCount || 0);
-                    }
-                }
-                // Extract text from raw parts after stream completes
-                // This avoids SDK warning about non-text parts (thoughtSignature, functionCall)
-                const stepText = rawResponseParts
-                    .filter((part) => typeof part.text === "string")
-                    .map((part) => part.text)
-                    .join("");
-                // If no function calls, we're done
-                if (stepFunctionCalls.length === 0) {
-                    finalText = stepText;
+        try {
+            // Agentic loop for tool calling
+            while (step < maxSteps) {
+                if (composedSignal?.aborted) {
                     break;
                 }
-                // Track the last step text for maxSteps termination
-                lastStepText = stepText;
-                // Execute function calls
-                logger.debug(`[GoogleAIStudio] Executing ${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: rawResponseParts.length > 0
-                        ? rawResponseParts
-                        : stepFunctionCalls.map((fc) => ({
-                            functionCall: fc,
-                        })),
-                });
-                // Execute each function and collect responses
-                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,
-                        });
+                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);
                 }
-                // 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);
             }
         }
-        // Handle maxSteps termination - if we exited the loop due to maxSteps being reached
-        if (step >= maxSteps && !finalText) {
-            logger.warn(`[GoogleAIStudio] Generate tool call loop terminated after reaching maxSteps (${maxSteps}). ` +
-                `Model was still calling tools. Using accumulated text from last step.`);
-            finalText =
-                lastStepText ||
-                    `[Tool execution limit reached after ${maxSteps} steps. The model continued requesting tool calls beyond the limit.]`;
+        finally {
+            timeoutController?.cleanup();
         }
+        finalText = handleMaxStepsTermination("[GoogleAIStudio]", step, maxSteps, finalText, lastStepText);
         const responseTime = Date.now() - startTime;
         // Build EnhancedGenerateResult
         return {
@@ -1082,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,