@juspay/neurolink 5.2.0 → 6.0.0

package/dist/providers/function-calling-provider.js

@@ -7,7 +7,7 @@ import { streamText as aiStreamText, generateText as aiGenerate, Output, } from
 import { getAvailableFunctionTools, executeFunctionCall, isFunctionCallingAvailable, } from "../mcp/function-calling.js";
 import { createExecutionContext } from "../mcp/context-manager.js";
 import { mcpLogger } from "../mcp/logging.js";
-import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
+import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 /**
  * Enhanced provider that enables real function calling with MCP tools
  */
@@ -16,11 +16,22 @@ export class FunctionCallingProvider {
     enableFunctionCalling;
     sessionId;
     userId;
+    cachedToolsObject = null;
+    cachedToolMap = null;
+    cacheTimestamp = null;
+    cacheExpiryMs;
     constructor(baseProvider, options = {}) {
         this.baseProvider = baseProvider;
         this.enableFunctionCalling = options.enableFunctionCalling ?? true;
         this.sessionId = options.sessionId || `function-calling-${Date.now()}`;
         this.userId = options.userId || "function-calling-user";
+        // Configurable cache expiry: default 5 minutes, with environment override, then constructor option
+        const defaultExpiryMs = 5 * 60 * 1000; // 5 minutes
+        const envExpiryMs = process.env.NEUROLINK_CACHE_EXPIRY_MS
+            ? parseInt(process.env.NEUROLINK_CACHE_EXPIRY_MS, 10)
+            : undefined;
+        this.cacheExpiryMs =
+            options.cacheExpiryMs ?? envExpiryMs ?? defaultExpiryMs;
     }
     /**
      * PRIMARY METHOD: Stream content using AI (recommended for new code)
@@ -91,8 +102,30 @@ export class FunctionCallingProvider {
                 }
                 return result;
             }
-            // Get available function tools
-            const { tools, toolMap } = await getAvailableFunctionTools();
+            // Get available function tools (with automatic cache invalidation)
+            let toolsObject, toolMap;
+            const now = Date.now();
+            const isCacheExpired = this.cacheTimestamp === null ||
+                now - this.cacheTimestamp > this.cacheExpiryMs;
+            if (this.cachedToolsObject && this.cachedToolMap && !isCacheExpired) {
+                toolsObject = this.cachedToolsObject;
+                toolMap = this.cachedToolMap;
+                mcpLogger.debug(`[${functionTag}] Using cached tools (${Math.round((now - this.cacheTimestamp) / 1000)}s old)`);
+            }
+            else {
+                if (isCacheExpired && this.cachedToolsObject) {
+                    mcpLogger.debug(`[${functionTag}] Cache expired, refreshing tools`);
+                }
+                const result = await getAvailableFunctionTools();
+                toolsObject = result.toolsObject;
+                toolMap = result.toolMap;
+                // Cache the results for future use with timestamp
+                this.cachedToolsObject = toolsObject;
+                this.cachedToolMap = toolMap;
+                this.cacheTimestamp = now;
+                mcpLogger.debug(`[${functionTag}] Cached ${Object.keys(toolsObject).length} tools with expiry in ${this.cacheExpiryMs / 1000}s`);
+            }
+            const tools = Object.values(toolsObject);
             if (tools.length === 0) {
                 mcpLogger.debug(`[${functionTag}] No tools available, using base provider`);
                 const result = await this.baseProvider.generate(options, analysisSchema);
@@ -113,8 +146,8 @@ export class FunctionCallingProvider {
                 aiProvider: this.baseProvider.constructor.name,
             });
             // Use the AI SDK's native function calling by calling generate directly
-            // We need to get the underlying model from the base provider
-            const result = await this.generateWithTools(options, tools, toolMap, context, analysisSchema);
+            // We can now use the toolsObject directly instead of converting from array
+            const result = await this.generateWithToolsObject(options, toolsObject, toolMap, context, analysisSchema);
             if (!result) {
                 return {
                     content: "No response generated",
@@ -150,14 +183,83 @@ export class FunctionCallingProvider {
         }
     }
     /**
-     * Generate text using AI SDK's native function calling
+     * Generate text with tools using the AI SDK's generate function (with tools object)
+     */
+    async generateWithToolsObject(options, toolsObject, toolMap, context, analysisSchema) {
+        const functionTag = "FunctionCallingProvider.generateWithToolsObject";
+        try {
+            // Use the toolsObject directly with proper execution wrapped
+            const toolsWithExecution = this.wrapToolsWithExecution(toolsObject, toolMap, context);
+            mcpLogger.debug(`[${functionTag}] Using tools object with ${Object.keys(toolsWithExecution).length} tools`);
+            // Get the model from base provider
+            const modelInfo = await this.getModelFromProvider();
+            if (!modelInfo) {
+                mcpLogger.warn(`[${functionTag}] Could not get model from provider, falling back to base provider`);
+                const result = await this.baseProvider.generate(options, analysisSchema);
+                if (!result) {
+                    return {
+                        content: "No response generated",
+                        provider: "function-calling",
+                        model: "unknown",
+                    };
+                }
+                return result;
+            }
+            // Use AI SDK's generate directly with tools
+            const generateOptions = {
+                model: modelInfo.model,
+                prompt: options.prompt,
+                system: options.systemPrompt || "You are a helpful AI assistant.",
+                temperature: options.temperature || 0.7,
+                maxTokens: options.maxTokens ?? DEFAULT_MAX_TOKENS,
+                tools: toolsWithExecution,
+                toolChoice: "auto", // Let the AI decide when to use tools
+                maxSteps: options.maxSteps ?? DEFAULT_MAX_STEPS, // Enable multi-turn tool execution
+            };
+            // Add experimental_output if schema is provided
+            if (analysisSchema) {
+                generateOptions.experimental_output = Output.object({
+                    schema: analysisSchema,
+                });
+            }
+            const result = await aiGenerate(generateOptions);
+            mcpLogger.debug(`[${functionTag}] AI SDK generate completed`, {
+                toolCalls: result.toolCalls?.length || 0,
+                finishReason: result.finishReason,
+                usage: result.usage,
+            });
+            return {
+                content: result.text,
+                provider: "function-calling",
+                model: "unknown",
+                usage: result.usage
+                    ? {
+                        inputTokens: result.usage.promptTokens,
+                        outputTokens: result.usage.completionTokens,
+                        totalTokens: result.usage.totalTokens,
+                    }
+                    : undefined,
+                responseTime: 0,
+                toolsUsed: result.toolCalls?.map((tc) => tc.toolName) || [],
+                toolExecutions: [],
+                enhancedWithTools: (result.toolCalls?.length || 0) > 0,
+                availableTools: [],
+            };
+        }
+        catch (error) {
+            mcpLogger.error(`[${functionTag}] Failed to generate text with tools:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Generate text using AI SDK's native function calling (legacy array-based)
      */
     async generateWithTools(options, tools, toolMap, context, analysisSchema) {
         const functionTag = "FunctionCallingProvider.generateWithTools";
         try {
             // Convert our tools to AI SDK format with proper execution
             const toolsWithExecution = this.convertToAISDKTools(tools, toolMap, context);
-            mcpLogger.debug(`[${functionTag}] Calling AI SDK generate with ${Object.keys(toolsWithExecution).length} tools and maxSteps: 5`);
+            mcpLogger.debug(`[${functionTag}] Calling AI SDK generate with ${Object.keys(toolsWithExecution).length} tools and maxSteps: ${options.maxSteps ?? DEFAULT_MAX_STEPS}`);
             mcpLogger.debug(`[${functionTag}] Sanitized tool names:`, Object.keys(toolsWithExecution));
             // Log the first few tools to debug the issue
             const toolNames = Object.keys(toolsWithExecution);
@@ -187,7 +289,7 @@ export class FunctionCallingProvider {
                 maxTokens: options.maxTokens ?? DEFAULT_MAX_TOKENS,
                 tools: toolsWithExecution,
                 toolChoice: "auto", // Let the AI decide when to use tools
-                maxSteps: 5, // CRITICAL: Enable multi-turn tool execution
+                maxSteps: options.maxSteps ?? DEFAULT_MAX_STEPS, // Enable multi-turn tool execution
             };
             // Add experimental_output if schema is provided
             if (analysisSchema) {
@@ -242,7 +344,7 @@ export class FunctionCallingProvider {
             if (typeof provider.getModel === "function") {
                 mcpLogger.debug(`[${functionTag}] Found getModel method on provider`);
                 const model = await provider.getModel();
-                return { model };
+                return { model: model };
             }
             mcpLogger.warn(`[${functionTag}] Could not find model on provider`);
             return null;
@@ -270,7 +372,52 @@ export class FunctionCallingProvider {
         return sanitized;
     }
     /**
-     * Convert our tools to AI SDK format with proper execution
+     * Wrap tools with proper execution context (for object-based tools)
+     */
+    wrapToolsWithExecution(toolsObject, toolMap, context) {
+        const functionTag = "FunctionCallingProvider.wrapToolsWithExecution";
+        const wrappedTools = {};
+        for (const [toolName, tool] of Object.entries(toolsObject)) {
+            const toolInfo = toolMap.get(toolName);
+            const originalToolName = toolInfo ? toolInfo.toolName : toolName;
+            // Create a version with actual MCP execution
+            wrappedTools[toolName] = {
+                description: tool.description,
+                parameters: tool.parameters,
+                execute: async (args) => {
+                    // Debug logging only in debug mode
+                    if (process.env.NEUROLINK_DEBUG === "true") {
+                        const providerName = this.baseProvider.constructor.name;
+                        mcpLogger.debug(`Tool execution - Provider: ${providerName}`);
+                        mcpLogger.debug(`Tool: ${toolName} (original: ${originalToolName})`);
+                        mcpLogger.debug(`Args:`, args);
+                    }
+                    try {
+                        // Execute the actual MCP tool
+                        const result = await executeFunctionCall(toolName, args);
+                        if (process.env.NEUROLINK_DEBUG === "true") {
+                            mcpLogger.debug(`Tool result:`, result);
+                        }
+                        if (result.success) {
+                            return result.data || { success: true };
+                        }
+                        else {
+                            return { error: result.error || "Tool execution failed" };
+                        }
+                    }
+                    catch (error) {
+                        mcpLogger.error(`[${functionTag}] Tool execution error: ${toolName}`, error);
+                        return {
+                            error: error instanceof Error ? error.message : String(error),
+                        };
+                    }
+                },
+            };
+        }
+        return wrappedTools;
+    }
+    /**
+     * Convert our tools to AI SDK format with proper execution (legacy array-based)
      */
     convertToAISDKTools(tools, toolMap, context) {
         const functionTag = "FunctionCallingProvider.convertToAISDKTools";
@@ -394,6 +541,57 @@ These functions provide accurate, real-time data. Use them actively to enhance y
     /**
      * Alias for generate() - CLI-SDK consistency
      */
+    /**
+     * Clear cached tools - Cache Invalidation Strategy
+     *
+     * WHEN TO CALL clearToolsCache():
+     *
+     * 1. **MCP Server Changes**: When MCP servers are added, removed, or restarted
+     *    - After calling unifiedRegistry.addServer() or removeServer()
+     *    - When MCP server configurations change
+     *    - After MCP server restart or reconnection
+     *
+     * 2. **Tool Registration Changes**: When custom tools are modified
+     *    - After registering new SDK tools via registerTool()
+     *    - When tool implementations change
+     *    - After unregistering tools
+     *
+     * 3. **Provider Reinitialization**: When the provider context changes
+     *    - Before switching between different AI providers
+     *    - When session context changes significantly
+     *    - After provider authentication refresh
+     *
+     * 4. **Error Recovery**: When tool execution encounters systematic failures
+     *    - After MCP connection errors are resolved
+     *    - When tool discovery needs to be re-run
+     *    - During error recovery workflows
+     *
+     * 5. **Development/Testing**: During development and testing cycles
+     *    - Between test cases that modify tool availability
+     *    - When testing different tool configurations
+     *    - During hot reloading scenarios
+     *
+     * CACHE LIFECYCLE:
+     * - Cache is populated on first generate() call via getAvailableFunctionTools()
+     * - Cache persists across multiple generate() calls for performance
+     * - Cache is invalidated by calling this method
+     * - Next generate() call will rebuild cache from current tool state
+     *
+     * PERFORMANCE IMPACT:
+     * - Clearing cache forces tool discovery on next usage (~100-500ms overhead)
+     * - Recommended to clear cache proactively rather than reactively
+     * - Consider batching tool changes before clearing cache
+     *
+     * THREAD SAFETY:
+     * - This method is not thread-safe
+     * - Avoid calling during active generate() operations
+     * - Safe to call between separate AI generation requests
+     */
+    clearToolsCache() {
+        this.cachedToolsObject = null;
+        this.cachedToolMap = null;
+        this.cacheTimestamp = null;
+    }
     /**
      * Short alias for generate() - CLI-SDK consistency
      */
@@ -422,6 +620,7 @@ export function createMCPAwareProviderV3(baseProvider, options = {}) {
         enableFunctionCalling: options.enableFunctionCalling,
         sessionId: options.sessionId,
         userId: options.userId,
+        cacheExpiryMs: options.cacheExpiryMs,
     });
     mcpLogger.debug(`[${functionTag}] Created MCP-aware provider with function calling`, {
         providerName: options.providerName,

package/dist/providers/google-ai-studio.d.ts

@@ -8,14 +8,14 @@ import { BaseProvider } from "../core/base-provider.js";
  * Migrated from original GoogleAIStudio class to new factory pattern
  */
 export declare class GoogleAIStudioProvider extends BaseProvider {
-    constructor(modelName?: string, sdk?: any);
+    constructor(modelName?: string, sdk?: unknown);
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     /**
      * 🔧 PHASE 2: Return AI SDK model instance for tool calling
      */
     protected getAISDKModel(): LanguageModelV1;
-    protected handleProviderError(error: any): Error;
+    protected handleProviderError(error: unknown): Error;
     protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
     private getApiKey;
     private validateStreamOptions;

package/dist/providers/google-ai-studio.js

@@ -45,13 +45,19 @@ export class GoogleAIStudioProvider extends BaseProvider {
         if (error instanceof TimeoutError) {
             return new Error(`Google AI request timed out: ${error.message}`);
         }
-        if (error?.message?.includes("API_KEY_INVALID")) {
+        const errorRecord = error;
+        if (typeof errorRecord?.message === "string" &&
+            errorRecord.message.includes("API_KEY_INVALID")) {
             return new Error("Invalid Google AI API key. Please check your GOOGLE_AI_API_KEY environment variable.");
         }
-        if (error?.message?.includes("RATE_LIMIT_EXCEEDED")) {
+        if (typeof errorRecord?.message === "string" &&
+            errorRecord.message.includes("RATE_LIMIT_EXCEEDED")) {
             return new Error("Google AI rate limit exceeded. Please try again later.");
         }
-        return new Error(`Google AI error: ${error?.message || "Unknown error"}`);
+        const message = typeof errorRecord?.message === "string"
+            ? errorRecord.message
+            : "Unknown error";
+        return new Error(`Google AI error: ${message}`);
     }
     // executeGenerate removed - BaseProvider handles all generation with tools
     async executeStream(options, analysisSchema) {

package/dist/providers/google-vertex.d.ts

@@ -21,7 +21,7 @@ export declare class GoogleVertexProvider extends BaseProvider {
     private projectId;
     private location;
     private cachedAnthropicModel;
-    constructor(modelName?: string);
+    constructor(modelName?: string, sdk?: unknown);
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     /**
@@ -30,7 +30,7 @@ export declare class GoogleVertexProvider extends BaseProvider {
      */
     protected getAISDKModel(): Promise<LanguageModelV1>;
     protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
-    protected handleProviderError(error: any): Error;
+    protected handleProviderError(error: unknown): Error;
     private validateStreamOptions;
     /**
      * Check if Anthropic models are available

package/dist/providers/google-vertex.js

@@ -15,7 +15,8 @@ async function getCreateVertexAnthropic() {
     _anthropicImportAttempted = true;
     try {
         // Try to import the anthropic module - available in @ai-sdk/google-vertex ^2.2.0+
-        const anthropicModule = await import("@ai-sdk/google-vertex/anthropic");
+        // Use proper dynamic import without eval() for security
+        const anthropicModule = (await import("@ai-sdk/google-vertex/anthropic"));
         _createVertexAnthropic = anthropicModule.createVertexAnthropic;
         logger.debug("[GoogleVertexAI] Anthropic module successfully loaded");
         return _createVertexAnthropic;
@@ -69,8 +70,8 @@ export class GoogleVertexProvider extends BaseProvider {
     projectId;
     location;
     cachedAnthropicModel = null;
-    constructor(modelName) {
-        super(modelName, "vertex");
+    constructor(modelName, sdk) {
+        super(modelName, "vertex", sdk);
         // Validate Google Cloud credentials
         if (!hasGoogleCredentials()) {
             throw new Error(`❌ Google Vertex AI Provider Configuration Error\n\nMissing Google Cloud authentication. One of the following is required:\n\n🔧 Option 1: Service Account Key File\nGOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json\n\n🔧 Option 2: Service Account Key (Base64)\nGOOGLE_SERVICE_ACCOUNT_KEY=base64_encoded_key\n\n🔧 Option 3: Individual Credentials\nGOOGLE_AUTH_CLIENT_EMAIL=your-service-account@project.iam.gserviceaccount.com\nGOOGLE_AUTH_PRIVATE_KEY=-----BEGIN PRIVATE KEY-----...\n\n🔧 Step 4: Restart Application\nRestart your application to load the new environment variables.`);
@@ -147,22 +148,27 @@ export class GoogleVertexProvider extends BaseProvider {
         }
     }
     handleProviderError(error) {
-        if (error.name === "TimeoutError") {
+        const errorRecord = error;
+        if (typeof errorRecord?.name === "string" &&
+            errorRecord.name === "TimeoutError") {
             return new TimeoutError(`Google Vertex AI request timed out. Consider increasing timeout or using a lighter model.`, this.defaultTimeout);
         }
-        if (error.message?.includes("PERMISSION_DENIED")) {
+        const message = typeof errorRecord?.message === "string"
+            ? 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`);
         }
-        if (error.message?.includes("NOT_FOUND")) {
-            return new Error(`❌ Google Vertex AI Model Not Found\n\n${error.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`);
+        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`);
         }
-        if (error.message?.includes("QUOTA_EXCEEDED")) {
-            return new Error(`❌ Google Vertex AI Quota Exceeded\n\n${error.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`);
+        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`);
         }
-        if (error.message?.includes("INVALID_ARGUMENT")) {
-            return new Error(`❌ Google Vertex AI Invalid Request\n\n${error.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`);
+        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 Provider Error\n\n${error.message || "Unknown error occurred"}\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\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`);
     }
     validateStreamOptions(options) {
         if (!options.input?.text?.trim()) {

package/dist/providers/huggingFace.d.ts

@@ -33,7 +33,7 @@ export declare class HuggingFaceProvider extends BaseProvider {
      * Returns the Vercel AI SDK model instance for HuggingFace
      */
     protected getAISDKModel(): LanguageModelV1;
-    protected handleProviderError(error: any): Error;
+    protected handleProviderError(error: unknown): Error;
     private validateStreamOptions;
 }
 export default HuggingFaceProvider;

package/dist/providers/huggingFace.js

@@ -114,14 +114,18 @@ export class HuggingFaceProvider extends BaseProvider {
         if (error instanceof TimeoutError) {
             return new Error(`HuggingFace request timed out: ${error.message}`);
         }
-        if (error?.message?.includes("API_TOKEN_INVALID") ||
-            error?.message?.includes("Invalid token")) {
+        const errorObj = error;
+        const message = errorObj?.message && typeof errorObj.message === "string"
+            ? errorObj.message
+            : "Unknown error";
+        if (message.includes("API_TOKEN_INVALID") ||
+            message.includes("Invalid token")) {
             return new Error("Invalid HuggingFace API token. Please check your HUGGING_FACE_API_KEY environment variable.");
         }
-        if (error?.message?.includes("rate limit")) {
+        if (message.includes("rate limit")) {
             return new Error("HuggingFace rate limit exceeded. Please try again later.");
         }
-        return new Error(`HuggingFace error: ${error?.message || "Unknown error"}`);
+        return new Error(`HuggingFace error: ${message}`);
     }
     // ===================
     // PRIVATE VALIDATION METHODS

package/dist/providers/mcp-provider.d.ts

@@ -2,7 +2,7 @@
  * NeuroLink MCP-Aware AI Provider
  * Integrates MCP tools with AI providers following Lighthouse's pattern
  */
-import type { AIProvider, TextGenerationOptions, EnhancedGenerateResult } from "../core/types.js";
+import type { AIProvider, TextGenerationOptions } from "../core/types.js";
 import type { Schema } from "ai";
 import type { GenerateResult } from "../types/generate-types.js";
 import type { ZodType, ZodTypeDef } from "zod";
@@ -37,7 +37,7 @@ export declare class MCPAwareProvider implements AIProvider {
      * PRIMARY METHOD: Stream content using AI (recommended for new code)
      * Future-ready for multi-modal capabilities with current text focus
      */
-    stream(optionsOrPrompt: StreamOptions | string, analysisSchema?: any): Promise<StreamResult>;
+    stream(optionsOrPrompt: StreamOptions | string, analysisSchema?: unknown): Promise<StreamResult>;
     generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateResult>;
     /**
      * Detect if the prompt is requesting tool usage
@@ -63,7 +63,7 @@ export declare class MCPAwareProvider implements AIProvider {
     /**
      * Short alias for generate() - CLI-SDK consistency
      */
-    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateResult | null>;
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateResult>;
 }
 /**
  * Create an MCP-aware provider

package/dist/providers/mcp-provider.js

@@ -62,11 +62,26 @@ export class MCPAwareProvider {
                     exists: async () => false,
                 },
                 path: {
-                    join: (...paths) => require("path").join(...paths),
-                    resolve: (...paths) => require("path").resolve(...paths),
-                    relative: (from, to) => require("path").relative(from, to),
-                    dirname: (path) => require("path").dirname(path),
-                    basename: (path, ext) => require("path").basename(path, ext),
+                    join: (...paths) => {
+                        const pathModule = require("path");
+                        return pathModule.join(...paths);
+                    },
+                    resolve: (...paths) => {
+                        const pathModule = require("path");
+                        return pathModule.resolve(...paths);
+                    },
+                    relative: (from, to) => {
+                        const pathModule = require("path");
+                        return pathModule.relative(from, to);
+                    },
+                    dirname: (pathArg) => {
+                        const pathModule = require("path");
+                        return pathModule.dirname(pathArg);
+                    },
+                    basename: (pathArg, ext) => {
+                        const pathModule = require("path");
+                        return pathModule.basename(pathArg, ext);
+                    },
                 },
                 grantedPermissions: [],
                 log: console.log,

package/dist/providers/mistral.d.ts

@@ -1,42 +1,49 @@
-import type { ZodType, ZodTypeDef } from "zod";
-import { type Schema, type LanguageModelV1 } from "ai";
-import type { AIProviderName } from "../core/types.js";
+import { type LanguageModelV1 } from "ai";
+import type { AIProviderName, TextGenerationOptions, EnhancedGenerateResult } from "../core/types.js";
 import type { StreamOptions, StreamResult } from "../types/stream-types.js";
 import { BaseProvider } from "../core/base-provider.js";
 /**
  * Mistral AI Provider v2 - BaseProvider Implementation
- *
- * PHASE 3.6: Simple BaseProvider wrap around existing @ai-sdk/mistral implementation
- *
- * Features:
- * - Extends BaseProvider for shared functionality
- * - Uses pre-configured Mistral instance for efficiency
- * - Enhanced error handling with setup guidance
- * - Supports all Mistral models (mistral-small, mistral-medium, mistral-large)
+ * Supports official AI-SDK integration with all Mistral models
  */
 export declare class MistralProvider extends BaseProvider {
-    private mistral;
     private model;
-    constructor(modelName?: string, sdk?: any);
-    protected getProviderName(): AIProviderName;
-    protected getDefaultModel(): string;
+    constructor(modelName?: string, sdk?: unknown);
     /**
-     * Returns the Vercel AI SDK model instance for Mistral
+     * Generate text using Mistral API
      */
-    protected getAISDKModel(): LanguageModelV1;
-    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
-    protected handleProviderError(error: any): Error;
-    private validateStreamOptions;
+    generate(options: TextGenerationOptions): Promise<EnhancedGenerateResult>;
     /**
-     * Check available Mistral models
-     * @returns Array of available model names
+     * Stream text generation using Mistral API
      */
-    getAvailableModels(): string[];
+    executeStream(options: StreamOptions): Promise<StreamResult>;
     /**
-     * Get recommended model based on use case
-     * @param useCase - The intended use case
-     * @returns Recommended model name
+     * Get default model name for this provider
      */
-    getRecommendedModel(useCase: "speed" | "balanced" | "quality"): string;
+    getDefaultModel(): string;
+    /**
+     * Get provider name
+     */
+    getProviderName(): AIProviderName;
+    /**
+     * Get AI SDK model instance
+     */
+    getAISDKModel(): LanguageModelV1;
+    /**
+     * Handle provider-specific errors
+     */
+    handleProviderError(error: unknown): Error;
+    /**
+     * Validate provider configuration
+     */
+    validateConfiguration(): Promise<boolean>;
+    /**
+     * Get provider-specific configuration
+     */
+    getConfiguration(): {
+        provider: AIProviderName;
+        model: string;
+        defaultModel: string;
+    };
 }
 export default MistralProvider;