@juspay/neurolink 7.6.1 → 7.7.1

package/dist/providers/googleVertex.js

@@ -1,9 +1,10 @@
 import { createVertex, } from "@ai-sdk/google-vertex";
-import { streamText, Output } from "ai";
+import { streamText, Output, } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
-import { createTimeoutController, TimeoutError, getDefaultTimeout, } from "../utils/timeout.js";
+import { TimeoutError } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
+import { ModelConfigurationManager } from "../core/modelConfiguration.js";
 import { validateApiKey, createVertexProjectConfig, createGoogleAuthConfig, } from "../utils/providerConfig.js";
 // Cache for anthropic module to avoid repeated imports
 let _createVertexAnthropic = null;
@@ -28,7 +29,6 @@ async function getCreateVertexAnthropic() {
         return null;
     }
 }
-// Configuration helpers
 // Configuration helpers - now using consolidated utility
 const getVertexProjectId = () => {
     return validateApiKey(createVertexProjectConfig());
@@ -40,6 +40,8 @@ const getVertexLocation = () => {
         "us-central1");
 };
 const getDefaultVertexModel = () => {
+    // Use gemini-1.5-pro as default - stable and widely supported model
+    // Override with VERTEX_MODEL environment variable if needed
     return process.env.VERTEX_MODEL || "gemini-1.5-pro";
 };
 const hasGoogleCredentials = () => {
@@ -48,24 +50,80 @@ const hasGoogleCredentials = () => {
         (process.env.GOOGLE_AUTH_CLIENT_EMAIL &&
             process.env.GOOGLE_AUTH_PRIVATE_KEY));
 };
+// Enhanced Vertex settings creation with authentication fallback
+const createVertexSettings = () => {
+    const baseSettings = {
+        project: getVertexProjectId(),
+        location: getVertexLocation(),
+    };
+    // Check for principal account authentication first (recommended for production)
+    if (process.env.GOOGLE_APPLICATION_CREDENTIALS) {
+        logger.debug("Using principal account authentication (recommended)", {
+            credentialsPath: process.env.GOOGLE_APPLICATION_CREDENTIALS
+                ? "[PROVIDED]"
+                : "[NOT_PROVIDED]",
+            authMethod: "principal_account",
+        });
+        // For principal account auth, we don't need to provide explicit credentials
+        // The google-auth-library will use GOOGLE_APPLICATION_CREDENTIALS automatically
+        return baseSettings;
+    }
+    // Fallback to explicit credentials for development
+    if (process.env.GOOGLE_AUTH_CLIENT_EMAIL &&
+        process.env.GOOGLE_AUTH_PRIVATE_KEY) {
+        logger.debug("Using explicit credentials authentication", {
+            authMethod: "explicit_credentials",
+            hasClientEmail: !!process.env.GOOGLE_AUTH_CLIENT_EMAIL,
+            hasPrivateKey: !!process.env.GOOGLE_AUTH_PRIVATE_KEY,
+        });
+        return {
+            ...baseSettings,
+            googleAuthOptions: {
+                credentials: {
+                    client_email: process.env.GOOGLE_AUTH_CLIENT_EMAIL,
+                    private_key: process.env.GOOGLE_AUTH_PRIVATE_KEY.replace(/\\n/g, "\n"),
+                },
+            },
+        };
+    }
+    // Log warning if no valid authentication is available
+    logger.warn("No valid authentication found for Google Vertex AI", {
+        authMethod: "none",
+        hasPrincipalAccount: !!process.env.GOOGLE_APPLICATION_CREDENTIALS,
+        hasExplicitCredentials: !!(process.env.GOOGLE_AUTH_CLIENT_EMAIL &&
+            process.env.GOOGLE_AUTH_PRIVATE_KEY),
+    });
+    return baseSettings;
+};
+// Helper function to determine if a model is an Anthropic model
+const isAnthropicModel = (modelName) => {
+    return modelName.toLowerCase().includes("claude");
+};
 /**
  * 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 class GoogleVertexProvider extends BaseProvider {
-    vertex;
-    model;
     projectId;
     location;
-    cachedAnthropicModel = null;
+    registeredTools = new Map();
+    toolContext = {};
+    // Memory-managed cache for model configuration lookups to avoid repeated calls
+    // Uses WeakMap for automatic cleanup and bounded LRU for recently used models
+    static modelConfigCache = new Map();
+    static modelConfigCacheTime = 0;
+    static CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
+    static MAX_CACHE_SIZE = 50; // Prevent memory leaks by limiting cache size
+    // Memory-managed cache for maxTokens handling decisions to optimize streaming performance
+    static maxTokensCache = new Map();
+    static maxTokensCacheTime = 0;
     constructor(modelName, sdk) {
         super(modelName, "vertex", sdk);
         // Validate Google Cloud credentials - now using consolidated utility
@@ -75,14 +133,6 @@ export class GoogleVertexProvider extends BaseProvider {
         // Initialize Google Cloud configuration
         this.projectId = getVertexProjectId();
         this.location = getVertexLocation();
-        const vertexConfig = {
-            project: this.projectId,
-            location: this.location,
-        };
-        // Create Vertex provider instance
-        this.vertex = createVertex(vertexConfig);
-        // Pre-initialize model for efficiency
-        this.model = this.vertex(this.modelName || getDefaultVertexModel());
         logger.debug("Google Vertex AI BaseProvider v2 initialized", {
             modelName: this.modelName,
             projectId: this.projectId,
@@ -98,37 +148,101 @@ export class GoogleVertexProvider extends BaseProvider {
     }
     /**
      * Returns the Vercel AI SDK model instance for Google Vertex
-     * Handles both Google and Anthropic models
+     * Creates fresh model instances for each request
      */
     async getAISDKModel() {
+        const model = await this.getModel();
+        return model;
+    }
+    /**
+     * Gets the appropriate model instance (Google or Anthropic)
+     * Creates fresh instances for each request to ensure proper authentication
+     */
+    async getModel() {
+        const modelName = this.modelName || getDefaultVertexModel();
         // Check if this is an Anthropic model
-        if (this.modelName && this.modelName.includes("claude")) {
-            // Return cached Anthropic model if available
-            if (this.cachedAnthropicModel) {
-                return this.cachedAnthropicModel;
-            }
-            // Create and cache new Anthropic model
-            const anthropicModel = await this.createAnthropicModel(this.modelName);
+        if (isAnthropicModel(modelName)) {
+            logger.debug("Creating Anthropic model for Vertex AI", { modelName });
+            const anthropicModel = await this.createAnthropicModel(modelName);
             if (anthropicModel) {
-                this.cachedAnthropicModel = anthropicModel;
                 return anthropicModel;
             }
             // Fall back to regular model if Anthropic not available
-            logger.warn(`Anthropic model ${this.modelName} requested but not available, falling back to Google model`);
+            logger.warn(`Anthropic model ${modelName} requested but not available, falling back to Google model`);
         }
-        return this.model;
+        // Create fresh Google Vertex model with current settings
+        logger.debug("Creating Google Vertex model", {
+            modelName,
+            project: this.projectId,
+            location: this.location,
+        });
+        const vertex = createVertex(createVertexSettings());
+        const model = vertex(modelName);
+        return model;
     }
     // executeGenerate removed - BaseProvider handles all generation with tools
     async executeStream(options, analysisSchema) {
+        const functionTag = "GoogleVertexProvider.executeStream";
+        let chunkCount = 0;
         try {
             this.validateStreamOptions(options);
-            const result = await streamText({
-                model: this.model,
+            logger.debug(`${functionTag}: Starting stream request`, {
+                modelName: this.modelName,
+                promptLength: options.input.text.length,
+                hasSchema: !!analysisSchema,
+            });
+            const model = await this.getModel();
+            // Model-specific maxTokens handling
+            const modelName = this.modelName || getDefaultVertexModel();
+            // Use cached model configuration to determine maxTokens handling for streaming performance
+            // This avoids hardcoded model-specific logic and repeated config lookups
+            const shouldSetMaxTokens = this.shouldSetMaxTokensCached(modelName);
+            const maxTokens = shouldSetMaxTokens
+                ? options.maxTokens || DEFAULT_MAX_TOKENS
+                : undefined;
+            // Build complete stream options with proper typing
+            let streamOptions = {
+                model: model,
                 prompt: options.input.text,
                 system: options.systemPrompt,
-                maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
                 temperature: options.temperature,
-            });
+                ...(maxTokens && { maxTokens }),
+                onError: (event) => {
+                    const error = event.error;
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    logger.error(`${functionTag}: Stream error`, {
+                        provider: this.providerName,
+                        modelName: this.modelName,
+                        error: errorMessage,
+                        chunkCount,
+                    });
+                },
+                onFinish: (event) => {
+                    logger.debug(`${functionTag}: Stream finished`, {
+                        finishReason: event.finishReason,
+                        totalChunks: chunkCount,
+                    });
+                },
+                onChunk: () => {
+                    chunkCount++;
+                },
+            };
+            if (analysisSchema) {
+                try {
+                    streamOptions = {
+                        ...streamOptions,
+                        experimental_output: Output.object({
+                            schema: analysisSchema,
+                        }),
+                    };
+                }
+                catch (error) {
+                    logger.warn("Schema application failed, continuing without schema", {
+                        error: String(error),
+                    });
+                }
+            }
+            const result = streamText(streamOptions);
             return {
                 stream: (async function* () {
                     for await (const chunk of result.textStream) {
@@ -140,6 +254,12 @@ export class GoogleVertexProvider extends BaseProvider {
             };
         }
         catch (error) {
+            logger.error(`${functionTag}: Exception`, {
+                provider: this.providerName,
+                modelName: this.modelName,
+                error: String(error),
+                chunkCount,
+            });
             throw this.handleProviderError(error);
         }
     }
@@ -153,24 +273,28 @@ export class GoogleVertexProvider extends BaseProvider {
             ? errorRecord.message
             : "Unknown error occurred";
         if (message.includes("PERMISSION_DENIED")) {
-            return new Error(`❌ Google Vertex AI Permission Denied\n\nYour Google Cloud credentials don't have permission to access Vertex AI.\n\n🔧 Required Steps:\n1. Ensure your service account has Vertex AI User role\n2. Check if Vertex AI API is enabled in your project\n3. Verify your project ID is correct\n4. Confirm your location/region has Vertex AI available`);
+            return new Error(`❌ Google Vertex AI Permission Denied\n\nYour Google Cloud credentials don't have permission to access Vertex AI.\n\nRequired Steps:\n1. Ensure your service account has Vertex AI User role\n2. Check if Vertex AI API is enabled in your project\n3. Verify your project ID is correct\n4. Confirm your location/region has Vertex AI available`);
         }
         if (message.includes("NOT_FOUND")) {
-            return new Error(`❌ Google Vertex AI Model Not Found\n\n${message}\n\n🔧 Check:\n1. Model name is correct (e.g., 'gemini-1.5-pro')\n2. Model is available in your region (${this.location})\n3. Your project has access to the model\n4. Model supports your request parameters`);
+            return new Error(`❌ Google Vertex AI Model Not Found\n\n${message}\n\nCheck:\n1. Model name is correct (e.g., 'gemini-1.5-pro')\n2. Model is available in your region (${this.location})\n3. Your project has access to the model\n4. Model supports your request parameters`);
         }
         if (message.includes("QUOTA_EXCEEDED")) {
-            return new Error(`❌ Google Vertex AI Quota Exceeded\n\n${message}\n\n🔧 Solutions:\n1. Check your Vertex AI quotas in Google Cloud Console\n2. Request quota increase if needed\n3. Try a different model or reduce request frequency\n4. Consider using a different region`);
+            return new Error(`❌ Google Vertex AI Quota Exceeded\n\n${message}\n\nSolutions:\n1. Check your Vertex AI quotas in Google Cloud Console\n2. Request quota increase if needed\n3. Try a different model or reduce request frequency\n4. Consider using a different region`);
         }
         if (message.includes("INVALID_ARGUMENT")) {
-            return new Error(`❌ Google Vertex AI Invalid Request\n\n${message}\n\n🔧 Check:\n1. Request parameters are within model limits\n2. Input text is properly formatted\n3. Temperature and other settings are valid\n4. Model supports your request type`);
+            return new Error(`❌ Google Vertex AI Invalid Request\n\n${message}\n\nCheck:\n1. Request parameters are within model limits\n2. Input text is properly formatted\n3. Temperature and other settings are valid\n4. Model supports your request type`);
         }
-        return new Error(`❌ Google Vertex AI Provider Error\n\n${message}\n\n🔧 Troubleshooting:\n1. Check Google Cloud credentials and permissions\n2. Verify project ID and location settings\n3. Ensure Vertex AI API is enabled\n4. Check network connectivity`);
+        return new Error(`❌ Google Vertex AI Provider Error\n\n${message}\n\nTroubleshooting:\n1. Check Google Cloud credentials and permissions\n2. Verify project ID and location settings\n3. Ensure Vertex AI API is enabled\n4. Check network connectivity`);
     }
     validateStreamOptions(options) {
         if (!options.input?.text?.trim()) {
             throw new Error("Prompt is required for streaming");
         }
-        if (options.maxTokens &&
+        // Use cached model configuration for validation performance
+        const modelName = this.modelName || getDefaultVertexModel();
+        const shouldValidateMaxTokens = this.shouldSetMaxTokensCached(modelName);
+        if (shouldValidateMaxTokens &&
+            options.maxTokens &&
             (options.maxTokens < 1 || options.maxTokens > 8192)) {
             throw new Error("maxTokens must be between 1 and 8192 for Google Vertex AI");
         }
@@ -179,6 +303,93 @@ export class GoogleVertexProvider extends BaseProvider {
             throw new Error("temperature must be between 0 and 2");
         }
     }
+    /**
+     * Memory-safe cache management for model configurations
+     * Implements LRU eviction to prevent memory leaks in long-running processes
+     */
+    static evictLRUCacheEntries(cache) {
+        if (cache.size <= GoogleVertexProvider.MAX_CACHE_SIZE) {
+            return;
+        }
+        // Evict oldest entries (first entries in Map are oldest in insertion order)
+        const entriesToRemove = cache.size - GoogleVertexProvider.MAX_CACHE_SIZE + 5; // Remove extra to avoid frequent evictions
+        let removed = 0;
+        for (const key of cache.keys()) {
+            if (removed >= entriesToRemove) {
+                break;
+            }
+            cache.delete(key);
+            removed++;
+        }
+        logger.debug("GoogleVertexProvider: Evicted LRU cache entries", {
+            entriesRemoved: removed,
+            currentCacheSize: cache.size,
+        });
+    }
+    /**
+     * Access and refresh cache entry (moves to end for LRU)
+     */
+    static accessCacheEntry(cache, key) {
+        const value = cache.get(key);
+        if (value !== undefined) {
+            // Move to end (most recently used)
+            cache.delete(key);
+            cache.set(key, value);
+        }
+        return value;
+    }
+    /**
+     * 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
+     */
+    shouldSetMaxTokensCached(modelName) {
+        const now = Date.now();
+        // Check if cache is valid (within 5 minutes)
+        if (now - GoogleVertexProvider.maxTokensCacheTime >
+            GoogleVertexProvider.CACHE_DURATION) {
+            // Cache expired, refresh all cached results
+            GoogleVertexProvider.maxTokensCache.clear();
+            GoogleVertexProvider.maxTokensCacheTime = now;
+        }
+        // Check if we have cached result for this model (with LRU access)
+        const cachedResult = GoogleVertexProvider.accessCacheEntry(GoogleVertexProvider.maxTokensCache, modelName);
+        if (cachedResult !== undefined) {
+            return cachedResult;
+        }
+        // Calculate and cache the result with memory management
+        const shouldSet = !this.modelHasMaxTokensIssues(modelName);
+        GoogleVertexProvider.maxTokensCache.set(modelName, shouldSet);
+        // Prevent memory leaks by evicting old entries if cache grows too large
+        GoogleVertexProvider.evictLRUCacheEntries(GoogleVertexProvider.maxTokensCache);
+        return shouldSet;
+    }
+    /**
+     * 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
+     */
+    modelHasMaxTokensIssues(modelName) {
+        const now = Date.now();
+        const cacheKey = "google-vertex-config";
+        // Check if cache is valid (within 5 minutes)
+        if (now - GoogleVertexProvider.modelConfigCacheTime >
+            GoogleVertexProvider.CACHE_DURATION) {
+            // Cache expired, refresh it with memory management
+            GoogleVertexProvider.modelConfigCache.clear();
+            const config = ModelConfigurationManager.getInstance();
+            const vertexConfig = config.getProviderConfig("google-vertex");
+            GoogleVertexProvider.modelConfigCache.set(cacheKey, vertexConfig);
+            GoogleVertexProvider.modelConfigCacheTime = now;
+        }
+        // Access cached config with LRU behavior
+        const vertexConfig = GoogleVertexProvider.accessCacheEntry(GoogleVertexProvider.modelConfigCache, cacheKey);
+        // Check if model is in the list of models with maxTokens issues
+        const modelsWithIssues = vertexConfig?.modelBehavior?.maxTokensIssues || [
+            "gemini-2.5-flash",
+            "gemini-2.5-pro",
+        ];
+        return modelsWithIssues.some((problematicModel) => modelName.includes(problematicModel));
+    }
     /**
      * Check if Anthropic models are available
      * @returns Promise<boolean> indicating if Anthropic support is available
@@ -189,19 +400,127 @@ export class GoogleVertexProvider extends BaseProvider {
     }
     /**
      * 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
      */
-    async createAnthropicModel(modelName) {
-        const createVertexAnthropic = await getCreateVertexAnthropic();
-        if (!createVertexAnthropic) {
-            return null;
+    createAnthropicModel(modelName) {
+        return getCreateVertexAnthropic().then((createVertexAnthropic) => {
+            if (!createVertexAnthropic) {
+                return null;
+            }
+            // Use fresh vertex settings instead of cached config
+            // Type guard to ensure createVertexAnthropic is callable
+            if (typeof createVertexAnthropic !== "function") {
+                throw new Error("createVertexAnthropic is not a function");
+            }
+            const vertexSettings = createVertexSettings();
+            const vertexAnthropicInstance = createVertexAnthropic(vertexSettings);
+            // Type guard to ensure the returned instance has the expected model creation method
+            if (!vertexAnthropicInstance ||
+                typeof vertexAnthropicInstance !== "function") {
+                throw new Error("Failed to create valid Anthropic instance");
+            }
+            const model = vertexAnthropicInstance(modelName);
+            // Type guard to ensure the returned model implements LanguageModelV1
+            if (!model ||
+                typeof model !== "object" ||
+                !("specificationVersion" in model)) {
+                throw new Error("Failed to create valid LanguageModelV1 instance");
+            }
+            return model;
+        });
+    }
+    /**
+     * 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, schema, description, handler) {
+        const functionTag = "GoogleVertexProvider.registerTool";
+        try {
+            const tool = {
+                description,
+                parameters: schema,
+                execute: async (params) => {
+                    try {
+                        const contextEnrichedParams = {
+                            ...params,
+                            __context: this.toolContext,
+                        };
+                        return await handler(contextEnrichedParams);
+                    }
+                    catch (error) {
+                        logger.error(`${functionTag}: Tool execution error`, {
+                            toolName: name,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                        throw error;
+                    }
+                },
+            };
+            this.registeredTools.set(name, tool);
+            logger.debug(`${functionTag}: Tool registered`, {
+                toolName: name,
+                modelName: this.modelName,
+            });
         }
-        const vertexAnthropic = createVertexAnthropic({
-            project: this.projectId,
-            location: this.location,
+        catch (error) {
+            logger.error(`${functionTag}: Tool registration error`, {
+                toolName: name,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    /**
+     * Set the context for tool execution
+     * @param context The context to use for tool execution
+     */
+    setToolContext(context) {
+        this.toolContext = { ...this.toolContext, ...context };
+        logger.debug("GoogleVertexProvider.setToolContext: Tool context set", {
+            contextKeys: Object.keys(context),
         });
-        return vertexAnthropic(modelName);
+    }
+    /**
+     * Get the current tool execution context
+     * @returns The current tool execution context
+     */
+    getToolContext() {
+        return { ...this.toolContext };
+    }
+    /**
+     * Clear all static caches - useful for testing and memory cleanup
+     * Public method to allow external cache management
+     */
+    static clearCaches() {
+        GoogleVertexProvider.modelConfigCache.clear();
+        GoogleVertexProvider.maxTokensCache.clear();
+        GoogleVertexProvider.modelConfigCacheTime = 0;
+        GoogleVertexProvider.maxTokensCacheTime = 0;
+        logger.debug("GoogleVertexProvider: All caches cleared", {
+            clearedAt: Date.now(),
+        });
+    }
+    /**
+     * Get cache statistics for monitoring and debugging
+     */
+    static getCacheStats() {
+        const now = Date.now();
+        return {
+            modelConfigCacheSize: GoogleVertexProvider.modelConfigCache.size,
+            maxTokensCacheSize: GoogleVertexProvider.maxTokensCache.size,
+            maxCacheSize: GoogleVertexProvider.MAX_CACHE_SIZE,
+            cacheAge: {
+                modelConfig: now - GoogleVertexProvider.modelConfigCacheTime,
+                maxTokens: now - GoogleVertexProvider.maxTokensCacheTime,
+            },
+        };
     }
 }
 export default GoogleVertexProvider;
+// Re-export for compatibility
+export { GoogleVertexProvider as GoogleVertexAI };

package/dist/providers/huggingFace.d.ts

@@ -11,29 +11,70 @@ export declare class HuggingFaceProvider extends BaseProvider {
     private model;
     constructor(modelName?: string);
     /**
-     * HuggingFace models currently don't properly support tool/function calling
+     * HuggingFace Tool Calling Support (Enhanced 2025)
      *
-     * **Tested Models & Issues:**
-     * - microsoft/DialoGPT-medium: Describes tools instead of executing them
-     * - Most HF models via router endpoint: Function schema passed but not executed
-     * - Issue: Models treat tool definitions as conversation context rather than executable functions
+     * **Supported Models (Tool Calling Enabled):**
+     * - meta-llama/Llama-3.1-8B-Instruct - Post-trained for tool calling
+     * - meta-llama/Llama-3.1-70B-Instruct - Advanced tool calling capabilities
+     * - meta-llama/Llama-3.1-405B-Instruct - Full tool calling support
+     * - nvidia/Llama-3.1-Nemotron-Ultra-253B-v1 - Optimized for tool calling
+     * - NousResearch/Hermes-3-Llama-3.2-3B - Function calling trained
+     * - codellama/CodeLlama-34b-Instruct-hf - Code-focused tool calling
+     * - mistralai/Mistral-7B-Instruct-v0.3 - Basic tool support
      *
-     * **Known Limitations:**
-     * - Tools are visible to model but treated as descriptive text
-     * - No proper function call response format handling
-     * - HuggingFace router endpoint doesn't enforce OpenAI-compatible tool execution
+     * **Unsupported Models (Tool Calling Disabled):**
+     * - microsoft/DialoGPT-* - Treats tools as conversation context
+     * - gpt2, bert, roberta variants - No tool calling training
+     * - Most pre-2024 models - Limited function calling capabilities
      *
-     * @returns false to disable tools by default until proper implementation
+     * **Implementation Details:**
+     * - Intelligent model detection based on known capabilities
+     * - Custom tool schema formatting for HuggingFace models
+     * - Enhanced response parsing for function call extraction
+     * - Graceful fallback for unsupported models
+     *
+     * @returns true for supported models, false for unsupported models
      */
     supportsTools(): boolean;
     protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    /**
+     * Prepare stream options with HuggingFace-specific enhancements
+     * Handles tool calling optimizations and model-specific formatting
+     */
+    private prepareStreamOptions;
+    /**
+     * Enhance system prompt with tool calling instructions for HuggingFace models
+     * Many HF models benefit from explicit tool calling guidance
+     */
+    private enhanceSystemPromptForTools;
+    /**
+     * Format tools for HuggingFace model compatibility
+     * Some models require specific tool schema formatting
+     */
+    private formatToolsForHuggingFace;
+    /**
+     * Get recommendations for tool-calling capable HuggingFace models
+     * Provides guidance for users who want to use function calling
+     */
+    static getToolCallingRecommendations(): {
+        recommended: string[];
+        performance: Record<string, {
+            speed: number;
+            quality: number;
+            cost: number;
+        }>;
+        notes: Record<string, string>;
+    };
+    /**
+     * Enhanced error handling with HuggingFace-specific guidance
+     */
+    protected handleProviderError(error: unknown): Error;
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     /**
      * Returns the Vercel AI SDK model instance for HuggingFace
      */
     protected getAISDKModel(): LanguageModelV1;
-    protected handleProviderError(error: unknown): Error;
     private validateStreamOptions;
 }
 export default HuggingFaceProvider;