@juspay/neurolink 5.3.0 → 6.1.0

package/dist/cli/commands/ollama.js

@@ -41,7 +41,8 @@ async function listModelsHandler() {
     }
     catch (error) {
         spinner.fail("Failed to list models. Is Ollama installed?");
-        console.error(chalk.red("Error:", error.message));
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(chalk.red("Error:", errorMessage));
         console.log(chalk.blue("\nTip: Install Ollama from https://ollama.ai"));
         process.exit(1);
     }
@@ -57,7 +58,8 @@ async function pullModelHandler(argv) {
     }
     catch (error) {
         console.error(chalk.red(`\n❌ Failed to download ${model}`));
-        console.error(chalk.red("Error:", error.message));
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(chalk.red("Error:", errorMessage));
         process.exit(1);
     }
 }
@@ -83,7 +85,8 @@ async function removeModelHandler(argv) {
     }
     catch (error) {
         spinner.fail(`Failed to remove ${model}`);
-        console.error(chalk.red("Error:", error.message));
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(chalk.red("Error:", errorMessage));
         process.exit(1);
     }
 }
@@ -163,7 +166,8 @@ async function startHandler() {
     }
     catch (error) {
         console.error(chalk.red("Failed to start Ollama service"));
-        console.error(chalk.red("Error:", error.message));
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(chalk.red("Error:", errorMessage));
         console.log(chalk.blue("\nTry starting Ollama manually or check installation"));
         process.exit(1);
     }

package/dist/cli/factories/command-factory.d.ts

@@ -1,4 +1,5 @@
 import type { CommandModule } from "yargs";
+import type { UnknownRecord } from "../../lib/types/common.js";
 /**
  * CLI Command Factory for generate commands
  */
@@ -10,7 +11,7 @@ export declare class CLICommandFactory {
     /**
      * Execute provider status command
      */
-    executeProviderStatus(argv: any): Promise<void>;
+    executeProviderStatus(argv: UnknownRecord): Promise<void>;
     /**
      * Execute the generate command
      */

package/dist/cli/index.js

@@ -23,10 +23,6 @@ import { addMCPCommands } from "./commands/mcp.js";
 import { addOllamaCommands } from "./commands/ollama.js";
 import { CLICommandFactory } from "./factories/command-factory.js";
 import { logger } from "../lib/utils/logger.js";
-/**
- * Helper functions for displaying analytics and evaluation results
- * Addresses DRY principle - extracted shared parts into reusable functions
- */
 function displayDebugInfo(title, data, debug) {
     if (debug) {
         console.log(chalk.blue(title));
@@ -45,11 +41,13 @@ function formatAnalytics(analytics) {
     console.log(`   🚀 Provider: ${analytics.provider}`);
     console.log(`   🤖 Model: ${analytics.model}`);
     if (analytics.tokens) {
-        console.log(`   💬 Tokens: ${analytics.tokens.totalTokens || analytics.tokens.total || "unknown"}`);
+        const tokens = analytics.tokens;
+        console.log(`   💬 Tokens: ${tokens.totalTokens || tokens.total || "unknown"}`);
     }
     console.log(`   ⏱️  Response Time: ${analytics.responseTime}ms`);
     if (analytics.context) {
-        console.log(`   📋 Context: ${Object.keys(analytics.context).length} fields`);
+        const context = analytics.context;
+        console.log(`   📋 Context: ${Object.keys(context).length} fields`);
     }
     console.log();
 }
@@ -537,24 +535,27 @@ const cli = yargs(args)
                 console.log("\n" + responseText + "\n");
             }
             // Show tool calls if any
-            if (result &&
-                result.toolCalls &&
-                result.toolCalls.length > 0) {
+            const typedResultForTools = result;
+            if (typedResultForTools &&
+                typedResultForTools.toolCalls &&
+                typedResultForTools.toolCalls.length > 0) {
                 console.log(chalk.blue("🔧 Tools Called:"));
-                for (const toolCall of result.toolCalls) {
-                    console.log(`- ${toolCall.toolName}`);
-                    console.log(`  Args: ${JSON.stringify(toolCall.args)}`);
+                for (const toolCall of typedResultForTools.toolCalls) {
+                    const toolCallObj = toolCall;
+                    console.log(`- ${toolCallObj.toolName}`);
+                    console.log(`  Args: ${JSON.stringify(toolCallObj.args)}`);
                 }
                 console.log();
             }
             // Show tool results if any
-            if (result &&
-                result.toolResults &&
-                result.toolResults.length > 0) {
+            if (typedResultForTools &&
+                typedResultForTools.toolResults &&
+                typedResultForTools.toolResults.length > 0) {
                 console.log(chalk.blue("📋 Tool Results:"));
-                for (const toolResult of result.toolResults) {
-                    console.log(`- ${toolResult.toolCallId}`);
-                    console.log(`  Result: ${JSON.stringify(toolResult.result).substring(0, 200)}...`);
+                for (const toolResult of typedResultForTools.toolResults) {
+                    const toolResultObj = toolResult;
+                    console.log(`- ${toolResultObj.toolCallId}`);
+                    console.log(`  Result: ${JSON.stringify(toolResultObj.result).substring(0, 200)}...`);
                 }
                 console.log();
             }
@@ -578,7 +579,9 @@ const cli = yargs(args)
                     ? result.provider || argv.provider
                     : argv.provider,
                 usage: responseUsage,
-                responseTime: result ? result.responseTime || 0 : 0,
+                responseTime: result
+                    ? result.responseTime || 0
+                    : 0,
             }, null, 2));
             if (responseUsage.totalTokens) {
                 console.log(chalk.blue(`ℹ️  ${responseUsage.totalTokens} tokens used`));

package/dist/core/analytics.d.ts

@@ -4,6 +4,7 @@
  * Provides lightweight analytics tracking for AI provider usage,
  * including tokens, costs, performance metrics, and custom context.
  */
+import type { JsonValue, UnknownRecord } from "../types/common.js";
 export interface AnalyticsData {
     provider: string;
     model: string;
@@ -14,10 +15,10 @@ export interface AnalyticsData {
     };
     cost?: number;
     responseTime: number;
-    context?: Record<string, any>;
+    context?: Record<string, JsonValue>;
     timestamp: string;
 }
 /**
  * Create analytics data structure from AI 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: UnknownRecord, responseTime: number, context?: Record<string, JsonValue>): AnalyticsData;

package/dist/core/analytics.js

@@ -51,23 +51,30 @@ export function createAnalytics(provider, model, result, responseTime, context)
  */
 function extractTokenUsage(result) {
     // Handle different response formats
-    if (result.usage) {
+    if (result.usage &&
+        typeof result.usage === "object" &&
+        result.usage !== null) {
         const usage = result.usage;
         // Standard format
-        if (usage.promptTokens !== undefined &&
-            usage.completionTokens !== undefined) {
+        if (typeof usage.promptTokens === "number" &&
+            typeof usage.completionTokens === "number") {
             return {
                 input: usage.promptTokens || 0,
                 output: usage.completionTokens || 0,
-                total: usage.totalTokens || usage.promptTokens + usage.completionTokens,
+                total: typeof usage.totalTokens === "number"
+                    ? usage.totalTokens
+                    : usage.promptTokens + usage.completionTokens,
             };
         }
         // Alternative formats
-        if (usage.input_tokens !== undefined && usage.output_tokens !== undefined) {
+        if (typeof usage.input_tokens === "number" &&
+            typeof usage.output_tokens === "number") {
             return {
                 input: usage.input_tokens || 0,
                 output: usage.output_tokens || 0,
-                total: usage.total_tokens || usage.input_tokens + usage.output_tokens,
+                total: typeof usage.total_tokens === "number"
+                    ? usage.total_tokens
+                    : usage.input_tokens + usage.output_tokens,
             };
         }
         // Generic tokens field
@@ -80,7 +87,9 @@ function extractTokenUsage(result) {
         }
     }
     // Fallback: estimate from text length
-    const textLength = result.text?.length || result.content?.length || 0;
+    const textLength = (typeof result.text === "string" ? result.text.length : 0) ||
+        (typeof result.content === "string" ? result.content.length : 0) ||
+        0;
     const estimatedTokens = Math.ceil(textLength / 4); // ~4 chars per token
     return {
         input: 0,

package/dist/core/base-provider.d.ts

@@ -1,8 +1,35 @@
 import type { ZodType, ZodTypeDef } from "zod";
 import type { Schema } from "ai";
-import type { Tool } from "ai";
-import type { AIProvider, TextGenerationOptions, EnhancedGenerateResult, AnalyticsData, AIProviderName } from "../core/types.js";
+import type { Tool, LanguageModel } from "ai";
+import type { AIProvider, TextGenerationOptions, EnhancedGenerateResult, AnalyticsData, AIProviderName, EvaluationData } from "../core/types.js";
 import type { StreamOptions, StreamResult } from "../types/stream-types.js";
+import type { JsonValue, UnknownRecord } from "../types/common.js";
+import type { ToolResult } from "../types/tools.js";
+/**
+ * Interface for SDK with in-memory MCP servers
+ */
+export interface NeuroLinkSDK {
+    getInMemoryServers?: () => Map<string, {
+        server: {
+            title?: string;
+            description?: string;
+            tools?: Map<string, ToolInfo> | Record<string, ToolInfo>;
+        };
+        category?: string;
+        metadata?: UnknownRecord;
+    }>;
+}
+/**
+ * Interface for tool information in MCP servers
+ */
+interface ToolInfo {
+    description?: string;
+    inputSchema?: ZodType<JsonValue>;
+    parameters?: ZodType<JsonValue>;
+    execute: (args: JsonValue) => Promise<JsonValue | ToolResult> | JsonValue | ToolResult;
+    isImplemented?: boolean;
+    metadata?: UnknownRecord;
+}
 /**
  * Abstract base class for all AI providers
  * Tools are integrated as first-class citizens - always available by default
@@ -354,8 +381,8 @@ export declare abstract class BaseProvider implements AIProvider {
     protected mcpTools?: Record<string, Tool>;
     protected sessionId?: string;
     protected userId?: string;
-    protected sdk?: any;
-    constructor(modelName?: string, providerName?: AIProviderName, sdk?: any);
+    protected sdk?: NeuroLinkSDK;
+    constructor(modelName?: string, providerName?: AIProviderName, sdk?: NeuroLinkSDK);
     /**
      * Check if this provider supports tool/function calling
      * Override in subclasses to disable tools for specific providers or models
@@ -392,7 +419,7 @@ export declare abstract class BaseProvider implements AIProvider {
      * REQUIRED: Every provider MUST implement this method
      * Returns the Vercel AI SDK model instance for this provider
      */
-    protected abstract getAISDKModel(): any | Promise<any>;
+    protected abstract getAISDKModel(): LanguageModel | Promise<LanguageModel>;
     /**
      * Get all available tools - direct tools are ALWAYS available
      * MCP tools are added when available (without blocking)
@@ -405,12 +432,12 @@ export declare abstract class BaseProvider implements AIProvider {
     /**
      * Provider-specific error handling
      */
-    protected abstract handleProviderError(error: any): Error;
+    protected abstract handleProviderError(error: unknown): Error;
     protected normalizeTextOptions(optionsOrPrompt: TextGenerationOptions | string): TextGenerationOptions;
     protected normalizeStreamOptions(optionsOrPrompt: StreamOptions | string): StreamOptions;
     protected enhanceResult(result: EnhancedGenerateResult, options: TextGenerationOptions, startTime: number): Promise<EnhancedGenerateResult>;
     protected createAnalytics(result: EnhancedGenerateResult, responseTime: number, options: TextGenerationOptions): Promise<AnalyticsData>;
-    protected createEvaluation(result: EnhancedGenerateResult, options: TextGenerationOptions): Promise<any>;
+    protected createEvaluation(result: EnhancedGenerateResult, options: TextGenerationOptions): Promise<EvaluationData>;
     protected validateOptions(options: TextGenerationOptions): void;
     protected getProviderInfo(): {
         provider: string;
@@ -421,3 +448,4 @@ export declare abstract class BaseProvider implements AIProvider {
      */
     getTimeout(options: TextGenerationOptions | StreamOptions): number;
 }
+export {};

package/dist/core/base-provider.js

@@ -1,18 +1,15 @@
 import { logger } from "../utils/logger.js";
 import { directAgentTools } from "../agent/direct-tools.js";
-// Dynamic imports to break circular dependency
-// import { evaluateResponse } from "../core/evaluation.js";
-// import { getAvailableFunctionTools } from "../mcp/function-calling.js";
-// Analytics helper will be dynamically imported when needed
 /**
  * Validates if a result contains a valid toolsObject structure
  * @param result - The result object to validate
  * @returns true if the result contains a valid toolsObject, false otherwise
  */
 function isValidToolsObject(result) {
-    return (result &&
+    return (result !== null &&
         typeof result === "object" &&
-        result.toolsObject &&
+        "toolsObject" in result &&
+        result.toolsObject !== null &&
         typeof result.toolsObject === "object" &&
         Object.keys(result.toolsObject).length > 0);
 }
@@ -101,7 +98,16 @@ export class BaseProvider {
                         parameters: call.args,
                         id: call.toolCallId,
                     })),
-                    toolResults: result?.toolResults,
+                    toolResults: result?.toolResults
+                        ? result.toolResults.map((tr) => ({
+                            toolName: tr.toolName || "unknown",
+                            status: (tr.status === "error"
+                                ? "failure"
+                                : "success"),
+                            result: tr.result,
+                            error: tr.error,
+                        }))
+                        : undefined,
                 };
             }
             catch (error) {
@@ -154,7 +160,19 @@ export class BaseProvider {
                 },
                 provider: this.providerName,
                 model: this.modelName,
-                toolCalls: result.toolCalls,
+                toolCalls: result.toolCalls
+                    ? result.toolCalls.map((tc) => ({
+                        toolCallId: tc.toolCallId ||
+                            tc.id ||
+                            "unknown",
+                        toolName: tc.toolName ||
+                            tc.name ||
+                            "unknown",
+                        args: tc.args ||
+                            tc.parameters ||
+                            {},
+                    }))
+                    : [],
                 toolResults: result.toolResults,
             };
             // Enhanced result with analytics and evaluation
@@ -186,8 +204,7 @@ export class BaseProvider {
         logger.debug(`[BaseProvider] Direct tools: ${Object.keys(this.directTools).join(", ")}`);
         // Add custom tools from SDK if available
         logger.debug(`[BaseProvider] Checking SDK: ${!!this.sdk}, has getInMemoryServers: ${this.sdk && typeof this.sdk.getInMemoryServers}`);
-        if (this.sdk &&
-            typeof this.sdk.getInMemoryServers === "function") {
+        if (this.sdk && typeof this.sdk.getInMemoryServers === "function") {
             logger.debug(`[BaseProvider] SDK check passed, loading custom tools`);
             try {
                 const inMemoryServers = this.sdk.getInMemoryServers();
@@ -223,7 +240,10 @@ export class BaseProvider {
                                                     return result.data;
                                                 }
                                                 else {
-                                                    throw new Error(result.error || "Tool execution failed");
+                                                    const errorMsg = typeof result.error === "string"
+                                                        ? result.error
+                                                        : "Tool execution failed";
+                                                    throw new Error(errorMsg);
                                                 }
                                             }
                                             return result;
@@ -249,7 +269,9 @@ export class BaseProvider {
                     this.mcpTools = result.toolsObject;
                 }
                 else {
-                    logger.debug(`Invalid or empty toolsObject for ${this.providerName}: Expected an object with at least one key, but got ${typeof result.toolsObject} with ${result.toolsObject ? Object.keys(result.toolsObject).length : 0} keys. Full result:`, result);
+                    logger.debug(`Invalid or empty toolsObject for ${this.providerName}: Expected an object with at least one key, but got ${typeof result?.toolsObject} with ${result?.toolsObject
+                        ? Object.keys(result.toolsObject).length
+                        : 0} keys. Full result:`, result);
                 }
             }
             catch (error) {
@@ -336,7 +358,8 @@ export class BaseProvider {
     }
     async createEvaluation(result, options) {
         const { evaluateResponse } = await import("../core/evaluation.js");
-        return evaluateResponse(result.content, options.prompt);
+        const evaluation = await evaluateResponse(result.content, options.prompt);
+        return evaluation;
     }
     validateOptions(options) {
         if (!options.prompt || options.prompt.trim().length === 0) {

package/dist/core/defaults.d.ts

@@ -2,11 +2,12 @@
  * Default value helper functions for NeuroLink
  * Centralized logic for applying defaults across the system
  */
+import type { UnknownRecord } from "../types/common.js";
 /**
  * Apply default values to options object
  * User-provided values take precedence over defaults
  */
-export declare function applyDefaults(options: any): any;
+export declare function applyDefaults(options: UnknownRecord): UnknownRecord;
 /**
  * Get default max tokens for a specific provider
  * Can be extended for provider-specific overrides in the future

package/dist/core/evaluation.d.ts

@@ -23,7 +23,7 @@ export interface UnifiedEvaluationResult extends EvaluationData {
 export interface UnifiedEvaluationContext {
     userQuery: string;
     aiResponse: string;
-    context?: Record<string, any>;
+    context?: Record<string, unknown>;
     primaryDomain?: string;
     assistantRole?: string;
     conversationHistory?: Array<{
@@ -33,8 +33,8 @@ export interface UnifiedEvaluationContext {
     }>;
     toolUsage?: Array<{
         toolName: string;
-        input: any;
-        output: any;
+        input: unknown;
+        output: unknown;
         executionTime: number;
     }>;
     expectedOutcome?: string;
@@ -52,5 +52,5 @@ declare function parseUnifiedEvaluationResult(response: string, context: Unified
  * Main unified evaluation function
  */
 export declare function generateUnifiedEvaluation(context: UnifiedEvaluationContext): Promise<UnifiedEvaluationResult>;
-export declare function evaluateResponse(responseOrContext: any, contextOrUserQuery?: any, userQuery?: any, providedContexts?: any, options?: any, additionalArgs?: any): Promise<any>;
+export declare function evaluateResponse(responseOrContext: unknown, contextOrUserQuery?: unknown, userQuery?: unknown, providedContexts?: unknown, options?: unknown, additionalArgs?: unknown): Promise<unknown>;
 export { getDefaultUnifiedEvaluation, parseUnifiedEvaluationResult };

package/dist/core/evaluation.js

@@ -90,7 +90,19 @@ function parseUnifiedEvaluationResult(response, context) {
             if (match) {
                 const value = parseFloat(match[1]);
                 if (value >= 1 && value <= 10) {
-                    result[key] = Math.round(value);
+                    const roundedValue = Math.round(value);
+                    if (key === "relevance") {
+                        result.relevance = roundedValue;
+                    }
+                    else if (key === "accuracy") {
+                        result.accuracy = roundedValue;
+                    }
+                    else if (key === "completeness") {
+                        result.completeness = roundedValue;
+                    }
+                    else if (key === "overall") {
+                        result.overall = roundedValue;
+                    }
                 }
             }
         }
@@ -163,9 +175,7 @@ Overall: [score]
             return getDefaultUnifiedEvaluation("no-response", Date.now() - startTime, context);
         }
         // Extract text from result
-        const response = typeof result === "string"
-            ? result
-            : result.text || String(result);
+        const response = typeof result === "string" ? result : result?.content || String(result);
         // Parse evaluation result
         const parsed = parseUnifiedEvaluationResult(response, context);
         // Validate and enhance result
@@ -216,12 +226,12 @@ export async function evaluateResponse(responseOrContext, contextOrUserQuery, us
                 String(contextOrUserQuery || "");
     }
     const evalContext = {
-        userQuery: userQuery ||
+        userQuery: (typeof userQuery === "string" ? userQuery : "") ||
             context?.userQuery ||
-            contextOrUserQuery ||
+            (typeof contextOrUserQuery === "string" ? contextOrUserQuery : "") ||
             "Generated response",
         aiResponse,
-        context,
+        context: context,
     };
     return generateUnifiedEvaluation(evalContext);
 }

package/dist/core/factory.d.ts

@@ -1,4 +1,5 @@
 import type { AIProvider, AIProviderName, SupportedModelName } from "./types.js";
+import type { UnknownRecord } from "../types/common.js";
 declare const componentIdentifier = "aiProviderFactory";
 /**
  * Factory for creating AI provider instances with centralized configuration
@@ -15,7 +16,7 @@ export declare class AIProviderFactory {
      * @param enableMCP - Optional flag to enable MCP integration (default: true)
      * @returns AIProvider instance
      */
-    static createProvider(providerName: string, modelName?: string | null, enableMCP?: boolean, sdk?: any): Promise<AIProvider>;
+    static createProvider(providerName: string, modelName?: string | null, enableMCP?: boolean, sdk?: UnknownRecord): Promise<AIProvider>;
     /**
      * Create a provider instance with specific provider enum and model
      * @param provider - Provider enum value
@@ -30,7 +31,7 @@ export declare class AIProviderFactory {
      * @param enableMCP - Optional flag to enable MCP integration (default: true)
      * @returns AIProvider instance
      */
-    static createBestProvider(requestedProvider?: string, modelName?: string | null, enableMCP?: boolean, sdk?: any): Promise<AIProvider>;
+    static createBestProvider(requestedProvider?: string, modelName?: string | null, enableMCP?: boolean, sdk?: UnknownRecord): Promise<AIProvider>;
     /**
      * Create primary and fallback provider instances
      * @param primaryProvider - Primary provider name

package/dist/core/service-registry.d.ts

@@ -2,13 +2,13 @@
  * Service Registry for Dependency Injection
  * Breaks circular dependencies by providing lazy loading and centralized service management
  */
-export interface ServiceFactory<T = any> {
+export interface ServiceFactory<T = unknown> {
     (): T | Promise<T>;
 }
-export interface ServiceRegistration {
-    factory: ServiceFactory;
+export interface ServiceRegistration<T = unknown> {
+    factory: ServiceFactory<T>;
     singleton: boolean;
-    instance?: any;
+    instance?: T;
 }
 export declare class ServiceRegistry {
     private static services;

package/dist/core/types.d.ts

@@ -2,6 +2,7 @@ import type { ZodType, ZodTypeDef } from "zod";
 import type { Schema, Tool } from "ai";
 import type { GenerateResult } from "../types/generate-types.js";
 import type { StreamOptions, StreamResult } from "../types/stream-types.js";
+import type { JsonValue } from "../types/common.js";
 export interface TextGenerationResult {
     content: string;
     provider?: string;
@@ -26,8 +27,14 @@ export interface TextGenerationResult {
         server: string;
         category?: string;
     }>;
-    analytics?: any;
-    evaluation?: any;
+    analytics?: AnalyticsData;
+    evaluation?: {
+        relevance: number;
+        accuracy: number;
+        completeness: number;
+        overall: number;
+        reasoning?: string;
+    };
 }
 /**
  * Supported AI Provider Names
@@ -118,7 +125,7 @@ export interface TextGenerationOptions {
     maxSteps?: number;
     enableEvaluation?: boolean;
     enableAnalytics?: boolean;
-    context?: Record<string, any>;
+    context?: Record<string, JsonValue>;
     evaluationDomain?: string;
     toolUsageContext?: string;
     conversationHistory?: Array<{
@@ -140,7 +147,7 @@ export interface AnalyticsData {
     cost?: number;
     responseTime: number;
     timestamp: string;
-    context?: Record<string, any>;
+    context?: Record<string, JsonValue>;
 }
 /**
  * Response quality evaluation scores (Lighthouse-Compatible Schema)

package/dist/factories/compatibility-factory.d.ts

@@ -12,7 +12,22 @@ export declare class CompatibilityConversionFactory {
     /**
      * Convert GenerateResult to legacy TextGenerationResult format
      */
-    static convertGenerateToText(result: GenerateResult): any;
+    static convertGenerateToText(result: GenerateResult): {
+        content: string;
+        provider?: string;
+        model?: string;
+        usage?: {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+        };
+        responseTime?: number;
+        toolsUsed?: number;
+        toolExecutions?: unknown[];
+        analytics?: unknown;
+        evaluation?: unknown;
+        [key: string]: unknown;
+    };
     /**
      * Convert GenerateOptions to TextGenerationOptions
      */

package/dist/factories/compatibility-factory.js

@@ -37,7 +37,9 @@ export class CompatibilityConversionFactory {
             model: result.model,
             usage: result.usage,
             responseTime: result.responseTime,
-            toolsUsed: result.toolsUsed,
+            toolsUsed: Array.isArray(result.toolsUsed)
+                ? result.toolsUsed.length
+                : result.toolsUsed,
             toolExecutions: result.toolExecutions,
             enhancedWithTools: result.enhancedWithTools,
             availableTools: result.availableTools,

package/dist/factories/provider-factory.d.ts

@@ -1,10 +1,11 @@
 import type { AIProvider, AIProviderName } from "../core/types.js";
+import type { UnknownRecord } from "../types/common.js";
 /**
  * Provider constructor interface - supports both sync constructors and async factory functions
  */
 type ProviderConstructor = {
-    new (modelName?: string, providerName?: any, sdk?: any): AIProvider;
-} | ((modelName?: string, providerName?: any, sdk?: any) => Promise<AIProvider>);
+    new (modelName?: string, providerName?: string, sdk?: UnknownRecord): AIProvider;
+} | ((modelName?: string, providerName?: string, sdk?: UnknownRecord) => Promise<AIProvider>);
 /**
  * Provider registration entry
  */
@@ -29,7 +30,7 @@ export declare class ProviderFactory {
     /**
      * Create a provider instance
      */
-    static createProvider(providerName: AIProviderName | string, modelName?: string, sdk?: any): Promise<AIProvider>;
+    static createProvider(providerName: AIProviderName | string, modelName?: string, sdk?: UnknownRecord): Promise<AIProvider>;
     /**
      * Check if a provider is registered
      */
@@ -63,7 +64,7 @@ export declare class ProviderFactory {
      * Create the best available provider for the given name
      * Used by NeuroLink SDK for streaming and generation
      */
-    static createBestProvider(providerName: AIProviderName | string, modelName?: string, enableMCP?: boolean, sdk?: any): Promise<AIProvider>;
+    static createBestProvider(providerName: AIProviderName | string, modelName?: string, enableMCP?: boolean, sdk?: UnknownRecord): Promise<AIProvider>;
 }
 /**
  * Helper function to create providers with backward compatibility