@juspay/neurolink 5.2.0 → 6.0.0

package/dist/lib/providers/analytics-helper.js

@@ -3,23 +3,43 @@
  * Ensures consistent analytics data format across providers
  * Integrates with Universal Evaluation System
  */
+// Type guard for checking if an unknown value is a number
+function isNumber(value) {
+    return typeof value === "number" && !isNaN(value);
+}
+// Type guard for checking if an unknown value is an object
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 /**
  * Create standardized analytics data from provider response
  */
 export function createAnalytics(provider, model, result, responseTime, context) {
     // Handle different token usage formats across providers
-    const tokenUsage = result.usage || {};
+    const tokenUsage = result?.usage || {};
     // Standardize token field names across providers
-    const inputTokens = tokenUsage.promptTokens ||
-        tokenUsage.input_tokens ||
-        tokenUsage.inputTokens ||
+    const inputTokens = (typeof tokenUsage.promptTokens === "number"
+        ? tokenUsage.promptTokens
+        : 0) ||
+        (typeof tokenUsage.input_tokens === "number"
+            ? tokenUsage.input_tokens
+            : 0) ||
+        (typeof tokenUsage.inputTokens === "number" ? tokenUsage.inputTokens : 0) ||
         0;
-    const outputTokens = tokenUsage.completionTokens ||
-        tokenUsage.output_tokens ||
-        tokenUsage.outputTokens ||
+    const outputTokens = (typeof tokenUsage.completionTokens === "number"
+        ? tokenUsage.completionTokens
+        : 0) ||
+        (typeof tokenUsage.output_tokens === "number"
+            ? tokenUsage.output_tokens
+            : 0) ||
+        (typeof tokenUsage.outputTokens === "number"
+            ? tokenUsage.outputTokens
+            : 0) ||
         0;
-    const totalTokens = tokenUsage.totalTokens ||
-        tokenUsage.total_tokens ||
+    const totalTokens = (typeof tokenUsage.totalTokens === "number" ? tokenUsage.totalTokens : 0) ||
+        (typeof tokenUsage.total_tokens === "number"
+            ? tokenUsage.total_tokens
+            : 0) ||
         inputTokens + outputTokens ||
         0;
     // Simple cost estimation for synchronous use
@@ -35,7 +55,7 @@ export function createAnalytics(provider, model, result, responseTime, context)
         cost: estimatedCost,
         responseTime,
         timestamp: new Date().toISOString(),
-        context,
+        context: context,
     };
 }
 /**
@@ -43,18 +63,30 @@ export function createAnalytics(provider, model, result, responseTime, context)
  */
 export async function createEnhancedAnalytics(provider, model, result, responseTime, context) {
     // Handle different token usage formats across providers
-    const tokenUsage = result.usage || {};
+    const tokenUsage = result?.usage || {};
     // Standardize token field names across providers
-    const inputTokens = tokenUsage.promptTokens ||
-        tokenUsage.input_tokens ||
-        tokenUsage.inputTokens ||
+    const inputTokens = (typeof tokenUsage.promptTokens === "number"
+        ? tokenUsage.promptTokens
+        : 0) ||
+        (typeof tokenUsage.input_tokens === "number"
+            ? tokenUsage.input_tokens
+            : 0) ||
+        (typeof tokenUsage.inputTokens === "number" ? tokenUsage.inputTokens : 0) ||
         0;
-    const outputTokens = tokenUsage.completionTokens ||
-        tokenUsage.output_tokens ||
-        tokenUsage.outputTokens ||
+    const outputTokens = (typeof tokenUsage.completionTokens === "number"
+        ? tokenUsage.completionTokens
+        : 0) ||
+        (typeof tokenUsage.output_tokens === "number"
+            ? tokenUsage.output_tokens
+            : 0) ||
+        (typeof tokenUsage.outputTokens === "number"
+            ? tokenUsage.outputTokens
+            : 0) ||
         0;
-    const totalTokens = tokenUsage.totalTokens ||
-        tokenUsage.total_tokens ||
+    const totalTokens = (typeof tokenUsage.totalTokens === "number" ? tokenUsage.totalTokens : 0) ||
+        (typeof tokenUsage.total_tokens === "number"
+            ? tokenUsage.total_tokens
+            : 0) ||
         inputTokens + outputTokens ||
         0;
     // Enhanced cost calculation using provider configuration
@@ -70,7 +102,7 @@ export async function createEnhancedAnalytics(provider, model, result, responseT
         cost: estimatedCost,
         responseTime,
         timestamp: new Date().toISOString(),
-        context,
+        context: context,
         costDetails,
     };
 }
@@ -127,27 +159,57 @@ export async function calculateEnhancedCost(provider, inputTokens, outputTokens)
  * Enhance analytics with evaluation data
  */
 export function enhanceAnalyticsWithEvaluation(analytics, evaluationResult) {
+    // Helper function to safely extract number values with fallback
+    const getNumberValue = (obj, ...keys) => {
+        for (const key of keys) {
+            const value = obj[key];
+            if (isNumber(value)) {
+                return value;
+            }
+        }
+        return 1; // Default minimum score
+    };
+    // Helper function to safely extract evaluation config cost
+    const getEvaluationCost = (obj) => {
+        const evaluationConfig = obj.evaluationConfig;
+        if (isRecord(evaluationConfig)) {
+            const costEstimate = evaluationConfig.costEstimate;
+            return isNumber(costEstimate) ? costEstimate : 0;
+        }
+        return 0;
+    };
+    // Helper function to safely get existing total cost
+    const getExistingTotalCost = (costDetails) => {
+        if (!costDetails) {
+            return 0;
+        }
+        const totalCost = costDetails.totalCost;
+        return isNumber(totalCost) ? totalCost : 0;
+    };
+    const evaluationCost = getEvaluationCost(evaluationResult);
     return {
         ...analytics,
         evaluation: {
-            // FIX: Use correct field names and ensure minimum score of 1
-            relevanceScore: evaluationResult.relevance || evaluationResult.relevanceScore || 1,
-            accuracyScore: evaluationResult.accuracy || evaluationResult.accuracyScore || 1,
-            completenessScore: evaluationResult.completeness ||
-                evaluationResult.completenessScore ||
-                1,
-            overall: evaluationResult.overall || 1,
-            evaluationProvider: evaluationResult.evaluationProvider,
-            evaluationTime: evaluationResult.evaluationTime,
-            evaluationAttempt: evaluationResult.evaluationAttempt,
+            relevanceScore: getNumberValue(evaluationResult, "relevance", "relevanceScore"),
+            accuracyScore: getNumberValue(evaluationResult, "accuracy", "accuracyScore"),
+            completenessScore: getNumberValue(evaluationResult, "completeness", "completenessScore"),
+            overall: getNumberValue(evaluationResult, "overall"),
+            evaluationProvider: typeof evaluationResult.evaluationProvider === "string"
+                ? evaluationResult.evaluationProvider
+                : undefined,
+            evaluationTime: isNumber(evaluationResult.evaluationTime)
+                ? evaluationResult.evaluationTime
+                : undefined,
+            evaluationAttempt: isNumber(evaluationResult.evaluationAttempt)
+                ? evaluationResult.evaluationAttempt
+                : undefined,
         },
         // Add evaluation cost if available
         costDetails: analytics.costDetails
             ? {
                 ...analytics.costDetails,
-                evaluationCost: evaluationResult.evaluationConfig?.costEstimate || 0,
-                totalCost: (analytics.costDetails.totalCost || 0) +
-                    (evaluationResult.evaluationConfig?.costEstimate || 0),
+                evaluationCost,
+                totalCost: getExistingTotalCost(analytics.costDetails) + evaluationCost,
             }
             : undefined,
     };

package/dist/lib/providers/anthropic-baseprovider.d.ts

@@ -1,5 +1,5 @@
 import type { ZodType, ZodTypeDef } from "zod";
-import { type Schema } from "ai";
+import { type Schema, type LanguageModelV1 } from "ai";
 import type { AIProviderName } from "../core/types.js";
 import type { StreamOptions, StreamResult } from "../types/stream-types.js";
 import { BaseProvider } from "../core/base-provider.js";
@@ -15,8 +15,8 @@ export declare class AnthropicProviderV2 extends BaseProvider {
     /**
      * Returns the Vercel AI SDK model instance for Anthropic
      */
-    protected getAISDKModel(): any;
-    protected handleProviderError(error: any): Error;
+    protected getAISDKModel(): LanguageModelV1;
+    protected handleProviderError(error: unknown): Error;
     private getApiKey;
     protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
 }

package/dist/lib/providers/anthropic-baseprovider.js

@@ -38,16 +38,17 @@ export class AnthropicProviderV2 extends BaseProvider {
         if (error instanceof TimeoutError) {
             return new Error(`Anthropic request timed out: ${error.message}`);
         }
-        if (error?.status === 401) {
+        const errorWithStatus = error;
+        if (errorWithStatus?.status === 401) {
             return new Error("Invalid Anthropic API key. Please check your ANTHROPIC_API_KEY environment variable.");
         }
-        if (error?.status === 429) {
+        if (errorWithStatus?.status === 429) {
             return new Error("Anthropic rate limit exceeded. Please try again later.");
         }
-        if (error?.status === 400) {
-            return new Error(`Anthropic bad request: ${error?.message || "Invalid request parameters"}`);
+        if (errorWithStatus?.status === 400) {
+            return new Error(`Anthropic bad request: ${errorWithStatus?.message || "Invalid request parameters"}`);
         }
-        return new Error(`Anthropic error: ${error?.message || "Unknown error"}`);
+        return new Error(`Anthropic error: ${errorWithStatus?.message || String(error) || "Unknown error"}`);
     }
     getApiKey() {
         const apiKey = process.env.ANTHROPIC_API_KEY;

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

@@ -9,14 +9,14 @@ import { BaseProvider } from "../core/base-provider.js";
  */
 export declare class AnthropicProvider extends BaseProvider {
     private model;
-    constructor(modelName?: string, sdk?: any);
+    constructor(modelName?: string, sdk?: unknown);
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     /**
      * Returns the Vercel AI SDK model instance for Anthropic
      */
     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>;
     isAvailable(): Promise<boolean>;
     getModel(): LanguageModelV1;

package/dist/lib/providers/anthropic.js

@@ -47,14 +47,21 @@ export class AnthropicProvider extends BaseProvider {
         if (error instanceof TimeoutError) {
             return new Error(`Anthropic request timed out: ${error.message}`);
         }
-        if (error?.message?.includes("API_KEY_INVALID") ||
-            error?.message?.includes("Invalid API key")) {
+        const errorRecord = error;
+        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.");
         }
-        if (error?.message?.includes("rate limit")) {
+        if (typeof errorRecord?.message === "string" &&
+            errorRecord.message.includes("rate limit")) {
             return new Error("Anthropic rate limit exceeded. Please try again later.");
         }
-        return new Error(`Anthropic error: ${error?.message || "Unknown error"}`);
+        const message = typeof errorRecord?.message === "string"
+            ? errorRecord.message
+            : "Unknown error";
+        return new Error(`Anthropic error: ${message}`);
     }
     // executeGenerate removed - BaseProvider handles all generation with tools
     async executeStream(options, analysisSchema) {

package/dist/lib/providers/azure-openai.d.ts

@@ -1,3 +1,4 @@
+import { type LanguageModelV1 } from "ai";
 import { BaseProvider } from "../core/base-provider.js";
 import type { AIProviderName } from "../core/types.js";
 import type { StreamOptions, StreamResult } from "../types/stream-types.js";
@@ -7,14 +8,14 @@ export declare class AzureOpenAIProvider extends BaseProvider {
     private deployment;
     private apiVersion;
     private azureProvider;
-    constructor(modelName?: string);
+    constructor(modelName?: string, sdk?: unknown);
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     /**
      * Returns the Vercel AI SDK model instance for Azure OpenAI
      */
-    protected getAISDKModel(): any;
-    protected handleProviderError(error: any): Error;
-    protected executeStream(options: StreamOptions, analysisSchema?: any): Promise<StreamResult>;
+    protected getAISDKModel(): LanguageModelV1;
+    protected handleProviderError(error: unknown): Error;
+    protected executeStream(options: StreamOptions, analysisSchema?: unknown): Promise<StreamResult>;
 }
 export default AzureOpenAIProvider;

package/dist/lib/providers/azure-openai.js

@@ -7,8 +7,8 @@ export class AzureOpenAIProvider extends BaseProvider {
     deployment;
     apiVersion;
     azureProvider;
-    constructor(modelName) {
-        super(modelName, "azure");
+    constructor(modelName, sdk) {
+        super(modelName, "azure", sdk);
         this.apiKey = process.env.AZURE_OPENAI_API_KEY || "";
         const endpoint = process.env.AZURE_OPENAI_ENDPOINT || "";
         this.resourceName = endpoint
@@ -52,10 +52,16 @@ export class AzureOpenAIProvider extends BaseProvider {
         return this.azureProvider(this.deployment);
     }
     handleProviderError(error) {
-        if (error?.message?.includes("401")) {
+        const errorObj = error;
+        if (errorObj?.message &&
+            typeof errorObj.message === "string" &&
+            errorObj.message.includes("401")) {
             return new Error("Invalid Azure OpenAI API key or endpoint.");
         }
-        return new Error(`Azure OpenAI error: ${error?.message || "Unknown error"}`);
+        const message = errorObj?.message && typeof errorObj.message === "string"
+            ? errorObj.message
+            : "Unknown error";
+        return new Error(`Azure OpenAI error: ${message}`);
     }
     // executeGenerate removed - BaseProvider handles all generation with tools
     async executeStream(options, analysisSchema) {

package/dist/lib/providers/function-calling-provider.d.ts

@@ -16,22 +16,31 @@ export declare class FunctionCallingProvider implements AIProvider {
     private enableFunctionCalling;
     private sessionId;
     private userId;
+    private cachedToolsObject;
+    private cachedToolMap;
+    private cacheTimestamp;
+    private readonly cacheExpiryMs;
     constructor(baseProvider: AIProvider, options?: {
         enableFunctionCalling?: boolean;
         sessionId?: string;
         userId?: string;
+        cacheExpiryMs?: number;
     });
     /**
      * 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?: Schema): Promise<StreamResult>;
     /**
      * Generate text with real function calling support
      */
     generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<GenerateResult>;
     /**
-     * Generate text using AI SDK's native function calling
+     * Generate text with tools using the AI SDK's generate function (with tools object)
+     */
+    private generateWithToolsObject;
+    /**
+     * Generate text using AI SDK's native function calling (legacy array-based)
      */
     private generateWithTools;
     /**
@@ -44,7 +53,11 @@ export declare class FunctionCallingProvider implements AIProvider {
      */
     private sanitizeToolName;
     /**
-     * Convert our tools to AI SDK format with proper execution
+     * Wrap tools with proper execution context (for object-based tools)
+     */
+    private wrapToolsWithExecution;
+    /**
+     * Convert our tools to AI SDK format with proper execution (legacy array-based)
      */
     private convertToAISDKTools;
     /**
@@ -54,10 +67,57 @@ export declare class FunctionCallingProvider implements AIProvider {
     /**
      * 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(): void;
     /**
      * Short alias for generate() - CLI-SDK consistency
      */
-    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateResult | null>;
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: Schema): Promise<EnhancedGenerateResult | null>;
 }
 /**
  * Create a function-calling enhanced version of any AI provider
@@ -66,6 +126,7 @@ export declare function createFunctionCallingProvider(baseProvider: AIProvider,
     enableFunctionCalling?: boolean;
     sessionId?: string;
     userId?: string;
+    cacheExpiryMs?: number;
 }): AIProvider;
 /**
  * Enhanced MCP Provider Factory that creates function-calling enabled providers
@@ -77,4 +138,5 @@ export declare function createMCPAwareProviderV3(baseProvider: AIProvider, optio
     enableFunctionCalling?: boolean;
     sessionId?: string;
     userId?: string;
+    cacheExpiryMs?: number;
 }): AIProvider;