@juspay/neurolink 8.3.0 → 8.4.1

package/dist/core/constants.d.ts

@@ -48,6 +48,9 @@ export declare const PROVIDER_MAX_TOKENS: {
     azure: {
         default: number;
     };
+    mistral: {
+        default: number;
+    };
     ollama: {
         default: number;
     };

package/dist/core/constants.js

@@ -39,7 +39,7 @@ export const PROVIDER_MAX_TOKENS = {
         default: 64000,
     },
     openai: {
-        default: 500000,
+        default: 128000,
     },
     "google-ai": {
         default: 64000,
@@ -51,13 +51,16 @@ export const PROVIDER_MAX_TOKENS = {
         default: 64000,
     },
     azure: {
-        default: 32000,
+        default: 128000,
+    },
+    mistral: {
+        default: 128000,
     },
     ollama: {
         default: 64000,
     },
     litellm: {
-        default: 500000,
+        default: 128000,
     },
     default: 64000,
 };

package/dist/core/modelConfiguration.js

@@ -320,6 +320,16 @@ export class ModelConfigurationManager {
                     MODEL_NAMES.OLLAMA.BALANCED,
                     MODEL_NAMES.OLLAMA.QUALITY,
                 ]),
+                toolCapableModels: this.getConfigArray("OLLAMA_TOOL_CAPABLE_MODELS", [
+                    "llama3.1",
+                    "mistral",
+                    "hermes3",
+                    "qwen2.5",
+                    "codellama",
+                    "dolphin",
+                    "openchat",
+                    "solar",
+                ]),
                 specialHandling: this.getConfigObject("OLLAMA_SPECIAL_HANDLING", {
                     baseUrl: this.getConfigValue("OLLAMA_BASE_URL", "http://localhost:11434"),
                 }),

package/dist/core/modules/GenerationHandler.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Generation Handler Module
+ *
+ * Handles text generation execution, result formatting, and tool information extraction.
+ * Extracted from BaseProvider to follow Single Responsibility Principle.
+ *
+ * Responsibilities:
+ * - Generation execution with AI SDK
+ * - Tool information extraction
+ * - Result formatting and enhancement
+ * - Response analysis and logging
+ *
+ * @module core/modules/GenerationHandler
+ */
+import type { LanguageModelV1, CoreMessage, Tool } from "ai";
+import { generateText } from "ai";
+import type { TextGenerationOptions, EnhancedGenerateResult, AIProviderName, StandardRecord } from "../../types/index.js";
+/**
+ * GenerationHandler class - Handles text generation operations for AI providers
+ */
+export declare class GenerationHandler {
+    private readonly providerName;
+    private readonly modelName;
+    private readonly supportsToolsFn;
+    private readonly getTelemetryConfigFn;
+    private readonly handleToolStorageFn;
+    constructor(providerName: AIProviderName, modelName: string, supportsToolsFn: () => boolean, getTelemetryConfigFn: (options: TextGenerationOptions, type: string) => {
+        isEnabled: boolean;
+        functionId?: string;
+        metadata?: Record<string, string | number | boolean>;
+    } | undefined, handleToolStorageFn: (toolCalls: unknown[], toolResults: unknown[], options: TextGenerationOptions, timestamp: Date) => Promise<void>);
+    /**
+     * Execute the generation with AI SDK
+     */
+    executeGeneration(model: LanguageModelV1, messages: CoreMessage[], tools: Record<string, Tool>, options: TextGenerationOptions): Promise<Awaited<ReturnType<typeof generateText>>>;
+    /**
+     * Log generation completion information
+     */
+    logGenerationComplete(generateResult: Awaited<ReturnType<typeof generateText>>): void;
+    /**
+     * Extract tool information from generation result
+     */
+    extractToolInformation(generateResult: Awaited<ReturnType<typeof generateText>>): {
+        toolsUsed: string[];
+        toolExecutions: Array<{
+            name: string;
+            input: StandardRecord;
+            output: unknown;
+        }>;
+    };
+    /**
+     * Format the enhanced result
+     */
+    formatEnhancedResult(generateResult: Awaited<ReturnType<typeof generateText>>, tools: Record<string, Tool>, toolsUsed: string[], toolExecutions: Array<{
+        name: string;
+        input: StandardRecord;
+        output: unknown;
+    }>, options: TextGenerationOptions): EnhancedGenerateResult;
+    /**
+     * Analyze AI response structure and log detailed debugging information
+     */
+    analyzeAIResponse(result: Record<string, unknown>): void;
+}

package/dist/core/modules/GenerationHandler.js

@@ -0,0 +1,230 @@
+/**
+ * Generation Handler Module
+ *
+ * Handles text generation execution, result formatting, and tool information extraction.
+ * Extracted from BaseProvider to follow Single Responsibility Principle.
+ *
+ * Responsibilities:
+ * - Generation execution with AI SDK
+ * - Tool information extraction
+ * - Result formatting and enhancement
+ * - Response analysis and logging
+ *
+ * @module core/modules/GenerationHandler
+ */
+import { generateText, Output } from "ai";
+import { logger } from "../../utils/logger.js";
+import { DEFAULT_MAX_STEPS } from "../constants.js";
+/**
+ * GenerationHandler class - Handles text generation operations for AI providers
+ */
+export class GenerationHandler {
+    providerName;
+    modelName;
+    supportsToolsFn;
+    getTelemetryConfigFn;
+    handleToolStorageFn;
+    constructor(providerName, modelName, supportsToolsFn, getTelemetryConfigFn, handleToolStorageFn) {
+        this.providerName = providerName;
+        this.modelName = modelName;
+        this.supportsToolsFn = supportsToolsFn;
+        this.getTelemetryConfigFn = getTelemetryConfigFn;
+        this.handleToolStorageFn = handleToolStorageFn;
+    }
+    /**
+     * Execute the generation with AI SDK
+     */
+    async executeGeneration(model, messages, tools, options) {
+        const shouldUseTools = !options.disableTools && this.supportsToolsFn();
+        const useStructuredOutput = !!options.schema &&
+            (options.output?.format === "json" ||
+                options.output?.format === "structured");
+        return await generateText({
+            model,
+            messages,
+            tools,
+            maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
+            toolChoice: shouldUseTools ? "auto" : "none",
+            temperature: options.temperature,
+            maxTokens: options.maxTokens,
+            ...(useStructuredOutput &&
+                options.schema && {
+                experimental_output: Output.object({ schema: options.schema }),
+            }),
+            experimental_telemetry: this.getTelemetryConfigFn(options, "generate"),
+            onStepFinish: ({ toolCalls, toolResults }) => {
+                logger.info("Tool execution completed", { toolResults, toolCalls });
+                // Handle tool execution storage
+                this.handleToolStorageFn(toolCalls, toolResults, options, new Date()).catch((error) => {
+                    logger.warn("[GenerationHandler] Failed to store tool executions", {
+                        provider: this.providerName,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                });
+            },
+        });
+    }
+    /**
+     * Log generation completion information
+     */
+    logGenerationComplete(generateResult) {
+        logger.debug(`generateText completed`, {
+            provider: this.providerName,
+            model: this.modelName,
+            responseLength: generateResult.text?.length || 0,
+            toolResultsCount: generateResult.toolResults?.length || 0,
+            finishReason: generateResult.finishReason,
+            usage: generateResult.usage,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * Extract tool information from generation result
+     */
+    extractToolInformation(generateResult) {
+        const toolsUsed = [];
+        const toolExecutions = [];
+        // Extract tool names from tool calls
+        if (generateResult.toolCalls && generateResult.toolCalls.length > 0) {
+            toolsUsed.push(...generateResult.toolCalls.map((tc) => {
+                return tc.toolName || tc.name || "unknown";
+            }));
+        }
+        // Extract from steps
+        if (generateResult.steps &&
+            Array.isArray(generateResult.steps)) {
+            const toolCallArgsMap = new Map();
+            for (const step of generateResult
+                .steps || []) {
+                // Collect tool calls and their arguments
+                if (step?.toolCalls && Array.isArray(step.toolCalls)) {
+                    for (const toolCall of step.toolCalls) {
+                        const tcRecord = toolCall;
+                        const toolName = tcRecord.toolName ||
+                            tcRecord.name ||
+                            "unknown";
+                        const toolId = tcRecord.toolCallId ||
+                            tcRecord.id ||
+                            toolName;
+                        toolsUsed.push(toolName);
+                        let callArgs = {};
+                        if (tcRecord.args) {
+                            callArgs = tcRecord.args;
+                        }
+                        else if (tcRecord.arguments) {
+                            callArgs = tcRecord.arguments;
+                        }
+                        else if (tcRecord.parameters) {
+                            callArgs = tcRecord.parameters;
+                        }
+                        toolCallArgsMap.set(toolId, callArgs);
+                        toolCallArgsMap.set(toolName, callArgs);
+                    }
+                }
+                // Process tool results
+                if (step?.toolResults && Array.isArray(step.toolResults)) {
+                    for (const toolResult of step.toolResults) {
+                        const trRecord = toolResult;
+                        const toolName = trRecord.toolName || "unknown";
+                        const toolId = trRecord.toolCallId || trRecord.id;
+                        let toolArgs = {};
+                        if (trRecord.args) {
+                            toolArgs = trRecord.args;
+                        }
+                        else if (trRecord.arguments) {
+                            toolArgs = trRecord.arguments;
+                        }
+                        else if (trRecord.parameters) {
+                            toolArgs = trRecord.parameters;
+                        }
+                        else if (trRecord.input) {
+                            toolArgs = trRecord.input;
+                        }
+                        else {
+                            toolArgs = toolCallArgsMap.get(toolId || toolName) || {};
+                        }
+                        toolExecutions.push({
+                            name: toolName,
+                            input: toolArgs,
+                            output: trRecord.result ?? "success",
+                        });
+                    }
+                }
+            }
+        }
+        return { toolsUsed: [...new Set(toolsUsed)], toolExecutions };
+    }
+    /**
+     * Format the enhanced result
+     */
+    formatEnhancedResult(generateResult, tools, toolsUsed, toolExecutions, options) {
+        // Structured output check
+        const useStructuredOutput = !!options.schema &&
+            (options.output?.format === "json" ||
+                options.output?.format === "structured");
+        const content = useStructuredOutput
+            ? JSON.stringify(generateResult.experimental_output)
+            : generateResult.text;
+        return {
+            content,
+            usage: {
+                input: generateResult.usage?.promptTokens || 0,
+                output: generateResult.usage?.completionTokens || 0,
+                total: generateResult.usage?.totalTokens || 0,
+            },
+            provider: this.providerName,
+            model: this.modelName,
+            toolCalls: generateResult.toolCalls
+                ? generateResult.toolCalls.map((tc) => ({
+                    toolCallId: tc.toolCallId || "unknown",
+                    toolName: tc.toolName || "unknown",
+                    args: tc.args || {},
+                }))
+                : [],
+            toolResults: generateResult.toolResults || [],
+            toolsUsed,
+            toolExecutions,
+            availableTools: Object.keys(tools).map((name) => {
+                const tool = tools[name];
+                return {
+                    name,
+                    description: tool.description || "No description available",
+                    parameters: tool.parameters || {},
+                    server: tool.serverId || "direct",
+                };
+            }),
+        };
+    }
+    /**
+     * Analyze AI response structure and log detailed debugging information
+     */
+    analyzeAIResponse(result) {
+        logger.debug("NeuroLink Raw AI Response Analysis", {
+            provider: this.providerName,
+            model: this.modelName,
+            responseTextLength: result.text?.length || 0,
+            responsePreview: result.text?.substring(0, 500) + "...",
+            finishReason: result.finishReason,
+            usage: result.usage,
+        });
+        // Tool calls analysis
+        const toolCallsAnalysis = {
+            hasToolCalls: !!result.toolCalls,
+            toolCallsLength: result.toolCalls?.length || 0,
+            toolCalls: result.toolCalls?.map((toolCall, index) => {
+                const tcRecord = toolCall;
+                const toolName = tcRecord.toolName || tcRecord.name || "unknown";
+                return {
+                    index: index + 1,
+                    toolName,
+                    toolId: tcRecord.toolCallId || tcRecord.id || "none",
+                    hasArgs: !!tcRecord.args,
+                    argsKeys: tcRecord.args && typeof tcRecord.args === "object"
+                        ? Object.keys(tcRecord.args)
+                        : [],
+                };
+            }) || [],
+        };
+        logger.debug("Tool Calls Analysis", toolCallsAnalysis);
+    }
+}

package/dist/core/modules/MessageBuilder.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Message Builder Module
+ *
+ * Handles all message construction logic for AI providers.
+ * Extracted from BaseProvider to follow Single Responsibility Principle.
+ *
+ * Responsibilities:
+ * - Building messages from text generation options
+ * - Building messages from stream options
+ * - Multimodal input detection
+ * - Message format conversion (to CoreMessage[])
+ *
+ * @module core/modules/MessageBuilder
+ */
+import type { CoreMessage } from "ai";
+import type { TextGenerationOptions, AIProviderName } from "../../types/index.js";
+import type { StreamOptions } from "../../types/streamTypes.js";
+/**
+ * MessageBuilder class - Handles message construction for AI providers
+ */
+export declare class MessageBuilder {
+    private readonly providerName;
+    private readonly modelName;
+    constructor(providerName: AIProviderName, modelName: string);
+    /**
+     * Build messages array for generation
+     * Detects multimodal input and routes to appropriate message builder
+     */
+    buildMessages(options: TextGenerationOptions): Promise<CoreMessage[]>;
+    /**
+     * Build messages array for streaming operations
+     * This is a protected helper method that providers can use to build messages
+     * with automatic multimodal detection, eliminating code duplication
+     *
+     * @param options - Stream options or text generation options
+     * @returns Promise resolving to CoreMessage array ready for AI SDK
+     */
+    buildMessagesForStream(options: StreamOptions | TextGenerationOptions): Promise<CoreMessage[]>;
+}

package/dist/core/modules/MessageBuilder.js

@@ -0,0 +1,179 @@
+/**
+ * Message Builder Module
+ *
+ * Handles all message construction logic for AI providers.
+ * Extracted from BaseProvider to follow Single Responsibility Principle.
+ *
+ * Responsibilities:
+ * - Building messages from text generation options
+ * - Building messages from stream options
+ * - Multimodal input detection
+ * - Message format conversion (to CoreMessage[])
+ *
+ * @module core/modules/MessageBuilder
+ */
+import { logger } from "../../utils/logger.js";
+import { buildMessagesArray, buildMultimodalMessagesArray, } from "../../utils/messageBuilder.js";
+/**
+ * MessageBuilder class - Handles message construction for AI providers
+ */
+export class MessageBuilder {
+    providerName;
+    modelName;
+    constructor(providerName, modelName) {
+        this.providerName = providerName;
+        this.modelName = modelName;
+    }
+    /**
+     * Build messages array for generation
+     * Detects multimodal input and routes to appropriate message builder
+     */
+    async buildMessages(options) {
+        const hasMultimodalInput = (opts) => {
+            const input = opts.input;
+            const hasImages = !!input?.images?.length;
+            const hasContent = !!input?.content?.length;
+            const hasCSVFiles = !!input?.csvFiles?.length;
+            const hasPdfFiles = !!input?.pdfFiles?.length;
+            const hasFiles = !!input?.files?.length;
+            return hasImages || hasContent || hasCSVFiles || hasPdfFiles || hasFiles;
+        };
+        let messages;
+        if (hasMultimodalInput(options)) {
+            if (process.env.NEUROLINK_DEBUG === "true") {
+                logger.debug("Detected multimodal input, using multimodal message builder");
+            }
+            const input = options.input;
+            const multimodalOptions = {
+                input: {
+                    text: options.prompt || options.input?.text || "",
+                    images: input?.images,
+                    content: input?.content,
+                    csvFiles: input?.csvFiles,
+                    pdfFiles: input?.pdfFiles,
+                    files: input?.files,
+                },
+                csvOptions: options.csvOptions,
+                provider: options.provider,
+                model: options.model,
+                temperature: options.temperature,
+                maxTokens: options.maxTokens,
+                systemPrompt: options.systemPrompt,
+                enableAnalytics: options.enableAnalytics,
+                enableEvaluation: options.enableEvaluation,
+                context: options.context,
+                conversationHistory: options.conversationMessages,
+            };
+            messages = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
+        }
+        else {
+            if (process.env.NEUROLINK_DEBUG === "true") {
+                logger.debug("No multimodal input detected, using standard message builder");
+            }
+            messages = await buildMessagesArray(options);
+        }
+        // Convert messages to Vercel AI SDK format
+        return messages.map((msg) => {
+            if (typeof msg.content === "string") {
+                return {
+                    role: msg.role,
+                    content: msg.content,
+                };
+            }
+            else {
+                return {
+                    role: msg.role,
+                    content: msg.content.map((item) => {
+                        if (item.type === "text") {
+                            return { type: "text", text: item.text || "" };
+                        }
+                        else if (item.type === "image") {
+                            return { type: "image", image: item.image || "" };
+                        }
+                        return item;
+                    }),
+                };
+            }
+        });
+    }
+    /**
+     * Build messages array for streaming operations
+     * This is a protected helper method that providers can use to build messages
+     * with automatic multimodal detection, eliminating code duplication
+     *
+     * @param options - Stream options or text generation options
+     * @returns Promise resolving to CoreMessage array ready for AI SDK
+     */
+    async buildMessagesForStream(options) {
+        // Detect multimodal input
+        const hasMultimodalInput = (opts) => {
+            const input = opts.input;
+            const hasImages = !!input?.images?.length;
+            const hasContent = !!input?.content?.length;
+            const hasCSVFiles = !!input?.csvFiles?.length;
+            const hasPdfFiles = !!input?.pdfFiles?.length;
+            const hasFiles = !!input?.files?.length;
+            return hasImages || hasContent || hasCSVFiles || hasPdfFiles || hasFiles;
+        };
+        let messages;
+        if (hasMultimodalInput(options)) {
+            if (process.env.NEUROLINK_DEBUG === "true") {
+                logger.debug(`${this.providerName}: Detected multimodal input, using multimodal message builder`);
+            }
+            const input = options.input;
+            const multimodalOptions = {
+                input: {
+                    text: options.prompt ||
+                        options.input?.text ||
+                        "",
+                    images: input?.images,
+                    content: input?.content,
+                    csvFiles: input?.csvFiles,
+                    pdfFiles: input?.pdfFiles,
+                    files: input?.files,
+                },
+                csvOptions: options.csvOptions,
+                provider: options.provider,
+                model: options.model,
+                temperature: options.temperature,
+                maxTokens: options.maxTokens,
+                systemPrompt: options.systemPrompt,
+                enableAnalytics: options.enableAnalytics,
+                enableEvaluation: options.enableEvaluation,
+                context: options.context,
+                conversationHistory: options
+                    .conversationMessages,
+            };
+            messages = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
+        }
+        else {
+            if (process.env.NEUROLINK_DEBUG === "true") {
+                logger.debug(`${this.providerName}: No multimodal input detected, using standard message builder`);
+            }
+            messages = await buildMessagesArray(options);
+        }
+        // Convert messages to Vercel AI SDK format
+        return messages.map((msg) => {
+            if (typeof msg.content === "string") {
+                return {
+                    role: msg.role,
+                    content: msg.content,
+                };
+            }
+            else {
+                return {
+                    role: msg.role,
+                    content: msg.content.map((item) => {
+                        if (item.type === "text") {
+                            return { type: "text", text: item.text || "" };
+                        }
+                        else if (item.type === "image") {
+                            return { type: "image", image: item.image || "" };
+                        }
+                        return item;
+                    }),
+                };
+            }
+        });
+    }
+}

package/dist/core/modules/StreamHandler.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Stream Handler Module
+ *
+ * Handles streaming-related validation, result creation, and analytics.
+ * Extracted from BaseProvider to follow Single Responsibility Principle.
+ *
+ * Responsibilities:
+ * - Stream options validation
+ * - Text stream creation
+ * - Stream result formatting
+ * - Stream analytics creation
+ *
+ * @module core/modules/StreamHandler
+ */
+import type { StreamOptions, StreamResult } from "../../types/streamTypes.js";
+import type { UnknownRecord } from "../../types/common.js";
+import type { AIProviderName } from "../../types/index.js";
+/**
+ * StreamHandler class - Handles streaming operations for AI providers
+ */
+export declare class StreamHandler {
+    private readonly providerName;
+    private readonly modelName;
+    constructor(providerName: AIProviderName, modelName: string);
+    /**
+     * Validate stream options - consolidates validation from 7/10 providers
+     */
+    validateStreamOptions(options: StreamOptions): void;
+    /**
+     * Create text stream transformation - consolidates identical logic from 7/10 providers
+     */
+    createTextStream(result: {
+        textStream: AsyncIterable<string>;
+    }): AsyncGenerator<{
+        content: string;
+    }>;
+    /**
+     * Create standardized stream result - consolidates result structure
+     */
+    createStreamResult(stream: AsyncGenerator<{
+        content: string;
+    }>, additionalProps?: Partial<StreamResult>): StreamResult;
+    /**
+     * Create stream analytics - consolidates analytics from 4/10 providers
+     */
+    createStreamAnalytics(result: UnknownRecord, startTime: number, options: StreamOptions): Promise<UnknownRecord | undefined>;
+    /**
+     * Validate streaming-only options (called before executeStream)
+     * Simpler validation for options object structure
+     */
+    validateStreamOptionsOnly(options: StreamOptions): void;
+}