@juspay/neurolink 7.6.1 → 7.7.0

package/dist/providers/anthropic.js

@@ -45,19 +45,41 @@ export class AnthropicProvider extends BaseProvider {
     }
     handleProviderError(error) {
         if (error instanceof TimeoutError) {
-            return new Error(`Anthropic request timed out: ${error.message}`);
+            return new Error(`Anthropic request timed out after ${error.timeout}ms: ${error.message}`);
         }
         const errorRecord = error;
+        // Handle API key errors
         if ((typeof errorRecord?.message === "string" &&
             errorRecord.message.includes("API_KEY_INVALID")) ||
             (typeof errorRecord?.message === "string" &&
                 errorRecord.message.includes("Invalid API key"))) {
             return new Error("Invalid Anthropic API key. Please check your ANTHROPIC_API_KEY environment variable.");
         }
+        // Handle rate limiting errors
         if (typeof errorRecord?.message === "string" &&
-            errorRecord.message.includes("rate limit")) {
+            (errorRecord.message.includes("rate limit") ||
+                errorRecord.message.includes("too_many_requests") ||
+                errorRecord.message.includes("429"))) {
             return new Error("Anthropic rate limit exceeded. Please try again later.");
         }
+        // Handle connection errors
+        if (typeof errorRecord?.message === "string" &&
+            (errorRecord.message.includes("ECONNRESET") ||
+                errorRecord.message.includes("ENOTFOUND") ||
+                errorRecord.message.includes("ECONNREFUSED") ||
+                errorRecord.message.includes("network") ||
+                errorRecord.message.includes("connection"))) {
+            return new Error("Anthropic API connection error. Please check your internet connection and try again.");
+        }
+        // Handle server errors
+        if (typeof errorRecord?.message === "string" &&
+            (errorRecord.message.includes("500") ||
+                errorRecord.message.includes("502") ||
+                errorRecord.message.includes("503") ||
+                errorRecord.message.includes("504") ||
+                errorRecord.message.includes("server error"))) {
+            return new Error("Anthropic API server error. Please try again in a few moments.");
+        }
         const message = typeof errorRecord?.message === "string"
             ? errorRecord.message
             : "Unknown error";
@@ -76,12 +98,23 @@ export class AnthropicProvider extends BaseProvider {
         const timeout = this.getTimeout(options);
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
+            // ✅ Get tools for streaming (same as generate method)
+            const shouldUseTools = !options.disableTools && this.supportsTools();
+            const tools = shouldUseTools ? await this.getAllTools() : {};
+            // 🔧 CRITICAL FIX: Vercel AI SDK streamText() hangs with tools and maxSteps > 1
+            // For stream-focused SDK, we need reliable streaming, so avoid the hanging case
+            if (shouldUseTools && Object.keys(tools).length > 0) {
+                throw new Error("Vercel AI SDK streamText() limitation with tools - falling back to synthetic streaming");
+            }
             const result = await streamText({
                 model: this.model,
                 prompt: options.input.text,
                 system: options.systemPrompt || undefined,
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+                tools: {}, // 🔧 Force empty tools for real streaming to avoid hanging
+                maxSteps: 1, // 🔧 Force single step for real streaming
+                toolChoice: "none", // 🔧 Force no tools for real streaming
                 abortSignal: timeoutController?.controller.signal,
             });
             timeoutController?.cleanup();
@@ -91,10 +124,27 @@ export class AnthropicProvider extends BaseProvider {
                     yield { content: chunk };
                 }
             };
+            // ✅ Note: Vercel AI SDK's streamText() method limitations with tools
+            // The streamText() function doesn't provide the same tool result access as generateText()
+            // For full tool support, the BaseProvider will fall back to synthetic streaming when needed
+            const toolCalls = [];
+            const toolResults = [];
+            const usage = await result.usage;
+            const finishReason = await result.finishReason;
             return {
                 stream: transformedStream(),
                 provider: this.providerName,
                 model: this.modelName,
+                toolCalls, // ✅ Include tool calls in stream result
+                toolResults, // ✅ Include tool results in stream result
+                usage: usage
+                    ? {
+                        inputTokens: usage.promptTokens || 0,
+                        outputTokens: usage.completionTokens || 0,
+                        totalTokens: usage.totalTokens || 0,
+                    }
+                    : undefined,
+                finishReason: finishReason || undefined,
             };
         }
         catch (error) {

package/dist/providers/googleAiStudio.js

@@ -65,6 +65,10 @@ export class GoogleAIStudioProvider extends BaseProvider {
         this.validateStreamOptions(options);
         const startTime = Date.now();
         const apiKey = this.getApiKey();
+        // Ensure environment variable is set for @ai-sdk/google
+        if (!process.env.GOOGLE_GENERATIVE_AI_API_KEY) {
+            process.env.GOOGLE_GENERATIVE_AI_API_KEY = apiKey;
+        }
         const google = createGoogleGenerativeAI({ apiKey });
         const model = google(this.modelName);
         const timeout = this.getTimeout(options);

package/dist/providers/googleVertex.d.ts

@@ -1,37 +1,66 @@
 import type { ZodType, ZodTypeDef } from "zod";
-import { type Schema, type LanguageModelV1 } from "ai";
+import { type Schema, type LanguageModelV1, type LanguageModel } from "ai";
 import type { AIProviderName } from "../core/types.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
 /**
  * Google Vertex AI Provider v2 - BaseProvider Implementation
  *
- * PHASE 3.5: Simple BaseProvider wrap around existing @ai-sdk/google-vertex implementation
- *
  * Features:
  * - Extends BaseProvider for shared functionality
  * - Preserves existing Google Cloud authentication
  * - Maintains Anthropic model support via dynamic imports
- * - Uses pre-initialized Vertex instance for efficiency
+ * - Fresh model creation for each request
  * - Enhanced error handling with setup guidance
+ * - Tool registration and context management
  */
 export declare class GoogleVertexProvider extends BaseProvider {
-    private vertex;
-    private model;
     private projectId;
     private location;
-    private cachedAnthropicModel;
+    private registeredTools;
+    private toolContext;
+    private static modelConfigCache;
+    private static modelConfigCacheTime;
+    private static readonly CACHE_DURATION;
+    private static readonly MAX_CACHE_SIZE;
+    private static maxTokensCache;
+    private static maxTokensCacheTime;
     constructor(modelName?: string, sdk?: unknown);
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     /**
      * Returns the Vercel AI SDK model instance for Google Vertex
-     * Handles both Google and Anthropic models
+     * Creates fresh model instances for each request
+     */
+    protected getAISDKModel(): Promise<LanguageModel>;
+    /**
+     * Gets the appropriate model instance (Google or Anthropic)
+     * Creates fresh instances for each request to ensure proper authentication
      */
-    protected getAISDKModel(): Promise<LanguageModelV1>;
+    private getModel;
     protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
     protected handleProviderError(error: unknown): Error;
     private validateStreamOptions;
+    /**
+     * Memory-safe cache management for model configurations
+     * Implements LRU eviction to prevent memory leaks in long-running processes
+     */
+    private static evictLRUCacheEntries;
+    /**
+     * Access and refresh cache entry (moves to end for LRU)
+     */
+    private static accessCacheEntry;
+    /**
+     * Memory-safe cached check for whether maxTokens should be set for the given model
+     * Optimized for streaming performance with LRU eviction to prevent memory leaks
+     */
+    private shouldSetMaxTokensCached;
+    /**
+     * Memory-safe check if model has maxTokens issues using configuration-based approach
+     * This replaces hardcoded model-specific logic with configurable behavior
+     * Includes LRU caching to avoid repeated configuration lookups during streaming
+     */
+    private modelHasMaxTokensIssues;
     /**
      * Check if Anthropic models are available
      * @returns Promise<boolean> indicating if Anthropic support is available
@@ -39,9 +68,46 @@ export declare class GoogleVertexProvider extends BaseProvider {
     hasAnthropicSupport(): Promise<boolean>;
     /**
      * Create an Anthropic model instance if available
+     * Uses fresh vertex settings for each request
      * @param modelName Anthropic model name (e.g., 'claude-3-sonnet@20240229')
      * @returns LanguageModelV1 instance or null if not available
      */
     createAnthropicModel(modelName: string): Promise<LanguageModelV1 | null>;
+    /**
+     * Register a tool with the AI provider
+     * @param name The name of the tool
+     * @param schema The Zod schema defining the tool's parameters
+     * @param description A description of what the tool does
+     * @param handler The function to execute when the tool is called
+     */
+    registerTool(name: string, schema: ZodType<unknown>, description: string, handler: (params: Record<string, unknown>) => Promise<unknown>): void;
+    /**
+     * Set the context for tool execution
+     * @param context The context to use for tool execution
+     */
+    setToolContext(context: Record<string, unknown>): void;
+    /**
+     * Get the current tool execution context
+     * @returns The current tool execution context
+     */
+    getToolContext(): Record<string, unknown>;
+    /**
+     * Clear all static caches - useful for testing and memory cleanup
+     * Public method to allow external cache management
+     */
+    static clearCaches(): void;
+    /**
+     * Get cache statistics for monitoring and debugging
+     */
+    static getCacheStats(): {
+        modelConfigCacheSize: number;
+        maxTokensCacheSize: number;
+        maxCacheSize: number;
+        cacheAge: {
+            modelConfig: number;
+            maxTokens: number;
+        };
+    };
 }
 export default GoogleVertexProvider;
+export { GoogleVertexProvider as GoogleVertexAI };