@juspay/neurolink 8.26.0 → 8.27.0

package/dist/lib/core/analytics.js

@@ -6,6 +6,7 @@
  */
 import { logger } from "../utils/logger.js";
 import { modelConfig } from "./modelConfiguration.js";
+import { extractTokenUsage as extractTokenUsageUtil } from "../utils/tokenUtils.js";
 /**
  * Create analytics data structure from AI response
  */
@@ -49,36 +50,14 @@ export function createAnalytics(provider, model, result, responseTime, context)
 }
 /**
  * Extract token usage from various AI result formats
+ * Delegates to centralized tokenUtils for consistent extraction across providers
  */
 function extractTokenUsage(result) {
-    // Use properly typed usage object from BaseProvider or direct AI SDK
-    if (result.usage &&
-        typeof result.usage === "object" &&
-        result.usage !== null) {
-        const usage = result.usage;
-        // Try BaseProvider normalized format first (input/output/total)
-        if (typeof usage.input === "number" || typeof usage.output === "number") {
-            const input = typeof usage.input === "number" ? usage.input : 0;
-            const output = typeof usage.output === "number" ? usage.output : 0;
-            const total = typeof usage.total === "number" ? usage.total : input + output;
-            return { input, output, total };
-        }
-        // Try OpenAI/Mistral format (promptTokens/completionTokens)
-        if (typeof usage.promptTokens === "number" ||
-            typeof usage.completionTokens === "number") {
-            const input = typeof usage.promptTokens === "number" ? usage.promptTokens : 0;
-            const output = typeof usage.completionTokens === "number" ? usage.completionTokens : 0;
-            const total = typeof usage.total === "number" ? usage.total : input + output;
-            return { input, output, total };
-        }
-        // Handle total-only case
-        if (typeof usage.total === "number") {
-            return { input: 0, output: 0, total: usage.total };
-        }
-    }
-    // Fallback for edge cases
-    logger.debug("Token extraction failed: unknown usage format", { result });
-    return { input: 0, output: 0, total: 0 };
+    // Use centralized token extraction utility
+    // The utility handles nested usage objects, multiple provider formats,
+    // cache tokens, reasoning tokens, and cache savings calculation
+    // Cast result to allow extractTokenUsageUtil to handle type normalization
+    return extractTokenUsageUtil(result.usage);
 }
 /**
  * Estimate cost based on provider, model, and token usage

package/dist/lib/core/baseProvider.js

@@ -126,6 +126,7 @@ export class BaseProvider {
                         maxSteps: options.maxSteps || 5,
                         provider: options.provider,
                         model: options.model,
+                        region: options.region, // Pass region for Vertex AI
                         // 🔧 FIX: Include analytics and evaluation options from stream options
                         enableAnalytics: options.enableAnalytics,
                         enableEvaluation: options.enableEvaluation,

package/dist/lib/core/constants.d.ts

@@ -6,6 +6,7 @@ export declare const DEFAULT_MAX_TOKENS: undefined;
 export declare const DEFAULT_TEMPERATURE = 0.7;
 export declare const DEFAULT_TIMEOUT = 60000;
 export declare const DEFAULT_MAX_STEPS = 200;
+export declare const DEFAULT_TOOL_MAX_RETRIES = 2;
 export declare const STEP_LIMITS: {
     min: number;
     max: number;

package/dist/lib/core/constants.js

@@ -7,6 +7,7 @@ export const DEFAULT_MAX_TOKENS = undefined; // Unlimited by default - let provi
 export const DEFAULT_TEMPERATURE = 0.7;
 export const DEFAULT_TIMEOUT = 60000;
 export const DEFAULT_MAX_STEPS = 200;
+export const DEFAULT_TOOL_MAX_RETRIES = 2; // Maximum retries per tool before permanently failing
 // Step execution limits
 export const STEP_LIMITS = {
     min: 1,

package/dist/lib/core/modules/GenerationHandler.js

@@ -14,6 +14,7 @@
  */
 import { generateText, Output, NoObjectGeneratedError } from "ai";
 import { logger } from "../../utils/logger.js";
+import { extractTokenUsage } from "../../utils/tokenUtils.js";
 import { DEFAULT_MAX_STEPS } from "../constants.js";
 /**
  * GenerationHandler class - Handles text generation operations for AI providers
@@ -36,6 +37,10 @@ export class GenerationHandler {
      * @private
      */
     async callGenerateText(model, messages, tools, options, shouldUseTools, includeStructuredOutput) {
+        // Check if this is a Google provider (for provider-specific options)
+        const isGoogleProvider = this.providerName === "google-ai" || this.providerName === "vertex";
+        // Check if this is an Anthropic provider
+        const isAnthropicProvider = this.providerName === "anthropic" || this.providerName === "bedrock";
         const useStructuredOutput = includeStructuredOutput &&
             !!options.schema &&
             (options.output?.format === "json" ||
@@ -52,6 +57,39 @@ export class GenerationHandler {
                 options.schema && {
                 experimental_output: Output.object({ schema: options.schema }),
             }),
+            // Add thinking configuration for extended reasoning
+            // Gemini 3 models use providerOptions.google.thinkingConfig with thinkingLevel
+            // Gemini 2.5 models use thinkingBudget
+            // Anthropic models use experimental_thinking with budgetTokens
+            ...(options.thinkingConfig?.enabled && {
+                // For Anthropic: experimental_thinking with budgetTokens
+                ...(isAnthropicProvider &&
+                    options.thinkingConfig.budgetTokens &&
+                    !options.thinkingConfig.thinkingLevel && {
+                    experimental_thinking: {
+                        type: "enabled",
+                        budgetTokens: options.thinkingConfig.budgetTokens,
+                    },
+                }),
+                // For Google Gemini 3: providerOptions with thinkingLevel
+                // For Gemini 2.5: providerOptions with thinkingBudget
+                ...(isGoogleProvider && {
+                    providerOptions: {
+                        google: {
+                            thinkingConfig: {
+                                ...(options.thinkingConfig.thinkingLevel && {
+                                    thinkingLevel: options.thinkingConfig.thinkingLevel,
+                                }),
+                                ...(options.thinkingConfig.budgetTokens &&
+                                    !options.thinkingConfig.thinkingLevel && {
+                                    thinkingBudget: options.thinkingConfig.budgetTokens,
+                                }),
+                                includeThoughts: true,
+                            },
+                        },
+                    },
+                }),
+            }),
             experimental_telemetry: this.getTelemetryConfigFn(options, "generate"),
             onStepFinish: ({ toolCalls, toolResults }) => {
                 logger.info("Tool execution completed", { toolResults, toolCalls });
@@ -227,13 +265,13 @@ export class GenerationHandler {
         else {
             content = generateResult.text;
         }
+        // Extract usage with support for different formats and reasoning tokens
+        // Note: The AI SDK bundles thinking tokens into promptTokens for Google models.
+        // Separate reasoningTokens tracking will work when/if the AI SDK adds support.
+        const usage = extractTokenUsage(generateResult.usage);
         return {
             content,
-            usage: {
-                input: generateResult.usage?.promptTokens || 0,
-                output: generateResult.usage?.completionTokens || 0,
-                total: generateResult.usage?.totalTokens || 0,
-            },
+            usage,
             provider: this.providerName,
             model: this.modelName,
             toolCalls: generateResult.toolCalls

package/dist/lib/core/streamAnalytics.d.ts

@@ -6,6 +6,7 @@ import type { StreamTextResult, StreamAnalyticsCollector, ResponseMetadata } fro
 export declare class BaseStreamAnalyticsCollector implements StreamAnalyticsCollector {
     /**
      * Collect token usage from stream result
+     * Uses centralized tokenUtils for consistent extraction across providers
      */
     collectUsage(result: StreamTextResult): Promise<TokenUsage>;
     /**

package/dist/lib/core/streamAnalytics.js

@@ -1,37 +1,29 @@
 import { createAnalytics } from "./analytics.js";
 import { logger } from "../utils/logger.js";
+import { extractTokenUsage, createEmptyTokenUsage, } from "../utils/tokenUtils.js";
 /**
  * Base implementation for collecting analytics from Vercel AI SDK stream results
  */
 export class BaseStreamAnalyticsCollector {
     /**
      * Collect token usage from stream result
+     * Uses centralized tokenUtils for consistent extraction across providers
      */
     async collectUsage(result) {
         try {
             const usage = await result.usage;
             if (!usage) {
                 logger.debug("No usage data available from stream result");
-                return {
-                    input: 0,
-                    output: 0,
-                    total: 0,
-                };
+                return createEmptyTokenUsage();
             }
-            return {
-                input: usage.promptTokens || 0,
-                output: usage.completionTokens || 0,
-                total: usage.totalTokens ||
-                    (usage.promptTokens || 0) + (usage.completionTokens || 0),
-            };
+            // Use centralized token extraction utility
+            // Handles multiple provider formats, cache tokens, reasoning tokens,
+            // and cache savings calculation
+            return extractTokenUsage(usage);
         }
         catch (error) {
             logger.warn("Failed to collect usage from stream result", { error });
-            return {
-                input: 0,
-                output: 0,
-                total: 0,
-            };
+            return createEmptyTokenUsage();
         }
     }
     /**

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

@@ -2,6 +2,7 @@ import { type Schema, type LanguageModelV1 } from "ai";
 import type { ZodUnknownSchema } from "../types/typeAliases.js";
 import { AIProviderName } from "../constants/enums.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
+import type { TextGenerationOptions, EnhancedGenerateResult } from "../types/generateTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
 /**
  * Google AI Studio provider implementation using BaseProvider
@@ -44,6 +45,20 @@ export declare class GoogleAIStudioProvider extends BaseProvider {
     getAISDKModel(): LanguageModelV1;
     handleProviderError(error: unknown): Error;
     protected executeStream(options: StreamOptions, _analysisSchema?: ZodUnknownSchema | Schema<unknown>): Promise<StreamResult>;
+    /**
+     * Execute stream using native @google/genai SDK for Gemini 3 models
+     * This bypasses @ai-sdk/google to properly handle thought_signature
+     */
+    private executeNativeGemini3Stream;
+    /**
+     * Execute generate using native @google/genai SDK for Gemini 3 models
+     * This bypasses @ai-sdk/google to properly handle thought_signature
+     */
+    private executeNativeGemini3Generate;
+    /**
+     * Override generate to route Gemini 3 models with tools to native SDK
+     */
+    generate(optionsOrPrompt: TextGenerationOptions | string): Promise<EnhancedGenerateResult | null>;
     private executeAudioStreamViaGeminiLive;
     private getApiKey;
 }