@juspay/neurolink 5.3.0 → 6.0.0

package/dist/lib/mcp/unified-registry.d.ts

@@ -2,7 +2,17 @@
  * Unified MCP Registry - Combines Multiple Registration Sources
  */
 import type { DiscoveredMCP, ExecutionContext } from "./contracts/mcp-contract.js";
+import type { JsonValue } from "../types/common.js";
 import type { DiscoveryOptions } from "./auto-discovery.js";
+interface MCPServerConfig {
+    name: string;
+    id?: string;
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    transport?: string;
+    [key: string]: JsonValue | undefined;
+}
 import { MCPToolRegistry, type ToolInfo } from "./tool-registry.js";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { ErrorManager } from "./error-manager.js";
@@ -53,7 +63,7 @@ export declare class UnifiedMCPRegistry extends MCPToolRegistry {
     /**
      * Get manual servers
      */
-    getManualServers(): Map<string, any>;
+    getManualServers(): Map<string, MCPServerConfig>;
     /**
      * List all tools from all registered plugins
      */
@@ -73,7 +83,7 @@ export declare class UnifiedMCPRegistry extends MCPToolRegistry {
     /**
      * Register a manual server
      */
-    registerManualServer(id: string, server: any): void;
+    registerManualServer(id: string, server: MCPServerConfig): void;
     /**
      * Get registry statistics (override parent method)
      */
@@ -142,8 +152,14 @@ export declare class UnifiedMCPRegistry extends MCPToolRegistry {
      * Clear all registries and close active connections asynchronously
      */
     clearAsync(): Promise<void>;
+    /**
+     * Convert unknown arguments to JsonValue for CLI compatibility
+     * Attempts to serialize complex types to JSON-safe format
+     */
+    private toJsonValue;
 }
 /**
  * Default unified registry instance
  */
 export declare const unifiedRegistry: UnifiedMCPRegistry;
+export {};

package/dist/lib/mcp/unified-registry.js

@@ -284,7 +284,25 @@ export class UnifiedMCPRegistry extends MCPToolRegistry {
                 unifiedRegistryLogger.debug(`Trying tool ${toolName} on server ${serverId}`);
                 // Import the executeMCPTool function
                 const { executeMCPTool } = await import("../../cli/commands/mcp.js");
-                const result = await executeMCPTool(serverConfig, toolName, args || {});
+                const typedServerConfig = serverConfig;
+                const mcpServerConfig = {
+                    name: serverId,
+                    command: (typeof typedServerConfig.command === "string"
+                        ? typedServerConfig.command
+                        : "npx"),
+                    args: (Array.isArray(typedServerConfig.args)
+                        ? typedServerConfig.args
+                        : []),
+                    env: (typeof typedServerConfig.env === "object" &&
+                        typedServerConfig.env
+                        ? typedServerConfig.env
+                        : {}),
+                    cwd: typeof typedServerConfig.cwd === "string"
+                        ? typedServerConfig.cwd
+                        : undefined,
+                    transport: typedServerConfig.transport || "stdio",
+                };
+                const result = await executeMCPTool(mcpServerConfig, toolName, this.toJsonValue(args || {}));
                 // Convert to ToolResult format
                 const toolResult = {
                     success: true,
@@ -349,7 +367,8 @@ export class UnifiedMCPRegistry extends MCPToolRegistry {
         const bySource = {};
         const byType = {};
         for (const plugin of plugins) {
-            const source = plugin.source || "unknown";
+            const source = plugin.source ||
+                "unknown";
             bySource[source] = (bySource[source] || 0) + 1;
             // Extract type from name or metadata
             const type = plugin.metadata.name.split("/")[1]?.split("-")[0] || "unknown";
@@ -388,7 +407,11 @@ export class UnifiedMCPRegistry extends MCPToolRegistry {
         };
         // Register in internal registry
         this.register(serverMeta);
-        this.manualServers.set(serverId, config);
+        this.manualServers.set(serverId, {
+            ...config,
+            name: serverId,
+            command: config.command || "npx",
+        });
         this.availableServers.add(serverId);
         // Establish actual connection to make server immediately reachable
         try {
@@ -482,6 +505,32 @@ export class UnifiedMCPRegistry extends MCPToolRegistry {
         // Clear registries without attempting to close connections again
         this.clearRegistriesOnly();
     }
+    /**
+     * Convert unknown arguments to JsonValue for CLI compatibility
+     * Attempts to serialize complex types to JSON-safe format
+     */
+    toJsonValue(args) {
+        try {
+            // First try to use it directly if it's already a JsonValue
+            if (args === null ||
+                typeof args === "string" ||
+                typeof args === "number" ||
+                typeof args === "boolean") {
+                return args;
+            }
+            // For objects and arrays, try JSON round-trip to ensure serialization
+            if (typeof args === "object") {
+                return JSON.parse(JSON.stringify(args));
+            }
+            // For other types, convert to string
+            return String(args);
+        }
+        catch (error) {
+            // If serialization fails, return empty object as fallback
+            unifiedRegistryLogger.warn("Failed to convert args to JsonValue, using empty object:", error);
+            return {};
+        }
+    }
 }
 /**
  * Default unified registry instance

package/dist/lib/neurolink.d.ts

@@ -36,7 +36,7 @@ export interface MCPServerInfo {
     source: string;
     status: "connected" | "discovered" | "failed";
     hasServer: boolean;
-    metadata?: any;
+    metadata?: unknown;
 }
 export declare class NeuroLink {
     private mcpInitialized;
@@ -132,7 +132,7 @@ export declare class NeuroLink {
      * @param options - Execution options
      * @returns Tool execution result
      */
-    executeTool<T = any>(toolName: string, params?: any, options?: {
+    executeTool<T = unknown>(toolName: string, params?: unknown, options?: {
         timeout?: number;
     }): Promise<T>;
     /**

package/dist/lib/neurolink.js

@@ -112,20 +112,45 @@ export class NeuroLink {
                 : undefined,
             responseTime: textResult.responseTime,
             toolsUsed: textResult.toolsUsed,
-            toolExecutions: textResult.toolExecutions?.map((te) => ({
-                name: te.toolName || te.name || "",
-                input: te.input || {},
-                output: te.output || te.result,
-                duration: te.executionTime || te.duration || 0,
-            })),
+            toolExecutions: textResult.toolExecutions?.map((te) => {
+                const teRecord = te;
+                return {
+                    name: te.toolName || teRecord.name || "",
+                    input: teRecord.input ||
+                        teRecord.args ||
+                        {},
+                    output: teRecord.output ||
+                        teRecord.result ||
+                        (te.success ? "success" : "failed"),
+                    duration: te.executionTime || teRecord.duration || 0,
+                };
+            }),
             enhancedWithTools: textResult.enhancedWithTools,
-            availableTools: textResult.availableTools?.map((tool) => ({
-                name: tool.name || "",
-                description: tool.description || "",
-                parameters: tool.parameters || {},
-            })),
+            availableTools: textResult.availableTools?.map((tool) => {
+                const toolRecord = tool;
+                return {
+                    name: tool.name || "",
+                    description: tool.description || "",
+                    parameters: toolRecord.parameters ||
+                        toolRecord.schema ||
+                        {},
+                };
+            }),
             analytics: textResult.analytics,
-            evaluation: textResult.evaluation,
+            evaluation: textResult.evaluation
+                ? {
+                    ...textResult.evaluation,
+                    isOffTopic: textResult.evaluation
+                        .isOffTopic ?? false,
+                    alertSeverity: textResult.evaluation.alertSeverity ?? "none",
+                    reasoning: textResult.evaluation.reasoning ??
+                        "No evaluation provided",
+                    evaluationModel: textResult.evaluation
+                        .evaluationModel ?? "unknown",
+                    evaluationTime: textResult.evaluation
+                        .evaluationTime ?? Date.now(),
+                }
+                : undefined,
         };
         return generateResult;
     }
@@ -213,9 +238,9 @@ export class NeuroLink {
             try {
                 const allTools = await toolRegistry.listTools();
                 availableTools = allTools.map((tool) => ({
-                    name: tool.name,
+                    name: tool.name || "Unknown",
                     description: tool.description || "No description available",
-                    server: tool.server,
+                    server: tool.server || "Unknown",
                     category: tool.category,
                 }));
             }
@@ -245,7 +270,7 @@ export class NeuroLink {
                 toolsUsed: [],
                 enhancedWithTools: true,
                 availableTools: availableTools.length > 0 ? availableTools : undefined,
-                // 🔧 FIX: Include analytics and evaluation from BaseProvider
+                // Include analytics and evaluation from BaseProvider
                 analytics: result.analytics,
                 evaluation: result.evaluation,
             };

package/dist/lib/providers/amazon-bedrock.d.ts

@@ -26,7 +26,7 @@ export declare class AmazonBedrockProvider extends BaseProvider {
      */
     protected getAISDKModel(): 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;
 }
 export default AmazonBedrockProvider;

package/dist/lib/providers/amazon-bedrock.js

@@ -112,19 +112,20 @@ export class AmazonBedrockProvider extends BaseProvider {
         }
     }
     handleProviderError(error) {
-        if (error.name === "TimeoutError") {
+        if (error instanceof Error && error.name === "TimeoutError") {
             return new TimeoutError(`Amazon Bedrock request timed out. Consider increasing timeout or using a lighter model.`, this.defaultTimeout);
         }
-        if (error.message?.includes("InvalidRequestException")) {
-            return new Error(`❌ Amazon Bedrock Request Error\n\nThe request was invalid: ${error.message}\n\n🔧 Common Solutions:\n1. Check your model ID format\n2. Verify your request parameters\n3. Ensure your AWS account has Bedrock access`);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.includes("InvalidRequestException")) {
+            return new Error(`❌ Amazon Bedrock Request Error\n\nThe request was invalid: ${errorMessage}\n\n🔧 Common Solutions:\n1. Check your model ID format\n2. Verify your request parameters\n3. Ensure your AWS account has Bedrock access`);
         }
-        if (error.message?.includes("AccessDeniedException")) {
+        if (errorMessage.includes("AccessDeniedException")) {
             return new Error(`❌ Amazon Bedrock Access Denied\n\nYour AWS credentials don't have permission to access Bedrock.\n\n🔧 Required Steps:\n1. Ensure your IAM user has bedrock:InvokeModel permission\n2. Check if Bedrock is available in your region\n3. Verify model access is enabled in Bedrock console`);
         }
-        if (error.message?.includes("ValidationException")) {
-            return new Error(`❌ Amazon Bedrock Validation Error\n\n${error.message}\n\n🔧 Check:\n1. Model ID format (should be ARN or model identifier)\n2. Request parameters are within limits\n3. Region configuration is correct`);
+        if (errorMessage.includes("ValidationException")) {
+            return new Error(`❌ Amazon Bedrock Validation Error\n\n${errorMessage}\n\n🔧 Check:\n1. Model ID format (should be ARN or model identifier)\n2. Request parameters are within limits\n3. Region configuration is correct`);
         }
-        return new Error(`❌ Amazon Bedrock Provider Error\n\n${error.message || "Unknown error occurred"}\n\n🔧 Troubleshooting:\n1. Check AWS credentials and permissions\n2. Verify model availability\n3. Check network connectivity`);
+        return new Error(`❌ Amazon Bedrock Provider Error\n\n${errorMessage || "Unknown error occurred"}\n\n🔧 Troubleshooting:\n1. Check AWS credentials and permissions\n2. Verify model availability\n3. Check network connectivity`);
     }
     validateStreamOptions(options) {
         if (!options.input?.text?.trim()) {

package/dist/lib/providers/analytics-helper.d.ts

@@ -3,18 +3,9 @@
  * Ensures consistent analytics data format across providers
  * Integrates with Universal Evaluation System
  */
-export interface AnalyticsData {
-    provider: string;
-    model: string;
-    tokens: {
-        input: number;
-        output: number;
-        total: number;
-    };
-    cost?: number;
-    responseTime: number;
-    timestamp: string;
-    context?: Record<string, any>;
+import type { UnknownRecord } from "../types/common.js";
+import type { AnalyticsData as CoreAnalyticsData } from "../core/types.js";
+export interface AnalyticsData extends CoreAnalyticsData {
     evaluation?: {
         relevanceScore: number;
         accuracyScore: number;
@@ -24,30 +15,24 @@ export interface AnalyticsData {
         evaluationTime?: number;
         evaluationAttempt?: number;
     };
-    costDetails?: {
-        inputCost: number;
-        outputCost: number;
-        evaluationCost?: number;
-        totalCost: number;
-        currency: string;
-    };
+    costDetails?: UnknownRecord;
 }
 /**
  * Create standardized analytics data from provider response
  */
-export declare function createAnalytics(provider: string, model: string, result: any, responseTime: number, context?: Record<string, any>): AnalyticsData;
+export declare function createAnalytics(provider: string, model: string, result: unknown, responseTime: number, context?: Record<string, unknown>): AnalyticsData;
 /**
  * Create enhanced analytics data with accurate cost calculations (async version)
  */
-export declare function createEnhancedAnalytics(provider: string, model: string, result: any, responseTime: number, context?: Record<string, any>): Promise<AnalyticsData>;
+export declare function createEnhancedAnalytics(provider: string, model: string, result: unknown, responseTime: number, context?: Record<string, unknown>): Promise<AnalyticsData>;
 /**
  * Calculate enhanced cost details using provider configurations
  */
 export declare function calculateEnhancedCost(provider: string, inputTokens: number, outputTokens: number): Promise<{
-    costDetails: any;
+    costDetails: UnknownRecord;
     estimatedCost: number;
 }>;
 /**
  * Enhance analytics with evaluation data
  */
-export declare function enhanceAnalyticsWithEvaluation(analytics: AnalyticsData, evaluationResult: any): AnalyticsData;
+export declare function enhanceAnalyticsWithEvaluation(analytics: AnalyticsData, evaluationResult: UnknownRecord): AnalyticsData;

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) {