neural-ai-sdk 0.1.4 → 0.1.5

package/dist/models/ollama-model.d.ts

@@ -10,6 +10,10 @@ export declare class OllamaModel extends BaseModel {
      * Extract function calls from text using various patterns
      */
     private extractFunctionCallsFromText;
+    /**
+     * Tries to fix incomplete JSON strings by adding missing closing braces
+     */
+    private tryFixIncompleteJSON;
     /**
      * Creates the request payload for Ollama, handling multimodal content if provided
      */

package/dist/models/ollama-model.js

@@ -18,30 +18,70 @@ class OllamaModel extends base_model_1.BaseModel {
     async generate(request) {
         const config = this.mergeConfig(request.options);
         try {
-            // Create and modify the payload for function calling
+            // Create the payload for the request
             const payload = await this.createRequestPayload(request, config);
-            const response = await axios_1.default.post(`${this.baseURL}/generate`, payload, {
+            // Determine which endpoint to use based on the payload format
+            const endpoint = payload.messages ? "chat" : "generate";
+            console.log(`Using Ollama ${endpoint} endpoint with model: ${payload.model || "default"}`);
+            // Set stream to true to handle responses as a stream
+            payload.stream = true;
+            const response = await axios_1.default.post(`${this.baseURL}/${endpoint}`, payload, {
+                responseType: "stream",
                 headers: {
                     "Content-Type": "application/json",
                 },
             });
-            if (!response.data || !response.data.response) {
-                throw new Error("Invalid response from Ollama API");
+            // Accumulate the complete response
+            let responseText = "";
+            let promptTokens = 0;
+            let completionTokens = 0;
+            // Process the stream
+            const reader = response.data;
+            for await (const chunk of reader) {
+                const lines = chunk.toString().split("\n").filter(Boolean);
+                for (const line of lines) {
+                    try {
+                        const parsed = JSON.parse(line);
+                        // Handle different response formats
+                        if (endpoint === "chat") {
+                            if (parsed.message && parsed.message.content) {
+                                responseText += parsed.message.content;
+                            }
+                        }
+                        else if (parsed.response) {
+                            responseText += parsed.response;
+                        }
+                        // Extract token usage from the final message
+                        if (parsed.done) {
+                            promptTokens = parsed.prompt_eval_count || 0;
+                            completionTokens = parsed.eval_count || 0;
+                        }
+                    }
+                    catch (error) {
+                        console.error("Error parsing Ollama stream data:", line, error);
+                    }
+                }
             }
+            console.log(`Extracted response text: "${responseText}"`);
             // Try to extract function calls from the response
-            const functionCalls = this.extractFunctionCallsFromText(response.data.response, request);
+            const functionCalls = this.extractFunctionCallsFromText(responseText, request);
             return {
-                text: response.data.response,
+                text: responseText,
                 usage: {
-                    promptTokens: response.data.prompt_eval_count,
-                    completionTokens: response.data.eval_count,
-                    totalTokens: response.data.prompt_eval_count + response.data.eval_count,
+                    promptTokens: promptTokens,
+                    completionTokens: completionTokens,
+                    totalTokens: promptTokens + completionTokens,
                 },
                 functionCalls,
-                raw: response.data,
+                raw: { response: responseText }, // We don't have the original raw response, so create one
             };
         }
         catch (error) {
+            console.error("Ollama API error details:", error);
+            if (error.response) {
+                console.error("Response status:", error.response.status);
+                console.error("Response data:", error.response.data);
+            }
             // Enhance error message if it appears to be related to multimodal support
             if (error.response?.status === 400 &&
                 (request.image || request.content) &&
@@ -50,6 +90,16 @@ class OllamaModel extends base_model_1.BaseModel {
                     error.response?.data?.error?.includes("vision"))) {
                 throw new Error(`The model "${config.model || "default"}" doesn't support multimodal inputs. Try a vision-capable model like "llama-3.2-vision" or "llava". Original error: ${error.message}`);
             }
+            // Check if the error is about the model not being found or loaded
+            if (error.response?.status === 404 ||
+                (error.response?.data &&
+                    typeof error.response.data.error === "string" &&
+                    error.response.data.error.toLowerCase().includes("model") &&
+                    error.response.data.error.toLowerCase().includes("not"))) {
+                throw new Error(`Model "${config.model || "default"}" not found or not loaded in Ollama. ` +
+                    `Make sure the model is installed with 'ollama pull ${config.model || "llama2"}' ` +
+                    `Original error: ${error.response?.data?.error || error.message}`);
+            }
             throw error;
         }
     }
@@ -57,7 +107,9 @@ class OllamaModel extends base_model_1.BaseModel {
         const config = this.mergeConfig(request.options);
         try {
             const payload = await this.createRequestPayload(request, config, true);
-            const response = await axios_1.default.post(`${this.baseURL}/generate`, payload, {
+            // Determine which endpoint to use based on the payload format
+            const endpoint = payload.messages ? "chat" : "generate";
+            const response = await axios_1.default.post(`${this.baseURL}/${endpoint}`, payload, {
                 responseType: "stream",
                 headers: {
                     "Content-Type": "application/json",
@@ -69,7 +121,13 @@ class OllamaModel extends base_model_1.BaseModel {
                 for (const line of lines) {
                     try {
                         const parsed = JSON.parse(line);
-                        if (parsed.response) {
+                        // Handle different response formats
+                        if (endpoint === "chat") {
+                            if (parsed.message && parsed.message.content) {
+                                yield parsed.message.content;
+                            }
+                        }
+                        else if (parsed.response) {
                             yield parsed.response;
                         }
                     }
@@ -98,16 +156,20 @@ class OllamaModel extends base_model_1.BaseModel {
         if (!text)
             return undefined;
         try {
-            // Try multiple patterns for function calls
+            // Fix incomplete JSON - look for patterns where JSON might be incomplete
+            // First, let's try to fix a common issue where the closing brace is missing
+            const fixedText = this.tryFixIncompleteJSON(text);
             // Pattern 1: JSON format with name and arguments
             // E.g., {"name": "getWeather", "arguments": {"location": "Tokyo"}}
             const jsonRegex = /\{[\s\n]*"name"[\s\n]*:[\s\n]*"([^"]+)"[\s\n]*,[\s\n]*"arguments"[\s\n]*:[\s\n]*([\s\S]*?)\}/g;
-            const jsonMatches = [...text.matchAll(jsonRegex)];
+            const jsonMatches = [...fixedText.matchAll(jsonRegex)];
             if (jsonMatches.length > 0) {
                 return jsonMatches.map((match) => {
                     try {
                         // Try to parse the arguments as JSON
-                        const argsText = match[2];
+                        let argsText = match[2];
+                        // Fix potential incomplete JSON in arguments
+                        argsText = this.tryFixIncompleteJSON(argsText);
                         let args;
                         try {
                             args = JSON.parse(argsText);
@@ -117,10 +179,11 @@ class OllamaModel extends base_model_1.BaseModel {
                             };
                         }
                         catch (e) {
-                            // If parsing fails, use the raw text
+                            // If parsing fails, try to fix the JSON before returning
+                            console.warn("Error parsing function arguments, trying to fix:", e);
                             return {
                                 name: match[1],
-                                arguments: argsText,
+                                arguments: this.tryFixIncompleteJSON(argsText, true),
                             };
                         }
                     }
@@ -135,46 +198,88 @@ class OllamaModel extends base_model_1.BaseModel {
             }
             // Pattern 2: Function call pattern: functionName({"key": "value"})
             const functionRegex = /([a-zA-Z0-9_]+)\s*\(\s*(\{[\s\S]*?\})\s*\)/g;
-            const functionMatches = [...text.matchAll(functionRegex)];
+            const functionMatches = [...fixedText.matchAll(functionRegex)];
             if (functionMatches.length > 0) {
-                return functionMatches.map((match) => ({
-                    name: match[1],
-                    arguments: match[2],
-                }));
+                return functionMatches.map((match) => {
+                    const argsText = this.tryFixIncompleteJSON(match[2]);
+                    return {
+                        name: match[1],
+                        arguments: argsText,
+                    };
+                });
             }
-            // Pattern 3: Look for more specific calculator patterns
+            // Pattern 3: Looking for direct JSON objects - for function specific forced calls
             if (currentRequest.functionCall &&
-                typeof currentRequest.functionCall === "object" &&
-                currentRequest.functionCall.name === "calculator") {
-                const calculatorRegex = /"?operation"?\s*:\s*"?([^",\s]+)"?,\s*"?a"?\s*:\s*(\d+),\s*"?b"?\s*:\s*(\d+)/;
-                const calculatorMatch = text.match(calculatorRegex);
-                if (calculatorMatch) {
-                    const operation = calculatorMatch[1];
-                    const a = parseInt(calculatorMatch[2]);
-                    const b = parseInt(calculatorMatch[3]);
-                    return [
-                        {
-                            name: "calculator",
-                            arguments: JSON.stringify({ operation, a, b }),
-                        },
-                    ];
+                typeof currentRequest.functionCall === "object") {
+                const forcedFunctionName = currentRequest.functionCall.name;
+                // For getWeather function
+                if (forcedFunctionName === "getWeather") {
+                    const weatherMatch = fixedText.match(/\{[\s\n]*"location"[\s\n]*:[\s\n]*"([^"]*)"(?:[\s\n]*,[\s\n]*"unit"[\s\n]*:[\s\n]*"([^"]*)"|)(.*?)\}/s);
+                    if (weatherMatch) {
+                        const location = weatherMatch[1];
+                        const unit = weatherMatch[2] || "celsius";
+                        return [
+                            {
+                                name: "getWeather",
+                                arguments: JSON.stringify({ location, unit }),
+                            },
+                        ];
+                    }
+                }
+                // For calculator function
+                if (forcedFunctionName === "calculator") {
+                    const calculatorMatch = fixedText.match(/\{[\s\n]*"operation"[\s\n]*:[\s\n]*"([^"]*)"[\s\n]*,[\s\n]*"a"[\s\n]*:[\s\n]*(\d+)[\s\n]*,[\s\n]*"b"[\s\n]*:[\s\n]*(\d+)[\s\S]*?\}/s);
+                    if (calculatorMatch) {
+                        const operation = calculatorMatch[1];
+                        const a = parseInt(calculatorMatch[2]);
+                        const b = parseInt(calculatorMatch[3]);
+                        return [
+                            {
+                                name: "calculator",
+                                arguments: JSON.stringify({ operation, a, b }),
+                            },
+                        ];
+                    }
                 }
             }
-            // Pattern 4: Look for more specific weather patterns
-            if (currentRequest.functionCall &&
-                typeof currentRequest.functionCall === "object" &&
-                currentRequest.functionCall.name === "getWeather") {
-                const weatherRegex = /"?location"?\s*:\s*"([^"]+)"(?:,\s*"?unit"?\s*:\s*"([^"]+)")?/;
-                const weatherMatch = text.match(weatherRegex);
-                if (weatherMatch) {
-                    const location = weatherMatch[1];
-                    const unit = weatherMatch[2] || "celsius";
-                    return [
-                        {
-                            name: "getWeather",
-                            arguments: JSON.stringify({ location, unit }),
-                        },
-                    ];
+            // If no matches found and we have a functionCall request, try one more pattern matching approach
+            if (currentRequest.functionCall) {
+                // Try to extract JSON-like structures even if they're not complete
+                const namedFunction = typeof currentRequest.functionCall === "object"
+                    ? currentRequest.functionCall.name
+                    : null;
+                // Look for the function name in the text followed by arguments
+                const functionNamePattern = namedFunction
+                    ? new RegExp(`"name"\\s*:\\s*"${namedFunction}"\\s*,\\s*"arguments"\\s*:\\s*(\\{[\\s\\S]*?)(?:\\}|$)`, "s")
+                    : null;
+                if (functionNamePattern) {
+                    const extractedMatch = fixedText.match(functionNamePattern);
+                    if (extractedMatch && extractedMatch[1]) {
+                        let argsText = extractedMatch[1];
+                        // Make sure the JSON is complete
+                        if (!argsText.endsWith("}")) {
+                            argsText += "}";
+                        }
+                        try {
+                            // Try to parse the fixed arguments
+                            const args = JSON.parse(argsText);
+                            return [
+                                {
+                                    name: namedFunction,
+                                    arguments: JSON.stringify(args),
+                                },
+                            ];
+                        }
+                        catch (e) {
+                            console.warn("Failed to parse extracted arguments:", e);
+                            return [
+                                {
+                                    name: namedFunction,
+                                    arguments: this.tryFixIncompleteJSON(argsText, true),
+                                },
+                            ];
+                        }
+                    }
                 }
             }
         }
@@ -183,6 +288,40 @@ class OllamaModel extends base_model_1.BaseModel {
         }
         return undefined;
     }
+    /**
+     * Tries to fix incomplete JSON strings by adding missing closing braces
+     */
+    tryFixIncompleteJSON(text, returnAsString = false) {
+        // Skip if the string is already valid JSON
+        try {
+            JSON.parse(text);
+            return text; // Already valid
+        }
+        catch (e) {
+            // Not valid JSON, try to fix
+        }
+        // Count opening and closing braces
+        const openBraces = (text.match(/\{/g) || []).length;
+        const closeBraces = (text.match(/\}/g) || []).length;
+        // If we have more opening braces than closing, add the missing closing braces
+        if (openBraces > closeBraces) {
+            const missingBraces = openBraces - closeBraces;
+            let fixedText = text + "}".repeat(missingBraces);
+            // Try to parse it to see if it's valid now
+            try {
+                if (!returnAsString) {
+                    JSON.parse(fixedText);
+                }
+                return fixedText;
+            }
+            catch (e) {
+                // Still not valid, return the original
+                console.warn("Failed to fix JSON even after adding braces", e);
+                return text;
+            }
+        }
+        return text;
+    }
     /**
      * Creates the request payload for Ollama, handling multimodal content if provided
      */
@@ -191,9 +330,12 @@ class OllamaModel extends base_model_1.BaseModel {
         const payload = {
             model: config.model || "llama3", // Updated default to a model that better supports function calling
             temperature: config.temperature,
-            num_predict: config.maxTokens,
             top_p: config.topP,
         };
+        // Add max tokens for the generate endpoint
+        if (config.maxTokens) {
+            payload.num_predict = config.maxTokens;
+        }
         // Handle streaming
         if (isStream) {
             payload.stream = true;
@@ -202,9 +344,10 @@ class OllamaModel extends base_model_1.BaseModel {
         const useMessagesFormat = request.image ||
             (request.content &&
                 request.content.some((item) => item.type === "image")) ||
-            (request.functions && request.functions.length > 0);
+            (request.functions && request.functions.length > 0) ||
+            request.systemPrompt; // Always use messages format when system prompt is provided
         if (useMessagesFormat) {
-            // Modern message-based format for Ollama
+            // Modern message-based format for Ollama (chat endpoint)
             const messages = [];
             // Add system prompt if provided
             if (request.systemPrompt) {
@@ -213,6 +356,27 @@ class OllamaModel extends base_model_1.BaseModel {
                     content: request.systemPrompt,
                 });
             }
+            else if (request.functions && request.functions.length > 0) {
+                // Add function calling guidance in system prompt if none provided
+                let functionSystemPrompt = "You are a helpful AI assistant with access to functions.";
+                // Add function definitions as JSON
+                functionSystemPrompt += `\n\nAvailable functions:\n\`\`\`json\n${JSON.stringify(request.functions, null, 2)}\n\`\`\`\n\n`;
+                // Add instruction based on functionCall setting
+                if (typeof request.functionCall === "object") {
+                    functionSystemPrompt += `You must call the function: ${request.functionCall.name}.\n`;
+                    functionSystemPrompt += `Format your response as a function call using this exact format:\n`;
+                    functionSystemPrompt += `{"name": "${request.functionCall.name}", "arguments": {...}}\n`;
+                }
+                else if (request.functionCall === "auto") {
+                    functionSystemPrompt += `Call one of these functions if appropriate for the user's request.\n`;
+                    functionSystemPrompt += `Format your response as a function call using this exact format:\n`;
+                    functionSystemPrompt += `{"name": "functionName", "arguments": {...}}\n`;
+                }
+                messages.push({
+                    role: "system",
+                    content: functionSystemPrompt,
+                });
+            }
             // Create user message content parts
             let userContent = [];
             // Add main text content
@@ -262,43 +426,24 @@ class OllamaModel extends base_model_1.BaseModel {
             if (userContent.length === 1 && userContent[0].type === "text") {
                 userMessage.content = userContent[0].text;
             }
-            else {
+            else if (userContent.length > 0) {
                 userMessage.content = userContent;
             }
-            messages.push(userMessage);
-            // Add function calling data to system prompt
-            if (request.functions && request.functions.length > 0) {
-                // Create a system prompt for function calling
-                let functionSystemPrompt = request.systemPrompt || "";
-                // Add function definitions as JSON
-                functionSystemPrompt += `\n\nAvailable functions:\n\`\`\`json\n${JSON.stringify(request.functions, null, 2)}\n\`\`\`\n\n`;
-                // Add instruction based on functionCall setting
-                if (typeof request.functionCall === "object") {
-                    functionSystemPrompt += `You must call the function: ${request.functionCall.name}.\n`;
-                    functionSystemPrompt += `Format your response as a function call using this exact format:\n`;
-                    functionSystemPrompt += `{"name": "${request.functionCall.name}", "arguments": {...}}\n`;
-                }
-                else if (request.functionCall === "auto") {
-                    functionSystemPrompt += `Call one of these functions if appropriate for the user's request.\n`;
-                    functionSystemPrompt += `Format your response as a function call using this exact format:\n`;
-                    functionSystemPrompt += `{"name": "functionName", "arguments": {...}}\n`;
-                }
-                // Replace or add the system message
-                if (messages.length > 0 && messages[0].role === "system") {
-                    messages[0].content = functionSystemPrompt;
-                }
-                else {
-                    messages.unshift({
-                        role: "system",
-                        content: functionSystemPrompt,
-                    });
-                }
+            else {
+                // Add empty string if no content provided to avoid invalid request
+                userMessage.content = "";
             }
+            messages.push(userMessage);
             payload.messages = messages;
+            // Remove any fields specific to the generate endpoint
+            // that might cause issues with the chat endpoint
+            if (payload.hasOwnProperty("num_predict")) {
+                delete payload.num_predict;
+            }
         }
         else {
-            // Traditional text-only format
-            let prompt = request.prompt;
+            // Traditional text-only format (generate endpoint)
+            let prompt = request.prompt || "";
             // Add system prompt if provided
             if (request.systemPrompt) {
                 prompt = `${request.systemPrompt}\n\n${prompt}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neural-ai-sdk",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Unified SDK for interacting with various AI LLM providers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",