@juspay/neurolink 5.0.0 → 5.2.0

package/dist/core/base-provider.js

@@ -0,0 +1,365 @@
+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
+/**
+ * Abstract base class for all AI providers
+ * Tools are integrated as first-class citizens - always available by default
+ */
+export class BaseProvider {
+    modelName;
+    providerName;
+    defaultTimeout = 30000; // 30 seconds
+    // Tools are ALWAYS part of the provider - no flags, no conditions
+    directTools = directAgentTools;
+    mcpTools; // MCP tools loaded dynamically when available
+    sessionId;
+    userId;
+    sdk; // Reference to NeuroLink SDK instance for custom tools
+    constructor(modelName, providerName, sdk) {
+        this.modelName = modelName || this.getDefaultModel();
+        this.providerName = providerName || this.getProviderName();
+        this.sdk = sdk;
+    }
+    /**
+     * Check if this provider supports tool/function calling
+     * Override in subclasses to disable tools for specific providers or models
+     * @returns true by default, providers can override to return false
+     */
+    supportsTools() {
+        return true;
+    }
+    // ===================
+    // PUBLIC API METHODS
+    // ===================
+    /**
+     * Primary streaming method - implements AIProvider interface
+     * When tools are involved, falls back to generate() with synthetic streaming
+     */
+    async stream(optionsOrPrompt, analysisSchema) {
+        const options = this.normalizeStreamOptions(optionsOrPrompt);
+        // If tools are not disabled AND provider supports tools, use generate() and create synthetic stream
+        if (!options.disableTools && this.supportsTools()) {
+            try {
+                // Convert stream options to text generation options
+                const textOptions = {
+                    prompt: options.input?.text || "",
+                    systemPrompt: options.systemPrompt,
+                    temperature: options.temperature,
+                    maxTokens: options.maxTokens,
+                    disableTools: false,
+                    maxSteps: options.maxSteps || 5,
+                    provider: options.provider,
+                    model: options.model,
+                };
+                const result = await this.generate(textOptions, analysisSchema);
+                // Create a synthetic stream from the generate result that simulates progressive delivery
+                return {
+                    stream: (async function* () {
+                        if (result?.content) {
+                            // Split content into words for more natural streaming
+                            const words = result.content.split(/(\s+)/); // Keep whitespace
+                            let buffer = "";
+                            for (let i = 0; i < words.length; i++) {
+                                buffer += words[i];
+                                // Yield chunks of roughly 5-10 words or at punctuation
+                                const shouldYield = i === words.length - 1 || // Last word
+                                    buffer.length > 50 || // Buffer getting long
+                                    /[.!?;,]\s*$/.test(buffer); // End of sentence/clause
+                                if (shouldYield && buffer.trim()) {
+                                    yield { content: buffer };
+                                    buffer = "";
+                                    // Small delay to simulate streaming (1-10ms)
+                                    await new Promise((resolve) => setTimeout(resolve, Math.random() * 9 + 1));
+                                }
+                            }
+                            // Yield any remaining content
+                            if (buffer.trim()) {
+                                yield { content: buffer };
+                            }
+                        }
+                    })(),
+                    usage: result?.usage,
+                    provider: result?.provider,
+                    model: result?.model,
+                    toolCalls: result?.toolCalls?.map((call) => ({
+                        toolName: call.toolName,
+                        parameters: call.args,
+                        id: call.toolCallId,
+                    })),
+                    toolResults: result?.toolResults,
+                };
+            }
+            catch (error) {
+                logger.error(`Stream with tools failed for ${this.providerName}:`, error);
+                throw this.handleProviderError(error);
+            }
+        }
+        // Traditional streaming without tools
+        try {
+            return await this.executeStream(options, analysisSchema);
+        }
+        catch (error) {
+            logger.error(`Stream failed for ${this.providerName}:`, error);
+            throw this.handleProviderError(error);
+        }
+    }
+    /**
+     * Text generation method - implements AIProvider interface
+     * Tools are always available unless explicitly disabled
+     */
+    async generate(optionsOrPrompt, analysisSchema) {
+        const options = this.normalizeTextOptions(optionsOrPrompt);
+        const startTime = Date.now();
+        try {
+            // Import generateText dynamically to avoid circular dependencies
+            const { generateText } = await import("ai");
+            // Get ALL available tools (direct + MCP when available)
+            const shouldUseTools = !options.disableTools && this.supportsTools();
+            const tools = shouldUseTools ? await this.getAllTools() : {};
+            logger.debug(`[BaseProvider.generate] Tools for ${this.providerName}: ${Object.keys(tools).join(", ")}`);
+            // EVERY provider uses Vercel AI SDK - no exceptions
+            const model = await this.getAISDKModel(); // This method is now REQUIRED
+            const result = await generateText({
+                model,
+                prompt: options.prompt || options.input?.text || "",
+                system: options.systemPrompt,
+                tools,
+                maxSteps: options.maxSteps || 5,
+                toolChoice: shouldUseTools ? "auto" : "none",
+                temperature: options.temperature,
+                maxTokens: options.maxTokens || 8192,
+            });
+            // Format the result with tool executions included
+            const enhancedResult = {
+                content: result.text,
+                usage: {
+                    inputTokens: result.usage?.promptTokens || 0,
+                    outputTokens: result.usage?.completionTokens || 0,
+                    totalTokens: result.usage?.totalTokens || 0,
+                },
+                provider: this.providerName,
+                model: this.modelName,
+                toolCalls: result.toolCalls,
+                toolResults: result.toolResults,
+            };
+            // Enhanced result with analytics and evaluation
+            return await this.enhanceResult(enhancedResult, options, startTime);
+        }
+        catch (error) {
+            logger.error(`Generate failed for ${this.providerName}:`, error);
+            throw this.handleProviderError(error);
+        }
+    }
+    /**
+     * Alias for generate method - implements AIProvider interface
+     */
+    async gen(optionsOrPrompt, analysisSchema) {
+        return this.generate(optionsOrPrompt, analysisSchema);
+    }
+    // ===================
+    // TOOL MANAGEMENT
+    // ===================
+    /**
+     * Get all available tools - direct tools are ALWAYS available
+     * MCP tools are added when available (without blocking)
+     */
+    async getAllTools() {
+        const tools = {
+            ...this.directTools, // Always include direct tools
+        };
+        logger.info(`[BaseProvider] getAllTools called, SDK available: ${!!this.sdk}, type: ${typeof this.sdk}`);
+        console.log(`[BaseProvider] Direct tools: ${Object.keys(this.directTools).join(", ")}`);
+        // Add custom tools from SDK if available
+        console.log(`[BaseProvider] Checking SDK: ${!!this.sdk}, has getInMemoryServers: ${this.sdk && typeof this.sdk.getInMemoryServers}`);
+        if (this.sdk &&
+            typeof this.sdk.getInMemoryServers === "function") {
+            console.log(`[BaseProvider] SDK check passed, loading custom tools`);
+            try {
+                const inMemoryServers = this.sdk.getInMemoryServers();
+                console.log(`[BaseProvider] Got servers:`, inMemoryServers.size);
+                logger.debug(`[BaseProvider] Loading custom tools from SDK, found ${inMemoryServers.size} servers`);
+                if (inMemoryServers && inMemoryServers.size > 0) {
+                    // Convert in-memory server tools to AI SDK format
+                    for (const [serverId, serverConfig] of inMemoryServers) {
+                        const server = serverConfig.server;
+                        if (server && server.tools) {
+                            // Handle both Map and object formats
+                            const toolEntries = server.tools instanceof Map
+                                ? Array.from(server.tools.entries())
+                                : Object.entries(server.tools || {});
+                            for (const [toolName, toolInfo] of toolEntries) {
+                                if (toolInfo && typeof toolInfo.execute === "function") {
+                                    console.log(`[BaseProvider] Converting custom tool: ${toolName}`);
+                                    // Convert to AI SDK tool format
+                                    const { tool: createAISDKTool } = await import("ai");
+                                    const { z } = await import("zod");
+                                    tools[toolName] = createAISDKTool({
+                                        description: toolInfo.description || `Tool ${toolName}`,
+                                        parameters: toolInfo.inputSchema ||
+                                            toolInfo.parameters ||
+                                            z.object({}),
+                                        execute: async (args) => {
+                                            const result = await toolInfo.execute(args);
+                                            // Handle MCP-style results
+                                            if (result &&
+                                                typeof result === "object" &&
+                                                "success" in result) {
+                                                if (result.success) {
+                                                    return result.data;
+                                                }
+                                                else {
+                                                    throw new Error(result.error || "Tool execution failed");
+                                                }
+                                            }
+                                            return result;
+                                        },
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                logger.debug(`Failed to load custom tools for ${this.providerName}:`, error);
+                // Not an error - custom tools are optional
+            }
+        }
+        // Try to load MCP tools if not already loaded
+        if (!this.mcpTools) {
+            try {
+                const { getAvailableFunctionTools } = await import("../mcp/function-calling.js");
+                const result = await getAvailableFunctionTools();
+                if (result.tools && result.tools.length > 0) {
+                    this.mcpTools = {};
+                    for (const tool of result.tools) {
+                        const toolName = tool.name || "unknown";
+                        this.mcpTools[toolName] = tool;
+                    }
+                }
+            }
+            catch (error) {
+                logger.debug(`MCP tools not available for ${this.providerName}:`, error);
+                // Not an error - MCP tools are optional
+            }
+        }
+        // Add MCP tools if available
+        if (this.mcpTools) {
+            Object.assign(tools, this.mcpTools);
+        }
+        console.log(`[BaseProvider] getAllTools returning tools: ${Object.keys(tools).join(", ")}`);
+        return tools;
+    }
+    /**
+     * Set session context for MCP tools
+     */
+    setSessionContext(sessionId, userId) {
+        this.sessionId = sessionId;
+        this.userId = userId;
+    }
+    // ===================
+    // TEMPLATE METHODS - COMMON FUNCTIONALITY
+    // ===================
+    normalizeTextOptions(optionsOrPrompt) {
+        if (typeof optionsOrPrompt === "string") {
+            return {
+                prompt: optionsOrPrompt,
+                provider: this.providerName,
+                model: this.modelName,
+            };
+        }
+        // Handle both prompt and input.text formats
+        const prompt = optionsOrPrompt.prompt || optionsOrPrompt.input?.text || "";
+        return {
+            ...optionsOrPrompt,
+            prompt,
+            provider: optionsOrPrompt.provider || this.providerName,
+            model: optionsOrPrompt.model || this.modelName,
+        };
+    }
+    normalizeStreamOptions(optionsOrPrompt) {
+        if (typeof optionsOrPrompt === "string") {
+            return {
+                input: { text: optionsOrPrompt },
+                provider: this.providerName,
+                model: this.modelName,
+            };
+        }
+        return {
+            ...optionsOrPrompt,
+            provider: optionsOrPrompt.provider || this.providerName,
+            model: optionsOrPrompt.model || this.modelName,
+        };
+    }
+    async enhanceResult(result, options, startTime) {
+        const responseTime = Date.now() - startTime;
+        let enhancedResult = { ...result };
+        if (options.enableAnalytics) {
+            try {
+                logger.debug(`Creating analytics for ${this.providerName}...`);
+                const analytics = await this.createAnalytics(result, responseTime, options);
+                logger.debug(`Analytics created:`, analytics);
+                enhancedResult = { ...enhancedResult, analytics };
+            }
+            catch (error) {
+                logger.warn(`Analytics creation failed for ${this.providerName}:`, error);
+            }
+        }
+        if (options.enableEvaluation) {
+            try {
+                const evaluation = await this.createEvaluation(result, options);
+                enhancedResult = { ...enhancedResult, evaluation };
+            }
+            catch (error) {
+                logger.warn(`Evaluation creation failed for ${this.providerName}:`, error);
+            }
+        }
+        return enhancedResult;
+    }
+    async createAnalytics(result, responseTime, options) {
+        const { createAnalytics } = await import("../providers/analytics-helper.js");
+        return createAnalytics(this.providerName, this.modelName, result, responseTime, options.context);
+    }
+    async createEvaluation(result, options) {
+        const { evaluateResponse } = await import("../core/evaluation.js");
+        return evaluateResponse(result.content, options.prompt);
+    }
+    validateOptions(options) {
+        if (!options.prompt || options.prompt.trim().length === 0) {
+            throw new Error("Prompt is required and cannot be empty");
+        }
+    }
+    getProviderInfo() {
+        return {
+            provider: this.providerName,
+            model: this.modelName,
+        };
+    }
+    /**
+     * Get timeout value in milliseconds
+     */
+    getTimeout(options) {
+        if (!options.timeout) {
+            return this.defaultTimeout;
+        }
+        if (typeof options.timeout === "number") {
+            return options.timeout;
+        }
+        // Parse string timeout (e.g., '30s', '2m', '1h')
+        const timeoutStr = options.timeout.toLowerCase();
+        const value = parseInt(timeoutStr);
+        if (timeoutStr.includes("h")) {
+            return value * 60 * 60 * 1000;
+        }
+        else if (timeoutStr.includes("m")) {
+            return value * 60 * 1000;
+        }
+        else if (timeoutStr.includes("s")) {
+            return value * 1000;
+        }
+        return this.defaultTimeout;
+    }
+}

package/dist/core/constants.d.ts

@@ -2,7 +2,7 @@
  * Central configuration constants for NeuroLink
  * Single source of truth for all default values
  */
-export declare const DEFAULT_MAX_TOKENS = 10000;
+export declare const DEFAULT_MAX_TOKENS = 8192;
 export declare const DEFAULT_TEMPERATURE = 0.7;
 export declare const DEFAULT_TIMEOUT = 30000;
 export declare const DEFAULT_EVALUATION_MAX_TOKENS = 500;

package/dist/core/constants.js

@@ -3,7 +3,7 @@
  * Single source of truth for all default values
  */
 // Core AI Generation Defaults
-export const DEFAULT_MAX_TOKENS = 10000;
+export const DEFAULT_MAX_TOKENS = 8192; // Changed from 10000 to fix Anthropic error
 export const DEFAULT_TEMPERATURE = 0.7;
 export const DEFAULT_TIMEOUT = 30000;
 // Specialized Use Case Defaults

package/dist/core/dynamic-models.d.ts

@@ -21,8 +21,8 @@ declare const ModelConfigSchema: z.ZodObject<{
     releaseDate: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     id: string;
-    displayName: string;
     capabilities: string[];
+    displayName: string;
     deprecated: boolean;
     pricing: {
         input: number;
@@ -32,8 +32,8 @@ declare const ModelConfigSchema: z.ZodObject<{
     releaseDate: string;
 }, {
     id: string;
-    displayName: string;
     capabilities: string[];
+    displayName: string;
     deprecated: boolean;
     pricing: {
         input: number;
@@ -64,8 +64,8 @@ declare const ModelRegistrySchema: z.ZodObject<{
         releaseDate: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         id: string;
-        displayName: string;
         capabilities: string[];
+        displayName: string;
         deprecated: boolean;
         pricing: {
             input: number;
@@ -75,8 +75,8 @@ declare const ModelRegistrySchema: z.ZodObject<{
         releaseDate: string;
     }, {
         id: string;
-        displayName: string;
         capabilities: string[];
+        displayName: string;
         deprecated: boolean;
         pricing: {
             input: number;
@@ -92,8 +92,8 @@ declare const ModelRegistrySchema: z.ZodObject<{
     lastUpdated: string;
     models: Record<string, Record<string, {
         id: string;
-        displayName: string;
         capabilities: string[];
+        displayName: string;
         deprecated: boolean;
         pricing: {
             input: number;
@@ -109,8 +109,8 @@ declare const ModelRegistrySchema: z.ZodObject<{
     lastUpdated: string;
     models: Record<string, Record<string, {
         id: string;
-        displayName: string;
         capabilities: string[];
+        displayName: string;
         deprecated: boolean;
         pricing: {
             input: number;

package/dist/core/evaluation.d.ts

@@ -1,15 +1,7 @@
 /**
  * NeuroLink Unified Evaluation System
- *
- * Combines Universal Evaluation with Lighthouse-Enhanced capabilities
- * - Domain-aware evaluation with sophisticated context handling
- * - Multi-provider support with fallback strategies
- * - Structured output with Zod schema validation
- * - Tool usage and conversation history analysis
- * - Enterprise-grade reliability and performance
  */
 import type { EvaluationData } from "./types.js";
-import { z } from "zod";
 export interface UnifiedEvaluationResult extends EvaluationData {
     domainAlignment?: number;
     terminologyAccuracy?: number;
@@ -24,6 +16,9 @@ export interface UnifiedEvaluationResult extends EvaluationData {
         toolsEvaluated: string[];
         conversationTurns: number;
     };
+    isOffTopic: boolean;
+    alertSeverity: "low" | "medium" | "high" | "none";
+    reasoning: string;
 }
 export interface UnifiedEvaluationContext {
     userQuery: string;
@@ -31,87 +26,31 @@ export interface UnifiedEvaluationContext {
     context?: Record<string, any>;
     primaryDomain?: string;
     assistantRole?: string;
-    toolsUsed?: string[];
-    toolContext?: string;
     conversationHistory?: Array<{
         role: "user" | "assistant";
         content: string;
         timestamp?: string;
     }>;
-    sessionId?: string;
-    userId?: string;
-    requestId?: string;
-    mode?: "simple" | "enhanced" | "lighthouse";
+    toolUsage?: Array<{
+        toolName: string;
+        input: any;
+        output: any;
+        executionTime: number;
+    }>;
+    expectedOutcome?: string;
+    evaluationCriteria?: string[];
 }
 /**
- * Unified Evaluation Schema (Lighthouse-compatible with extensions)
+ * Get default evaluation when evaluation fails
  */
-export declare const unifiedEvaluationSchema: z.ZodObject<{
-    relevanceScore: z.ZodNumber;
-    accuracyScore: z.ZodNumber;
-    completenessScore: z.ZodNumber;
-    domainAlignment: z.ZodOptional<z.ZodNumber>;
-    terminologyAccuracy: z.ZodOptional<z.ZodNumber>;
-    toolEffectiveness: z.ZodOptional<z.ZodNumber>;
-    isOffTopic: z.ZodBoolean;
-    reasoning: z.ZodString;
-    suggestedImprovements: z.ZodOptional<z.ZodString>;
-    alertSeverity: z.ZodEnum<["low", "medium", "high", "none"]>;
-}, "strip", z.ZodTypeAny, {
-    relevanceScore: number;
-    accuracyScore: number;
-    completenessScore: number;
-    isOffTopic: boolean;
-    reasoning: string;
-    alertSeverity: "low" | "medium" | "high" | "none";
-    domainAlignment?: number | undefined;
-    terminologyAccuracy?: number | undefined;
-    toolEffectiveness?: number | undefined;
-    suggestedImprovements?: string | undefined;
-}, {
-    relevanceScore: number;
-    accuracyScore: number;
-    completenessScore: number;
-    isOffTopic: boolean;
-    reasoning: string;
-    alertSeverity: "low" | "medium" | "high" | "none";
-    domainAlignment?: number | undefined;
-    terminologyAccuracy?: number | undefined;
-    toolEffectiveness?: number | undefined;
-    suggestedImprovements?: string | undefined;
-}>;
+declare function getDefaultUnifiedEvaluation(reason: string, evaluationTime: number, context: UnifiedEvaluationContext): UnifiedEvaluationResult;
 /**
- * Main unified evaluation function
+ * Parse unified evaluation result from text response
  */
-export declare function performUnifiedEvaluation(context: UnifiedEvaluationContext): Promise<UnifiedEvaluationResult>;
+declare function parseUnifiedEvaluationResult(response: string, context: UnifiedEvaluationContext): Partial<UnifiedEvaluationResult>;
 /**
- * Enhanced evaluation model selection
- */
-export declare function getEvaluationModel(): Promise<{
-    provider: any;
-    config: any;
-} | null>;
-/**
- * Create simple evaluation context (backward compatibility)
- */
-export declare function createSimpleEvaluationContext(prompt: string, response: string, context?: Record<string, any>): UnifiedEvaluationContext;
-/**
- * Create enhanced evaluation context
+ * Main unified evaluation function
  */
-export declare function createEnhancedEvaluationContext(userQuery: string, aiResponse: string, options?: {
-    domain?: string;
-    role?: string;
-    toolsUsed?: string[];
-    conversationHistory?: Array<{
-        role: "user" | "assistant";
-        content: string;
-    }>;
-    sessionId?: string;
-    context?: Record<string, any>;
-}): UnifiedEvaluationContext;
-export declare function evaluateResponse(prompt: string, response: string, context?: Record<string, any>, evaluationDomain?: string, toolUsageContext?: string, conversationHistory?: Array<{
-    role: string;
-    content: string;
-    timestamp?: string;
-}>): Promise<UnifiedEvaluationResult>;
-export type EvaluationResult = UnifiedEvaluationResult;
+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 { getDefaultUnifiedEvaluation, parseUnifiedEvaluationResult };