@juspay/neurolink 9.30.0 → 9.31.0

package/dist/providers/anthropic.js

@@ -1,5 +1,5 @@
 import { createAnthropic } from "@ai-sdk/anthropic";
-import { streamText } from "ai";
+import { stepCountIs, streamText } from "ai";
 import { trace, SpanKind, SpanStatusCode } from "@opentelemetry/api";
 import { AnthropicModels } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
@@ -11,11 +11,13 @@ import { calculateCost } from "../utils/pricing.js";
 import { createAnthropicConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { isModelAvailableForTier, getRecommendedModelForTier, getModelCapabilities, } from "../models/anthropicModels.js";
-import { CLAUDE_CLI_USER_AGENT, CLAUDE_CODE_CLIENT_ID, ANTHROPIC_TOKEN_URL, MCP_TOOL_PREFIX, } from "../auth/anthropicOAuth.js";
+import { CLAUDE_CLI_USER_AGENT, CLAUDE_CODE_CLIENT_ID, ANTHROPIC_TOKEN_URL, } from "../auth/anthropicOAuth.js";
+import { createOAuthFetch } from "../proxy/oauthFetch.js";
 import { homedir } from "os";
 import { readFileSync, existsSync, writeFileSync, mkdirSync, renameSync, } from "fs";
 import { join } from "path";
 import { TOKEN_EXPIRY_BUFFER_MS } from "../constants/enums.js";
+import { getModelId } from "./providerTypeUtils.js";
 /**
  * Beta headers for Claude Code integration.
  * These enable experimental features:
@@ -30,184 +32,6 @@ const ANTHROPIC_BETA_HEADERS = {
         "fine-grained-tool-streaming-2025-05-14",
     ].join(","),
 };
-/**
- * Creates a custom fetch function for OAuth-authenticated requests.
- * This wrapper applies all required transformations for OAuth mode:
- * - Uses Authorization: Bearer header (NOT x-api-key)
- * - Adds OAuth-required beta headers (oauth-2025-04-20 is critical)
- * - Sets User-Agent to Claude CLI
- * - Adds ?beta=true query parameter to /v1/messages
- * - Prefixes tool names with mcp_
- * - Strips mcp_ prefix from tool names in responses
- *
- * Accepts a getter function instead of a static token so that refreshed
- * tokens are picked up automatically on each request.
- */
-function createOAuthFetch(getToken, includeOptionalBetas = true) {
-    return async (input, init) => {
-        // Build the URL
-        let requestUrl = null;
-        try {
-            if (typeof input === "string" || input instanceof URL) {
-                requestUrl = new URL(input.toString());
-            }
-            else if (input instanceof Request) {
-                requestUrl = new URL(input.url);
-            }
-        }
-        catch {
-            requestUrl = null;
-        }
-        // Add ?beta=true to /v1/messages endpoint
-        if (requestUrl &&
-            requestUrl.pathname === "/v1/messages" &&
-            !requestUrl.searchParams.has("beta")) {
-            requestUrl.searchParams.set("beta", "true");
-        }
-        // Build new headers
-        const requestHeaders = new Headers();
-        // Copy headers from Request object if present
-        if (input instanceof Request) {
-            input.headers.forEach((value, key) => {
-                requestHeaders.set(key, value);
-            });
-        }
-        // Copy headers from init if present
-        if (init?.headers) {
-            if (init.headers instanceof Headers) {
-                init.headers.forEach((value, key) => {
-                    requestHeaders.set(key, value);
-                });
-            }
-            else if (Array.isArray(init.headers)) {
-                for (const [key, value] of init.headers) {
-                    if (typeof value !== "undefined") {
-                        requestHeaders.set(key, String(value));
-                    }
-                }
-            }
-            else {
-                for (const [key, value] of Object.entries(init.headers)) {
-                    if (typeof value !== "undefined") {
-                        requestHeaders.set(key, String(value));
-                    }
-                }
-            }
-        }
-        // Check if claude-code beta was requested
-        const incomingBeta = requestHeaders.get("anthropic-beta") || "";
-        const incomingBetasList = incomingBeta
-            .split(",")
-            .map((b) => b.trim())
-            .filter(Boolean);
-        const includeClaudeCode = incomingBetasList.includes("claude-code-20250219");
-        // Merge beta headers — oauth-2025-04-20 is always required for OAuth;
-        // optional betas (interleaved-thinking) gated on includeOptionalBetas.
-        const mergedBetas = [
-            "oauth-2025-04-20",
-            ...(includeOptionalBetas ? ["interleaved-thinking-2025-05-14"] : []),
-            ...(includeClaudeCode ? ["claude-code-20250219"] : []),
-        ].join(",");
-        // Set OAuth authorization (Bearer token, NOT x-api-key)
-        // Call getToken() each time so refreshed tokens are used automatically.
-        requestHeaders.set("authorization", `Bearer ${getToken()}`);
-        requestHeaders.set("anthropic-beta", mergedBetas);
-        requestHeaders.set("user-agent", CLAUDE_CLI_USER_AGENT);
-        requestHeaders.delete("x-api-key");
-        logger.debug("[createOAuthFetch] Making OAuth request:", {
-            url: requestUrl?.toString() || input.toString(),
-            hasAuthorization: requestHeaders.has("authorization"),
-            authType: "Bearer",
-            anthropicBeta: requestHeaders.get("anthropic-beta"),
-            userAgent: requestHeaders.get("user-agent"),
-        });
-        // Add mcp_ prefix to tool names in request body
-        let body = init?.body;
-        if (body && typeof body === "string") {
-            try {
-                const parsed = JSON.parse(body);
-                // Add prefix to tools definitions
-                if (parsed.tools && Array.isArray(parsed.tools)) {
-                    parsed.tools = parsed.tools.map((tool) => ({
-                        ...tool,
-                        name: tool.name ? `${MCP_TOOL_PREFIX}${tool.name}` : tool.name,
-                    }));
-                }
-                // Add prefix to tool_use blocks in messages
-                if (parsed.messages && Array.isArray(parsed.messages)) {
-                    parsed.messages = parsed.messages.map((msg) => {
-                        if (msg.content && Array.isArray(msg.content)) {
-                            msg.content = msg.content.map((block) => {
-                                const b = block;
-                                if (b.type === "tool_use" && b.name) {
-                                    return {
-                                        ...b,
-                                        name: `${MCP_TOOL_PREFIX}${b.name}`,
-                                    };
-                                }
-                                return block;
-                            });
-                        }
-                        return msg;
-                    });
-                }
-                body = JSON.stringify(parsed);
-            }
-            catch {
-                // Ignore JSON parse errors
-            }
-        }
-        // Make the request
-        const response = await fetch(requestUrl?.toString() ||
-            (input instanceof Request ? input.url : input.toString()), {
-            ...init,
-            body,
-            headers: requestHeaders,
-        });
-        // Transform streaming response to rename tools back (remove mcp_ prefix).
-        // Uses a small carry buffer to handle cross-chunk boundary splits of
-        // `"name": "mcp_..."` patterns.
-        if (response.body) {
-            const reader = response.body.getReader();
-            const decoder = new TextDecoder();
-            const encoder = new TextEncoder();
-            // Carry tail covers the longest possible partial match: `"name": "mcp_`
-            const CARRY_TAIL = 24;
-            let carry = "";
-            const stream = new ReadableStream({
-                async pull(controller) {
-                    const { done, value } = await reader.read();
-                    if (done) {
-                        // Flush any remaining carry
-                        if (carry) {
-                            const flushed = carry.replace(/"name"\s*:\s*"mcp_([^"]+)"/g, '"name": "$1"');
-                            controller.enqueue(encoder.encode(flushed));
-                            carry = "";
-                        }
-                        controller.close();
-                        return;
-                    }
-                    const chunkText = decoder.decode(value, { stream: true });
-                    const combined = carry + chunkText;
-                    const replaced = combined.replace(/"name"\s*:\s*"mcp_([^"]+)"/g, '"name": "$1"');
-                    // Keep a small tail as carry to cover partial matches at chunk boundary
-                    const safeLen = Math.max(0, replaced.length - CARRY_TAIL);
-                    carry = replaced.slice(safeLen);
-                    const toEmit = replaced.slice(0, safeLen);
-                    if (toEmit) {
-                        controller.enqueue(encoder.encode(toEmit));
-                    }
-                },
-            });
-            return new Response(stream, {
-                status: response.status,
-                statusText: response.statusText,
-                headers: response.headers,
-            });
-        }
-        return response;
-    };
-}
 // Configuration helpers - now using consolidated utility
 const getAnthropicApiKey = () => {
     return validateApiKey(createAnthropicConfig());
@@ -418,7 +242,14 @@ export class AnthropicProvider extends BaseProvider {
             // even after an automatic token refresh.
             // oauthToken is guaranteed non-null here (checked by the enclosing if-guard).
             const tokenRef = this.oauthToken;
-            const oauthFetch = createOAuthFetch(() => tokenRef.accessToken, this.enableBetaFeatures);
+            // skipBodyTransform=true: For the SDK provider path, body transforms ARE
+            // intentionally skipped because the Vercel AI SDK builds its own request
+            // format (system prompts, metadata, tool definitions). The billing header,
+            // agent block, user_id injection, and mcp_ tool-name prefixing are only
+            // needed for proxy passthrough of raw Claude API requests where we must
+            // make the request look like it came from Claude Code / CLIProxyAPI.
+            const oauthFetch = createOAuthFetch(() => tokenRef.accessToken, this.enableBetaFeatures, false, // No mcp_ prefix — tool names pass through as-is (matches CLIProxyAPI)
+            true);
             // For OAuth, we use a dummy API key since our fetch wrapper handles auth
             // IMPORTANT: Do NOT pass beta headers here - our fetch wrapper handles them
             // The claude-code-20250219 beta header triggers "credential only for Claude Code" error
@@ -886,7 +717,7 @@ export class AnthropicProvider extends BaseProvider {
                 kind: SpanKind.CLIENT,
                 attributes: {
                     "gen_ai.system": "anthropic",
-                    "gen_ai.request.model": model.modelId || this.modelName || "unknown",
+                    "gen_ai.request.model": getModelId(model, this.modelName || "unknown"),
                 },
             });
             let result;
@@ -895,10 +726,10 @@ export class AnthropicProvider extends BaseProvider {
                     model: model,
                     messages: messages,
                     temperature: options.temperature,
-                    maxTokens: options.maxTokens, // No default limit - unlimited unless specified
+                    maxOutputTokens: options.maxTokens, // No default limit - unlimited unless specified
                     maxRetries: 0, // NL11: Disable AI SDK's invisible internal retries; we handle retries with OTel instrumentation
                     tools,
-                    maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
+                    stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
                     toolChoice: shouldUseTools ? "auto" : "none",
                     abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                     experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
@@ -918,14 +749,14 @@ export class AnthropicProvider extends BaseProvider {
             }
             // Collect token usage and finish reason asynchronously when the stream completes,
             // then end the span. This avoids blocking the stream consumer.
-            result.usage
+            Promise.resolve(result.usage)
                 .then((usage) => {
-                streamSpan.setAttribute("gen_ai.usage.input_tokens", usage.promptTokens || 0);
-                streamSpan.setAttribute("gen_ai.usage.output_tokens", usage.completionTokens || 0);
+                streamSpan.setAttribute("gen_ai.usage.input_tokens", usage.inputTokens || 0);
+                streamSpan.setAttribute("gen_ai.usage.output_tokens", usage.outputTokens || 0);
                 const cost = calculateCost(this.providerName, this.modelName, {
-                    input: usage.promptTokens || 0,
-                    output: usage.completionTokens || 0,
-                    total: (usage.promptTokens || 0) + (usage.completionTokens || 0),
+                    input: usage.inputTokens || 0,
+                    output: usage.outputTokens || 0,
+                    total: (usage.inputTokens || 0) + (usage.outputTokens || 0),
                 });
                 if (cost && cost > 0) {
                     streamSpan.setAttribute("neurolink.cost", cost);
@@ -934,7 +765,7 @@ export class AnthropicProvider extends BaseProvider {
                 .catch(() => {
                 // Usage may not be available if the stream is aborted
             });
-            result.finishReason
+            Promise.resolve(result.finishReason)
                 .then((reason) => {
                 streamSpan.setAttribute("gen_ai.response.finish_reason", reason || "unknown");
             })
@@ -942,7 +773,7 @@ export class AnthropicProvider extends BaseProvider {
                 // Finish reason may not be available if the stream is aborted
             });
             // End the span when the stream text resolves (stream fully consumed)
-            result.text
+            Promise.resolve(result.text)
                 .then(() => {
                 streamSpan.end();
             })

package/dist/providers/anthropicBaseProvider.d.ts

@@ -1,5 +1,5 @@
-import type { ZodType, ZodTypeDef } from "zod";
-import { type Schema, type LanguageModelV1 } from "ai";
+import type { ZodType } from "zod";
+import { type LanguageModel, type Schema } from "ai";
 import { AIProviderName } from "../constants/enums.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
@@ -15,9 +15,9 @@ export declare class AnthropicProviderV2 extends BaseProvider {
     /**
      * Returns the Vercel AI SDK model instance for Anthropic
      */
-    protected getAISDKModel(): LanguageModelV1;
+    protected getAISDKModel(): LanguageModel;
     protected formatProviderError(error: unknown): Error;
     private getApiKey;
-    protected executeStream(options: StreamOptions, _analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    protected executeStream(options: StreamOptions, _analysisSchema?: ZodType | Schema<unknown>): Promise<StreamResult>;
 }
 export default AnthropicProviderV2;

package/dist/providers/anthropicBaseProvider.js

@@ -1,5 +1,5 @@
 import { createAnthropic } from "@ai-sdk/anthropic";
-import { streamText } from "ai";
+import { NoOutputGeneratedError, streamText, } from "ai";
 import { trace, SpanKind, SpanStatusCode } from "@opentelemetry/api";
 import { AIProviderName, AnthropicModels } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
@@ -8,6 +8,7 @@ import { logger } from "../utils/logger.js";
 import { calculateCost } from "../utils/pricing.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { validateApiKey, createAnthropicBaseConfig, } from "../utils/providerConfig.js";
+import { getModelId } from "./providerTypeUtils.js";
 const streamTracer = trace.getTracer("neurolink.provider.anthropic");
 /**
  * Anthropic provider implementation using BaseProvider pattern
@@ -76,7 +77,7 @@ export class AnthropicProviderV2 extends BaseProvider {
                 kind: SpanKind.CLIENT,
                 attributes: {
                     "gen_ai.system": "anthropic",
-                    "gen_ai.request.model": model.modelId || this.modelName || "unknown",
+                    "gen_ai.request.model": getModelId(model, this.modelName || "unknown"),
                 },
             });
             let result;
@@ -86,7 +87,7 @@ export class AnthropicProviderV2 extends BaseProvider {
                     prompt: options.input.text,
                     system: options.systemPrompt,
                     temperature: options.temperature,
-                    maxTokens: options.maxTokens, // No default limit - unlimited unless specified
+                    maxOutputTokens: options.maxTokens, // No default limit - unlimited unless specified
                     maxRetries: 0, // NL11: Disable AI SDK's invisible internal retries; we handle retries with OTel instrumentation
                     tools,
                     toolChoice: shouldUseTools ? "auto" : "none",
@@ -113,14 +114,14 @@ export class AnthropicProviderV2 extends BaseProvider {
             }
             // Collect token usage and finish reason asynchronously when the stream completes,
             // then end the span. This avoids blocking the stream consumer.
-            result.usage
+            Promise.resolve(result.usage)
                 .then((usage) => {
-                streamSpan.setAttribute("gen_ai.usage.input_tokens", usage.promptTokens || 0);
-                streamSpan.setAttribute("gen_ai.usage.output_tokens", usage.completionTokens || 0);
+                streamSpan.setAttribute("gen_ai.usage.input_tokens", usage.inputTokens || 0);
+                streamSpan.setAttribute("gen_ai.usage.output_tokens", usage.outputTokens || 0);
                 const cost = calculateCost(this.providerName, this.modelName, {
-                    input: usage.promptTokens || 0,
-                    output: usage.completionTokens || 0,
-                    total: (usage.promptTokens || 0) + (usage.completionTokens || 0),
+                    input: usage.inputTokens || 0,
+                    output: usage.outputTokens || 0,
+                    total: (usage.inputTokens || 0) + (usage.outputTokens || 0),
                 });
                 if (cost && cost > 0) {
                     streamSpan.setAttribute("neurolink.cost", cost);
@@ -129,14 +130,14 @@ export class AnthropicProviderV2 extends BaseProvider {
                 .catch(() => {
                 // Usage may not be available if the stream is aborted
             });
-            result.finishReason
+            Promise.resolve(result.finishReason)
                 .then((reason) => {
                 streamSpan.setAttribute("gen_ai.response.finish_reason", reason || "unknown");
             })
                 .catch(() => {
                 // Finish reason may not be available if the stream is aborted
             });
-            result.text
+            Promise.resolve(result.text)
                 .then(() => {
                 streamSpan.end();
             })
@@ -150,8 +151,18 @@ export class AnthropicProviderV2 extends BaseProvider {
             timeoutController?.cleanup();
             // Transform string stream to content object stream (match Google AI pattern)
             const transformedStream = async function* () {
-                for await (const chunk of result.textStream) {
-                    yield { content: chunk };
+                try {
+                    for await (const chunk of result.textStream) {
+                        yield { content: chunk };
+                    }
+                }
+                catch (streamError) {
+                    // AI SDK v6 throws NoOutputGeneratedError when the stream produced no output.
+                    if (NoOutputGeneratedError.isInstance(streamError)) {
+                        logger.warn("AnthropicBaseProvider: Stream produced no output (NoOutputGeneratedError)");
+                        return;
+                    }
+                    throw streamError;
                 }
             };
             return {

package/dist/providers/azureOpenai.d.ts

@@ -1,4 +1,4 @@
-import { type LanguageModelV1 } from "ai";
+import { type LanguageModel } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 import { AIProviderName } from "../constants/enums.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
@@ -14,7 +14,7 @@ export declare class AzureOpenAIProvider extends BaseProvider {
     /**
      * Returns the Vercel AI SDK model instance for Azure OpenAI
      */
-    getAISDKModel(): LanguageModelV1;
+    getAISDKModel(): LanguageModel;
     protected formatProviderError(error: unknown): Error;
     protected executeStream(options: StreamOptions, _analysisSchema?: unknown): Promise<StreamResult>;
 }

package/dist/providers/azureOpenai.js

@@ -1,11 +1,11 @@
 import { createAzure } from "@ai-sdk/azure";
-import { streamText } from "ai";
+import { stepCountIs, streamText } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 import { AIProviderName, APIVersions } from "../constants/enums.js";
 import { validateApiKey, createAzureAPIKeyConfig, createAzureEndpointConfig, } from "../utils/providerConfig.js";
+import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { logger } from "../utils/logger.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
-import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 export class AzureOpenAIProvider extends BaseProvider {
     apiKey;
@@ -102,24 +102,24 @@ export class AzureOpenAIProvider extends BaseProvider {
                 model,
                 messages: messages,
                 ...(options.maxTokens !== null && options.maxTokens !== undefined
-                    ? { maxTokens: options.maxTokens }
+                    ? { maxOutputTokens: options.maxTokens }
                     : {}),
                 ...(options.temperature !== null && options.temperature !== undefined
                     ? { temperature: options.temperature }
                     : {}),
                 tools,
                 toolChoice: shouldUseTools ? "auto" : "none",
+                stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
-                onStepFinish: ({ toolCalls, toolResults }) => {
-                    this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
+                onStepFinish: (event) => {
+                    this.handleToolExecutionStorage([...event.toolCalls], [...event.toolResults], options, new Date()).catch((error) => {
                         logger.warn("[AzureOpenaiProvider] Failed to store tool executions", {
                             provider: this.providerName,
                             error: error instanceof Error ? error.message : String(error),
                         });
                     });
                 },
-                maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
             });
             timeoutController?.cleanup();
             // Transform string stream to content object stream using BaseProvider method

package/dist/providers/googleAiStudio.d.ts

@@ -1,4 +1,4 @@
-import { type LanguageModelV1, type Schema } from "ai";
+import { type LanguageModel, type Schema } from "ai";
 import { type AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import type { EnhancedGenerateResult, TextGenerationOptions } from "../types/generateTypes.js";
@@ -42,7 +42,7 @@ export declare class GoogleAIStudioProvider extends BaseProvider {
     /**
      * 🔧 PHASE 2: Return AI SDK model instance for tool calling
      */
-    getAISDKModel(): LanguageModelV1;
+    getAISDKModel(): LanguageModel;
     protected formatProviderError(error: unknown): Error;
     /**
      * Overrides the BaseProvider's image generation method to implement it for Google AI.

package/dist/providers/googleAiStudio.js

@@ -1,5 +1,5 @@
 import { createGoogleGenerativeAI } from "@ai-sdk/google";
-import { embed, embedMany, streamText, } from "ai";
+import { embed, embedMany, stepCountIs, streamText, } from "ai";
 import { ErrorCategory, ErrorSeverity, GoogleAIModels, } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
@@ -12,6 +12,7 @@ import { isGemini3Model } from "../utils/modelDetection.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { estimateTokens } from "../utils/tokenEstimation.js";
 import { buildNativeConfig, buildNativeToolDeclarations, collectStreamChunks, collectStreamChunksIncremental, computeMaxSteps, createTextChannel, executeNativeToolCalls, extractTextFromParts, handleMaxStepsTermination, pushModelResponseToHistory, sanitizeToolsForGemini, } from "./googleNativeGemini3.js";
+import { toAnalyticsStreamResult } from "./providerTypeUtils.js";
 // Google AI Live API types now imported from ../types/providerSpecific.js
 // Import proper types for multimodal message handling
 // Create Google GenAI client
@@ -476,10 +477,10 @@ export class GoogleAIStudioProvider extends BaseProvider {
                 model,
                 messages: messages,
                 temperature: options.temperature,
-                maxTokens: options.maxTokens, // No default limit - unlimited unless specified
+                maxOutputTokens: options.maxTokens, // No default limit - unlimited unless specified
                 tools,
-                maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
-                toolChoice: shouldUseTools && tools ? "auto" : "none",
+                stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
+                toolChoice: shouldUseTools ? "auto" : "none",
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 // Gemini 3: use thinkingLevel via providerOptions
@@ -509,12 +510,19 @@ export class GoogleAIStudioProvider extends BaseProvider {
                     });
                 },
             });
-            // Defer timeout cleanup until the stream completes or errors
-            result.text.finally(() => timeoutController?.cleanup());
+            // Defer timeout cleanup until the stream completes or errors.
+            // Guard against NoOutputGeneratedError becoming an unhandled rejection.
+            Promise.resolve(result.text)
+                .catch((err) => {
+                logger.debug("Stream text promise rejected (expected for empty streams)", {
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            })
+                .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
-            const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
+            const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, toAnalyticsStreamResult(result), Date.now() - startTime, {
                 requestId: `google-ai-stream-${Date.now()}`,
                 streamingMode: true,
             });

package/dist/providers/googleNativeGemini3.d.ts

@@ -9,41 +9,9 @@
  * 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;
-};
+import type { ThinkingConfig } from "../types/configTypes.js";
+import type { CollectedChunkResult, NativeFunctionCall, NativeFunctionDeclaration, NativeFunctionResponse, NativeToolDeclarationsResult, NativeToolsConfig, TextChannel } from "../types/index.js";
+export type { CollectedChunkResult, NativeFunctionCall, NativeFunctionDeclaration, NativeFunctionResponse, NativeToolDeclarationsResult, NativeToolsConfig, TextChannel, };
 /**
  * Sanitize a JSON Schema for Gemini's proto-based API.
  *
@@ -98,25 +66,6 @@ export declare function collectStreamChunks(stream: AsyncIterable<{
     functionCalls?: NativeFunctionCall[];
     [key: string]: unknown;
 }>): Promise<CollectedChunkResult>;
-/**
- * A push-based text channel that decouples producers (agentic loop) from
- * consumers (the caller's async iterable).
- *
- * The producer calls `push(text)` for each chunk and `close()` / `error(err)`
- * when done.  The consumer iterates the `iterable` async generator.
- */
-export type TextChannel = {
-    /** Push a text chunk to the consumer. */
-    push(text: string): void;
-    /** Signal that no more chunks will arrive. */
-    close(): void;
-    /** Signal that the producer encountered a fatal error. */
-    error(err: unknown): void;
-    /** Async iterable consumed by the StreamResult. */
-    iterable: AsyncIterable<{
-        content: string;
-    }>;
-};
 /**
  * Create a push-based text channel that bridges a background producer
  * (the agentic tool-calling loop) with an async-iterable consumer.

package/dist/providers/googleNativeGemini3.js

@@ -117,7 +117,10 @@ export function sanitizeToolsForGemini(tools) {
     const dropped = [];
     for (const [name, tool] of Object.entries(tools)) {
         try {
-            const params = tool.parameters;
+            // Access the legacy `parameters` field that may exist on older AI SDK tools.
+            // AI SDK v6 uses `inputSchema`, but v3/v4 tools and third-party wrappers use `parameters`.
+            const legacyTool = tool;
+            const params = legacyTool.parameters;
             if (params &&
                 typeof params === "object" &&
                 "_def" in params &&
@@ -131,8 +134,7 @@ export function sanitizeToolsForGemini(tools) {
                 const sanitizedSchema = sanitizeSchemaForGemini(inlined);
                 sanitized[name] = createAISDKTool({
                     description: tool.description || `Tool: ${name}`,
-                    parameters: aiJsonSchema(sanitizedSchema),
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    inputSchema: aiJsonSchema(sanitizedSchema),
                     execute: tool.execute,
                 });
             }
@@ -145,8 +147,7 @@ export function sanitizeToolsForGemini(tools) {
                 const sanitizedSchema = sanitizeSchemaForGemini(inlineJsonSchema(rawSchema));
                 sanitized[name] = createAISDKTool({
                     description: tool.description || `Tool: ${name}`,
-                    parameters: aiJsonSchema(sanitizedSchema),
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    inputSchema: aiJsonSchema(sanitizedSchema),
                     execute: tool.execute,
                 });
             }
@@ -177,13 +178,16 @@ export function buildNativeToolDeclarations(tools) {
                 name,
                 description: tool.description || `Tool: ${name}`,
             };
-            if (tool.parameters) {
+            // Access legacy `parameters` (AI SDK v3/v4) or current `inputSchema` (v6)
+            const legacyTool = tool;
+            if (legacyTool.parameters || tool.inputSchema) {
                 let rawSchema;
-                if (isZodSchema(tool.parameters)) {
-                    rawSchema = convertZodToJsonSchema(tool.parameters);
+                const toolParams = legacyTool.parameters || tool.inputSchema;
+                if (isZodSchema(toolParams)) {
+                    rawSchema = convertZodToJsonSchema(toolParams);
                 }
-                else if (typeof tool.parameters === "object") {
-                    rawSchema = tool.parameters;
+                else if (typeof toolParams === "object") {
+                    rawSchema = toolParams;
                 }
                 else {
                     rawSchema = { type: "object", properties: {} };