@juspay/neurolink 7.6.0 → 7.7.0

package/dist/providers/ollama.js

@@ -3,6 +3,7 @@ import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
 import { getDefaultTimeout, TimeoutError } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
+import { modelConfig } from "../core/modelConfiguration.js";
 // Model version constants (configurable via environment)
 const DEFAULT_OLLAMA_MODEL = "llama3.1:8b";
 const FALLBACK_OLLAMA_MODEL = "llama3.2:latest"; // Used when primary model fails
@@ -247,49 +248,47 @@ export class OllamaProvider extends BaseProvider {
         return this.ollamaModel;
     }
     /**
-     * Ollama tool/function calling support is currently disabled due to integration issues.
+     * Ollama Tool Calling Support (Enhanced 2025)
      *
-     * **Current Issues:**
-     * 1. The OllamaLanguageModel from @ai-sdk/provider-utils doesn't properly integrate
-     *    with BaseProvider's tool calling mechanism
-     * 2. Ollama models require specific prompt formatting for function calls that differs
-     *    from the standardized AI SDK format
-     * 3. Tool response parsing and execution flow needs custom implementation
+     * Uses configurable model list from ModelConfiguration instead of hardcoded values.
+     * Tool-capable models can be configured via OLLAMA_TOOL_CAPABLE_MODELS environment variable.
      *
-     * **What's needed to enable tool support:**
-     * - Create a custom OllamaLanguageModel wrapper that handles tool schema formatting
-     * - Implement Ollama-specific tool calling prompt templates
-     * - Add proper response parsing for Ollama's function call format
-     * - Test with models that support function calling (llama3.1, mistral, etc.)
+     * **Configuration Options:**
+     * - Environment variable: OLLAMA_TOOL_CAPABLE_MODELS (comma-separated list)
+     * - Configuration file: providers.ollama.modelBehavior.toolCapableModels
+     * - Fallback: Default list of known tool-capable models
      *
-     * **Tracking:**
-     * - See BaseProvider tool integration patterns in other providers
-     * - Monitor Ollama function calling documentation: https://ollama.com/blog/tool-support
-     * - Track AI SDK updates for better Ollama integration
+     * **Implementation Features:**
+     * - Direct Ollama API integration (/v1/chat/completions)
+     * - Automatic tool schema conversion to Ollama format
+     * - Streaming tool calls with incremental response parsing
+     * - Model compatibility validation and fallback handling
      *
-     * @returns false to disable tools by default
+     * @returns true for supported models, false for unsupported models
      */
     supportsTools() {
-        // IMPLEMENTATION STATUS (2025): Ollama function calling actively evolving
-        //
-        // Current State:
-        // - Function calling added in Ollama 2024, improving in 2025
-        // - Requires compatible models (Llama 3.1+, Code Llama variants)
-        // - AI SDK integration needs custom adapter for Ollama's tool format
-        //
-        // Technical Requirements:
-        // 1. Replace AI SDK with direct Ollama API tool calls
-        // 2. Implement Ollama-specific tool schema conversion
-        // 3. Add function response parsing from Ollama's JSON format
-        // 4. Handle streaming tool calls with incremental parsing
-        // 5. Validate model compatibility before enabling tools
-        //
-        // Implementation Path:
-        // - Use Ollama's chat API with 'tools' parameter
-        // - Parse tool_calls from response.message.tool_calls
-        // - Execute functions and return results to conversation
-        //
-        // Until Ollama-specific implementation, tools disabled for compatibility
+        const modelName = this.modelName.toLowerCase();
+        // Get tool-capable models from configuration
+        const ollamaConfig = modelConfig.getProviderConfig("ollama");
+        const toolCapableModels = ollamaConfig?.modelBehavior?.toolCapableModels || [];
+        // Check if current model matches any tool-capable model patterns
+        const isToolCapable = toolCapableModels.some((capableModel) => modelName.includes(capableModel));
+        if (isToolCapable) {
+            logger.debug("Ollama tool calling enabled", {
+                model: this.modelName,
+                reason: "Model supports function calling",
+                baseUrl: this.baseUrl,
+                configuredModels: toolCapableModels.length,
+            });
+            return true;
+        }
+        // Log why tools are disabled for transparency
+        logger.debug("Ollama tool calling disabled", {
+            model: this.modelName,
+            reason: "Model not in tool-capable list",
+            suggestion: "Consider using llama3.1:8b-instruct, mistral:7b-instruct, or hermes3:8b for tool calling",
+            availableToolModels: toolCapableModels.slice(0, 3), // Show first 3 for brevity
+        });
         return false;
     }
     // executeGenerate removed - BaseProvider handles all generation with tools
@@ -297,43 +296,216 @@ export class OllamaProvider extends BaseProvider {
         try {
             this.validateStreamOptions(options);
             await this.checkOllamaHealth();
-            // Direct HTTP streaming implementation for better compatibility
-            const response = await fetch(`${this.baseUrl}/api/generate`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                    model: this.modelName || FALLBACK_OLLAMA_MODEL,
-                    prompt: options.input.text,
-                    system: options.systemPrompt,
-                    stream: true,
-                    options: {
-                        temperature: options.temperature,
-                        num_predict: options.maxTokens || DEFAULT_MAX_TOKENS,
-                    },
-                }),
-                signal: createAbortSignalWithTimeout(this.timeout),
-            });
-            if (!response.ok) {
-                throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+            // Check if tools are supported and provided
+            const modelSupportsTools = this.supportsTools();
+            const hasTools = options.tools && Object.keys(options.tools).length > 0;
+            if (modelSupportsTools && hasTools) {
+                // Use chat API with tools for tool-capable models
+                return this.executeStreamWithTools(options, analysisSchema);
+            }
+            else {
+                // Use generate API for non-tool scenarios
+                return this.executeStreamWithoutTools(options, analysisSchema);
             }
-            // Transform to async generator to match other providers
-            const self = this;
-            const transformedStream = async function* () {
-                const generator = self.createOllamaStream(response);
-                for await (const chunk of generator) {
-                    yield chunk;
-                }
-            };
-            return {
-                stream: transformedStream(),
-                provider: this.providerName,
-                model: this.modelName,
-            };
         }
         catch (error) {
             throw this.handleProviderError(error);
         }
     }
+    /**
+     * Execute streaming with Ollama's function calling support
+     * Uses the /v1/chat/completions endpoint with tools parameter
+     */
+    async executeStreamWithTools(options, analysisSchema) {
+        // Convert tools to Ollama format
+        const ollamaTools = this.convertToolsToOllamaFormat(options.tools);
+        // Prepare messages in Ollama chat format
+        const messages = [
+            ...(options.systemPrompt
+                ? [{ role: "system", content: options.systemPrompt }]
+                : []),
+            { role: "user", content: options.input.text },
+        ];
+        const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                model: this.modelName || FALLBACK_OLLAMA_MODEL,
+                messages,
+                tools: ollamaTools,
+                tool_choice: "auto",
+                stream: true,
+                temperature: options.temperature,
+                max_tokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+            }),
+            signal: createAbortSignalWithTimeout(this.timeout),
+        });
+        if (!response.ok) {
+            // Fallback to non-tool mode if chat API fails
+            logger.warn("Ollama chat API failed, falling back to generate API", {
+                status: response.status,
+                statusText: response.statusText,
+            });
+            return this.executeStreamWithoutTools(options, analysisSchema);
+        }
+        // Transform to async generator with tool call handling
+        const self = this;
+        const transformedStream = async function* () {
+            const generator = self.createOllamaChatStream(response, options.tools);
+            for await (const chunk of generator) {
+                yield chunk;
+            }
+        };
+        return {
+            stream: transformedStream(),
+            provider: self.providerName,
+            model: self.modelName,
+        };
+    }
+    /**
+     * Execute streaming without tools using the generate API
+     * Fallback for non-tool scenarios or when chat API is unavailable
+     */
+    async executeStreamWithoutTools(options, analysisSchema) {
+        const response = await fetch(`${this.baseUrl}/api/generate`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                model: this.modelName || FALLBACK_OLLAMA_MODEL,
+                prompt: options.input.text,
+                system: options.systemPrompt,
+                stream: true,
+                options: {
+                    temperature: options.temperature,
+                    num_predict: options.maxTokens || DEFAULT_MAX_TOKENS,
+                },
+            }),
+            signal: createAbortSignalWithTimeout(this.timeout),
+        });
+        if (!response.ok) {
+            throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+        }
+        // Transform to async generator to match other providers
+        const self = this;
+        const transformedStream = async function* () {
+            const generator = self.createOllamaStream(response);
+            for await (const chunk of generator) {
+                yield chunk;
+            }
+        };
+        return {
+            stream: transformedStream(),
+            provider: this.providerName,
+            model: this.modelName,
+        };
+    }
+    /**
+     * Convert AI SDK tools format to Ollama's function calling format
+     */
+    convertToolsToOllamaFormat(tools) {
+        if (!tools || typeof tools !== "object") {
+            return [];
+        }
+        const toolsArray = Array.isArray(tools) ? tools : Object.values(tools);
+        return toolsArray.map((tool) => ({
+            type: "function",
+            function: {
+                name: tool.name || tool.function?.name,
+                description: tool.description || tool.function?.description,
+                parameters: tool.parameters ||
+                    tool.function?.parameters || {
+                    type: "object",
+                    properties: {},
+                    required: [],
+                },
+            },
+        }));
+    }
+    /**
+     * Create stream generator for Ollama chat API with tool call support
+     */
+    async *createOllamaChatStream(response, tools) {
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new Error("No response body");
+        }
+        const decoder = new TextDecoder();
+        let buffer = "";
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    if (line.trim() && line.startsWith("data: ")) {
+                        const dataLine = line.slice(6); // Remove "data: " prefix
+                        if (dataLine === "[DONE]") {
+                            return;
+                        }
+                        try {
+                            const data = JSON.parse(dataLine);
+                            const delta = data.choices?.[0]?.delta;
+                            if (delta?.content) {
+                                yield { content: delta.content };
+                            }
+                            if (delta?.tool_calls) {
+                                // Handle tool calls - for now, we'll include them as content
+                                // Future enhancement: Execute tools and return results
+                                const toolCallDescription = this.formatToolCallForDisplay(delta.tool_calls);
+                                if (toolCallDescription) {
+                                    yield { content: toolCallDescription };
+                                }
+                            }
+                            if (data.choices?.[0]?.finish_reason) {
+                                return;
+                            }
+                        }
+                        catch (error) {
+                            // Ignore JSON parse errors for incomplete chunks
+                        }
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    /**
+     * Format tool calls for display when tools aren't executed directly
+     */
+    formatToolCallForDisplay(toolCalls) {
+        if (!toolCalls || toolCalls.length === 0) {
+            return "";
+        }
+        const descriptions = toolCalls.map((call) => {
+            const functionName = call.function?.name || "unknown_function";
+            let args = {};
+            if (call.function?.arguments) {
+                try {
+                    args = JSON.parse(call.function.arguments);
+                }
+                catch (error) {
+                    // If arguments are malformed, preserve for debugging while marking as invalid
+                    logger.warn?.("Malformed tool call arguments: " + call.function.arguments);
+                    args = {
+                        _malformed: true,
+                        _originalArguments: call.function.arguments,
+                        _error: error instanceof Error ? error.message : String(error),
+                    };
+                }
+            }
+            return `\n[Tool Call: ${functionName}(${JSON.stringify(args)})]`;
+        });
+        return descriptions.join("");
+    }
+    /**
+     * Create stream generator for Ollama generate API (non-tool mode)
+     */
     async *createOllamaStream(response) {
         const reader = response.body?.getReader();
         if (!reader) {
@@ -449,5 +621,41 @@ export class OllamaProvider extends BaseProvider {
         const models = await this.getAvailableModels();
         return models.includes(modelName);
     }
+    /**
+     * Get recommendations for tool-calling capable Ollama models
+     * Provides guidance for users who want to use function calling locally
+     */
+    static getToolCallingRecommendations() {
+        return {
+            recommended: [
+                "llama3.1:8b-instruct",
+                "mistral:7b-instruct-v0.3",
+                "hermes3:8b-llama3.1",
+                "codellama:34b-instruct",
+                "firefunction-v2:70b",
+            ],
+            performance: {
+                "llama3.1:8b-instruct": { speed: 3, quality: 3, size: "4.6GB" },
+                "mistral:7b-instruct-v0.3": { speed: 3, quality: 2, size: "4.1GB" },
+                "hermes3:8b-llama3.1": { speed: 3, quality: 3, size: "4.6GB" },
+                "codellama:34b-instruct": { speed: 1, quality: 3, size: "19GB" },
+                "firefunction-v2:70b": { speed: 1, quality: 3, size: "40GB" },
+            },
+            notes: {
+                "llama3.1:8b-instruct": "Best balance of speed, quality, and tool calling capability",
+                "mistral:7b-instruct-v0.3": "Lightweight with reliable function calling",
+                "hermes3:8b-llama3.1": "Specialized for tool execution and reasoning",
+                "codellama:34b-instruct": "Excellent for code-related tool calling, requires more resources",
+                "firefunction-v2:70b": "Optimized specifically for function calling, requires high-end hardware",
+            },
+            installation: {
+                "llama3.1:8b-instruct": "ollama pull llama3.1:8b-instruct",
+                "mistral:7b-instruct-v0.3": "ollama pull mistral:7b-instruct-v0.3",
+                "hermes3:8b-llama3.1": "ollama pull hermes3:8b-llama3.1",
+                "codellama:34b-instruct": "ollama pull codellama:34b-instruct",
+                "firefunction-v2:70b": "ollama pull firefunction-v2:70b",
+            },
+        };
+    }
 }
 export default OllamaProvider;

package/dist/sdk/toolRegistration.d.ts

@@ -8,6 +8,18 @@ import { logger } from "../utils/logger.js";
 import type { InMemoryMCPServerConfig, InMemoryToolInfo } from "../types/mcpTypes.js";
 import type { ToolArgs, ToolContext as CoreToolContext, ToolResult, SimpleTool as CoreSimpleTool } from "../types/tools.js";
 import type { JsonValue } from "../types/common.js";
+/**
+ * Enhanced validation configuration
+ */
+declare const VALIDATION_CONFIG: {
+    readonly NAME_MIN_LENGTH: 2;
+    readonly NAME_MAX_LENGTH: 50;
+    readonly DESCRIPTION_MIN_LENGTH: 10;
+    readonly DESCRIPTION_MAX_LENGTH: number;
+    readonly RESERVED_NAMES: Set<string>;
+    readonly RECOMMENDED_PATTERNS: readonly ["get_data", "fetch_info", "calculate_value", "send_message", "create_item", "update_record", "delete_file", "validate_input"];
+    readonly COMPILED_PATTERN_REGEXES: RegExp[];
+};
 /**
  * Context provided to tools during execution
  * Extends the core ToolContext with SDK-specific features
@@ -86,6 +98,13 @@ export declare function createMCPServerFromTools(serverId: string, tools: Record
  * Helper to create a tool with type safety
  */
 export declare function createTool<TParams = ToolArgs>(config: SimpleTool): SimpleTool;
+/**
+ * Helper to create a validated tool with suggested improvements
+ */
+export declare function createValidatedTool(name: string, config: SimpleTool, options?: {
+    strict?: boolean;
+    suggestions?: boolean;
+}): SimpleTool;
 /**
  * Helper to create a tool with typed parameters
  */
@@ -97,3 +116,26 @@ export declare function createTypedTool<TParams extends z.ZodSchema>(config: Omi
  * Validate tool configuration with detailed error messages
  */
 export declare function validateTool(name: string, tool: SimpleTool): void;
+/**
+ * Utility to validate multiple tools at once
+ */
+export declare function validateTools(tools: Record<string, SimpleTool>): {
+    valid: string[];
+    invalid: Array<{
+        name: string;
+        error: string;
+    }>;
+};
+/**
+ * Get validation configuration for external inspection
+ */
+export declare function getValidationConfig(): typeof VALIDATION_CONFIG;
+/**
+ * Check if a tool name is available (not reserved)
+ */
+export declare function isToolNameAvailable(name: string): boolean;
+/**
+ * Suggest alternative tool names if the provided name is invalid
+ */
+export declare function suggestToolNames(baseName: string): string[];
+export {};