neural-ai-sdk 0.1.3 → 0.1.5

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

@@ -6,4 +6,8 @@ export declare class DeepSeekModel extends BaseModel {
     constructor(config: AIModelConfig);
     generate(request: AIModelRequest): Promise<AIModelResponse>;
     stream(request: AIModelRequest): AsyncGenerator<string, void, unknown>;
+    /**
+     * Process function calls from DeepSeek API response
+     */
+    private processFunctionCalls;
 }

package/dist/models/deepseek-model.js

@@ -28,19 +28,39 @@ class DeepSeekModel extends base_model_1.BaseModel {
             role: "user",
             content: request.prompt,
         });
-        const response = await axios_1.default.post(`${this.baseURL}/chat/completions`, {
+        // Prepare request payload
+        const payload = {
             model: config.model || "deepseek-chat",
             messages,
             temperature: config.temperature,
             max_tokens: config.maxTokens,
             top_p: config.topP,
-        }, {
+        };
+        // Add function calling support if functions are provided
+        if (request.functions && request.functions.length > 0) {
+            payload.functions = request.functions;
+            // Handle function call configuration
+            if (request.functionCall) {
+                if (request.functionCall === "auto") {
+                    payload.function_call = "auto";
+                }
+                else if (request.functionCall === "none") {
+                    payload.function_call = "none";
+                }
+                else if (typeof request.functionCall === "object") {
+                    payload.function_call = { name: request.functionCall.name };
+                }
+            }
+        }
+        const response = await axios_1.default.post(`${this.baseURL}/chat/completions`, payload, {
             headers: {
                 "Content-Type": "application/json",
                 Authorization: `Bearer ${config.apiKey ||
                     (0, utils_1.getApiKey)(config.apiKey, "DEEPSEEK_API_KEY", "DeepSeek")}`,
             },
         });
+        // Process function calls if any
+        const functionCalls = this.processFunctionCalls(response.data);
         return {
             text: response.data.choices[0].message.content,
             usage: {
@@ -48,6 +68,7 @@ class DeepSeekModel extends base_model_1.BaseModel {
                 completionTokens: response.data.usage?.completion_tokens,
                 totalTokens: response.data.usage?.total_tokens,
             },
+            functionCalls,
             raw: response.data,
         };
     }
@@ -64,14 +85,32 @@ class DeepSeekModel extends base_model_1.BaseModel {
             role: "user",
             content: request.prompt,
         });
-        const response = await axios_1.default.post(`${this.baseURL}/chat/completions`, {
+        // Prepare request payload
+        const payload = {
             model: config.model || "deepseek-chat",
             messages,
             temperature: config.temperature,
             max_tokens: config.maxTokens,
             top_p: config.topP,
             stream: true,
-        }, {
+        };
+        // Add function calling support if functions are provided
+        if (request.functions && request.functions.length > 0) {
+            payload.functions = request.functions;
+            // Handle function call configuration
+            if (request.functionCall) {
+                if (request.functionCall === "auto") {
+                    payload.function_call = "auto";
+                }
+                else if (request.functionCall === "none") {
+                    payload.function_call = "none";
+                }
+                else if (typeof request.functionCall === "object") {
+                    payload.function_call = { name: request.functionCall.name };
+                }
+            }
+        }
+        const response = await axios_1.default.post(`${this.baseURL}/chat/completions`, payload, {
             headers: {
                 "Content-Type": "application/json",
                 Authorization: `Bearer ${config.apiKey ||
@@ -101,5 +140,20 @@ class DeepSeekModel extends base_model_1.BaseModel {
             }
         }
     }
+    /**
+     * Process function calls from DeepSeek API response
+     */
+    processFunctionCalls(response) {
+        if (!response.choices?.[0]?.message?.function_call) {
+            return undefined;
+        }
+        const functionCall = response.choices[0].message.function_call;
+        return [
+            {
+                name: functionCall.name,
+                arguments: functionCall.arguments,
+            },
+        ];
+    }
 }
 exports.DeepSeekModel = DeepSeekModel;

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

@@ -6,6 +6,10 @@ export declare class GoogleModel extends BaseModel {
     constructor(config: AIModelConfig);
     generate(request: AIModelRequest): Promise<AIModelResponse>;
     stream(request: AIModelRequest): AsyncGenerator<string, void, unknown>;
+    /**
+     * Extract function calls from text using regex patterns since we're using prompt engineering
+     */
+    private extractFunctionCallsFromText;
     /**
      * Format content for Google's Gemini API, handling both text and images
      */

package/dist/models/google-model.js

@@ -15,14 +15,56 @@ class GoogleModel extends base_model_1.BaseModel {
     }
     async generate(request) {
         const config = this.mergeConfig(request.options);
-        const model = this.client.getGenerativeModel({
-            model: config.model || "gemini-2.0-flash", // Updated default model
+        // Create base model configuration with Gemini 2.0 models
+        const modelConfig = {
+            model: config.model || "gemini-2.0-flash", // Using 2.0 models as default
             generationConfig: {
                 temperature: config.temperature,
                 maxOutputTokens: config.maxTokens,
                 topP: config.topP,
             },
-        });
+        };
+        const model = this.client.getGenerativeModel(modelConfig);
+        // Handle function calling through prompt engineering for Gemini 2.0 models
+        // as native function calling may not be fully supported in the same way
+        if (request.functions && request.functions.length > 0) {
+            try {
+                // Create an enhanced prompt with function definitions
+                let enhancedPrompt = request.prompt || "";
+                if (request.systemPrompt) {
+                    enhancedPrompt = `${request.systemPrompt}\n\n${enhancedPrompt}`;
+                }
+                // Add function definitions to the prompt
+                enhancedPrompt += `\n\nYou have access to the following functions:\n\`\`\`json\n${JSON.stringify(request.functions, null, 2)}\n\`\`\`\n\n`;
+                // Add specific instructions based on function call mode
+                if (typeof request.functionCall === "object") {
+                    enhancedPrompt += `You MUST use the function: ${request.functionCall.name}\n`;
+                    enhancedPrompt += `Format your response as a function call using JSON in this exact format:\n`;
+                    enhancedPrompt += `{"name": "${request.functionCall.name}", "arguments": {...}}\n`;
+                    enhancedPrompt += `Don't include any explanations, just output the function call.\n`;
+                }
+                else if (request.functionCall === "auto") {
+                    enhancedPrompt += `If appropriate for the request, call one of these functions.\n`;
+                    enhancedPrompt += `Format your response as a function call using JSON in this exact format:\n`;
+                    enhancedPrompt += `{"name": "functionName", "arguments": {...}}\n`;
+                }
+                const result = await model.generateContent(enhancedPrompt);
+                const response = result.response;
+                const text = response.text();
+                // Extract function calls from the response text
+                const functionCalls = this.extractFunctionCallsFromText(text);
+                return {
+                    text,
+                    functionCalls,
+                    raw: response,
+                };
+            }
+            catch (error) {
+                console.warn("Function calling with prompt engineering failed for Gemini, falling back to text-only", error);
+                // Fall back to regular text generation if prompt engineering fails
+            }
+        }
+        // Regular text generation without function calling
         const content = await this.formatMultiModalContent(request);
         const result = await model.generateContent(content);
         const response = result.response;
@@ -32,9 +74,11 @@ class GoogleModel extends base_model_1.BaseModel {
         };
     }
     async *stream(request) {
+        // For streaming, we'll keep it simpler as function calling with streaming
+        // has additional complexities
         const config = this.mergeConfig(request.options);
         const model = this.client.getGenerativeModel({
-            model: config.model || "gemini-2.0-flash", // Updated default model
+            model: config.model || "gemini-2.0-flash", // Using 2.0 models as default
             generationConfig: {
                 temperature: config.temperature,
                 maxOutputTokens: config.maxTokens,
@@ -50,6 +94,96 @@ class GoogleModel extends base_model_1.BaseModel {
             }
         }
     }
+    /**
+     * Extract function calls from text using regex patterns since we're using prompt engineering
+     */
+    extractFunctionCallsFromText(text) {
+        try {
+            if (!text)
+                return undefined;
+            const functionCalls = [];
+            // Pattern 1: JSON object with name and arguments
+            // Try full regex match first
+            const jsonRegex = /\{[\s\n]*"name"[\s\n]*:[\s\n]*"([^"]+)"[\s\n]*,[\s\n]*"arguments"[\s\n]*:[\s\n]*(\{.*?\})\s*\}/gs;
+            let match;
+            while ((match = jsonRegex.exec(text)) !== null) {
+                try {
+                    const name = match[1];
+                    const args = match[2];
+                    functionCalls.push({
+                        name,
+                        arguments: args,
+                    });
+                }
+                catch (e) {
+                    console.warn("Error parsing function call:", e);
+                }
+            }
+            // Pattern 2: Markdown code blocks that might contain JSON
+            const markdownRegex = /```(?:json)?\s*\n\s*(\{[\s\S]*?\})\s*\n```/gs;
+            while ((match = markdownRegex.exec(text)) !== null) {
+                try {
+                    const jsonBlock = match[1].trim();
+                    // Try to parse the JSON
+                    const jsonObj = JSON.parse(jsonBlock);
+                    if (jsonObj.name && (jsonObj.arguments || jsonObj.args)) {
+                        functionCalls.push({
+                            name: jsonObj.name,
+                            arguments: JSON.stringify(jsonObj.arguments || jsonObj.args),
+                        });
+                    }
+                }
+                catch (e) {
+                    // JSON might be malformed, try more aggressive parsing
+                    const nameMatch = match[1].match(/"name"\s*:\s*"([^"]+)"/);
+                    const argsMatch = match[1].match(/"arguments"\s*:\s*(\{[^}]*\})/);
+                    if (nameMatch && argsMatch) {
+                        try {
+                            // Try to fix and parse the arguments
+                            const argumentsStr = argsMatch[1].replace(/,\s*$/, "");
+                            const fixedArgs = argumentsStr + (argumentsStr.endsWith("}") ? "" : "}");
+                            functionCalls.push({
+                                name: nameMatch[1],
+                                arguments: fixedArgs,
+                            });
+                        }
+                        catch (e) {
+                            console.warn("Failed to fix JSON format:", e);
+                        }
+                    }
+                }
+            }
+            // Pattern 3: If still no matches, try looser regex
+            if (functionCalls.length === 0) {
+                // Extract function name and args separately with more permissive patterns
+                const nameMatch = text.match(/"name"\s*:\s*"([^"]+)"/);
+                if (nameMatch) {
+                    const name = nameMatch[1];
+                    // Find arguments block, accounting for potential closing bracket issues
+                    const argsRegex = /"arguments"\s*:\s*(\{[^{]*?(?:\}|$))/;
+                    const argsMatch = text.match(argsRegex);
+                    if (argsMatch) {
+                        let args = argsMatch[1].trim();
+                        // Fix common JSON formatting issues
+                        if (!args.endsWith("}")) {
+                            args += "}";
+                        }
+                        // Clean up trailing commas which cause JSON.parse to fail
+                        args = args.replace(/,\s*}/g, "}");
+                        functionCalls.push({
+                            name,
+                            arguments: args,
+                        });
+                    }
+                }
+            }
+            return functionCalls.length > 0 ? functionCalls : undefined;
+        }
+        catch (error) {
+            console.warn("Error extracting function calls from text:", error);
+            return undefined;
+        }
+    }
     /**
      * Format content for Google's Gemini API, handling both text and images
      */

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

@@ -13,6 +13,11 @@ export declare class HuggingFaceModel extends BaseModel {
      * Generate a response using multimodal inputs (text + images)
      */
     private generateWithImages;
+    /**
+     * Extract function calls from text using pattern matching
+     * This is more robust than the previous implementation and handles various formats
+     */
+    private extractFunctionCallsFromText;
     /**
      * Try generating with nested inputs format (common in newer models)
      */
@@ -22,9 +27,9 @@ export declare class HuggingFaceModel extends BaseModel {
      */
     private generateWithFlatFormat;
     /**
-     * Helper to parse HuggingFace response in various formats
+     * Helper to parse HuggingFace response with function call extraction
      */
-    private parseResponse;
+    private parseResponseWithFunctionCalls;
     /**
      * Fallback method that uses multipart/form-data for older HuggingFace models
      */

package/dist/models/huggingface-model.js

@@ -18,7 +18,8 @@ class HuggingFaceModel extends base_model_1.BaseModel {
     }
     async generate(request) {
         const config = this.mergeConfig(request.options);
-        const model = config.model || "meta-llama/Llama-2-7b-chat-hf";
+        // Use a more accessible default model that doesn't require special permissions
+        const model = config.model || "mistralai/Mistral-7B-Instruct-v0.2";
         try {
             // Try multimodal approach if images are present
             if (request.image ||
@@ -52,6 +53,10 @@ class HuggingFaceModel extends base_model_1.BaseModel {
                     " Try a different vision-capable model like 'llava-hf/llava-1.5-7b-hf' or check HuggingFace's documentation for this specific model.";
                 throw new Error(errorMessage);
             }
+            else if (error.response?.status === 403) {
+                // Handle permission errors more specifically
+                throw new Error(`Permission denied for model "${model}". Try using a different model with public access. Error: ${error.response?.data || error.message}`);
+            }
             throw error;
         }
     }
@@ -63,37 +68,62 @@ class HuggingFaceModel extends base_model_1.BaseModel {
         if (request.systemPrompt) {
             fullPrompt = `${request.systemPrompt}\n\n${fullPrompt}`;
         }
+        // If functions are provided, enhance the prompt to handle function calling
+        if (request.functions && request.functions.length > 0) {
+            // Format the functions in a way the model can understand
+            fullPrompt += `\n\nAVAILABLE FUNCTIONS:\n${JSON.stringify(request.functions, null, 2)}\n\n`;
+            // Add guidance based on function call setting
+            if (typeof request.functionCall === "object") {
+                fullPrompt += `You must call the function: ${request.functionCall.name}.\n`;
+                fullPrompt += `Format your answer as a function call using JSON, like this:\n`;
+                fullPrompt += `{"name": "${request.functionCall.name}", "arguments": {...}}\n`;
+                fullPrompt += `Don't include any explanations, just output the function call.\n`;
+            }
+            else if (request.functionCall === "auto") {
+                fullPrompt += `Call one of the available functions if appropriate. Format the function call as JSON, like this:\n`;
+                fullPrompt += `{"name": "functionName", "arguments": {...}}\n`;
+            }
+        }
         const payload = {
             inputs: fullPrompt,
             parameters: {
-                temperature: config.temperature,
-                max_new_tokens: config.maxTokens,
-                top_p: config.topP,
+                temperature: config.temperature || 0.1,
+                max_new_tokens: config.maxTokens || 500,
+                top_p: config.topP || 0.9,
                 return_full_text: false,
             },
         };
-        const response = await axios_1.default.post(`${this.baseURL}/${model}`, payload, {
-            headers: {
-                Authorization: `Bearer ${config.apiKey ||
-                    (0, utils_1.getApiKey)(config.apiKey, "HUGGINGFACE_API_KEY", "HuggingFace")}`,
-                "Content-Type": "application/json",
-            },
-        });
-        // HuggingFace can return different formats depending on the model
-        let text = "";
-        if (Array.isArray(response.data)) {
-            text = response.data[0]?.generated_text || "";
-        }
-        else if (response.data.generated_text) {
-            text = response.data.generated_text;
+        try {
+            const response = await axios_1.default.post(`${this.baseURL}/${model}`, payload, {
+                headers: {
+                    Authorization: `Bearer ${config.apiKey ||
+                        (0, utils_1.getApiKey)(config.apiKey, "HUGGINGFACE_API_KEY", "HuggingFace")}`,
+                    "Content-Type": "application/json",
+                },
+            });
+            // Parse the response
+            let text = "";
+            if (Array.isArray(response.data)) {
+                text = response.data[0]?.generated_text || "";
+            }
+            else if (response.data.generated_text) {
+                text = response.data.generated_text;
+            }
+            else {
+                text = JSON.stringify(response.data);
+            }
+            // Extract function calls from the response
+            const functionCalls = this.extractFunctionCallsFromText(text);
+            return {
+                text,
+                functionCalls,
+                raw: response.data,
+            };
         }
-        else {
-            text = JSON.stringify(response.data);
+        catch (error) {
+            console.error("Error generating with HuggingFace model:", error);
+            throw error;
         }
-        return {
-            text,
-            raw: response.data,
-        };
     }
     /**
      * Generate a response using multimodal inputs (text + images)
@@ -128,6 +158,86 @@ class HuggingFaceModel extends base_model_1.BaseModel {
             .join("; ")}`;
         throw new Error(errorMessage);
     }
+    /**
+     * Extract function calls from text using pattern matching
+     * This is more robust than the previous implementation and handles various formats
+     */
+    extractFunctionCallsFromText(text) {
+        if (!text)
+            return undefined;
+        try {
+            const functionCalls = [];
+            // Pattern 1: Clean JSON function call format
+            // Example: {"name": "functionName", "arguments": {...}}
+            const jsonRegex = /\{[\s\n]*"name"[\s\n]*:[\s\n]*"([^"]+)"[\s\n]*,[\s\n]*"arguments"[\s\n]*:[\s\n]*([\s\S]*?)\}/g;
+            let match;
+            while ((match = jsonRegex.exec(text)) !== null) {
+                try {
+                    // Try to parse the arguments part as JSON
+                    const name = match[1];
+                    let args = match[2].trim();
+                    // Check if args is already a valid JSON string
+                    try {
+                        JSON.parse(args);
+                        functionCalls.push({
+                            name,
+                            arguments: args,
+                        });
+                    }
+                    catch (e) {
+                        // If not valid JSON, try to extract the JSON object
+                        const argsMatch = args.match(/\{[\s\S]*\}/);
+                        if (argsMatch) {
+                            functionCalls.push({
+                                name,
+                                arguments: argsMatch[0],
+                            });
+                        }
+                        else {
+                            functionCalls.push({
+                                name,
+                                arguments: "{}",
+                            });
+                        }
+                    }
+                }
+                catch (e) {
+                    console.warn("Error parsing function call:", e);
+                }
+            }
+            // Pattern 2: Function-like syntax
+            // Example: functionName({param1: "value", param2: 123})
+            const functionRegex = /([a-zA-Z0-9_]+)\s*\(\s*(\{[\s\S]*?\})\s*\)/g;
+            while ((match = functionRegex.exec(text)) !== null) {
+                functionCalls.push({
+                    name: match[1],
+                    arguments: match[2],
+                });
+            }
+            // Pattern 3: Markdown code block with JSON
+            // Example: ```json\n{"name": "functionName", "arguments": {...}}\n```
+            const markdownRegex = /```(?:json)?\s*\n\s*(\{[\s\S]*?\})\s*\n```/g;
+            while ((match = markdownRegex.exec(text)) !== null) {
+                try {
+                    const jsonObj = JSON.parse(match[1]);
+                    if (jsonObj.name && (jsonObj.arguments || jsonObj.args)) {
+                        functionCalls.push({
+                            name: jsonObj.name,
+                            arguments: JSON.stringify(jsonObj.arguments || jsonObj.args),
+                        });
+                    }
+                }
+                catch (e) {
+                    // Ignore parse errors for markdown blocks
+                }
+            }
+            return functionCalls.length > 0 ? functionCalls : undefined;
+        }
+        catch (e) {
+            console.warn("Error in extractFunctionCallsFromText:", e);
+            return undefined;
+        }
+    }
     /**
      * Try generating with nested inputs format (common in newer models)
      */
@@ -135,14 +245,26 @@ class HuggingFaceModel extends base_model_1.BaseModel {
         const prompt = request.systemPrompt
             ? `${request.systemPrompt}\n\n${request.prompt}`
             : request.prompt;
+        // Handle function calling by adding function definitions to the prompt
+        let enhancedPrompt = prompt;
+        if (request.functions && request.functions.length > 0) {
+            const functionText = JSON.stringify({ functions: request.functions }, null, 2);
+            enhancedPrompt = `${enhancedPrompt}\n\nAvailable functions:\n\`\`\`json\n${functionText}\n\`\`\`\n\n`;
+            if (typeof request.functionCall === "object") {
+                enhancedPrompt += `Please call the function: ${request.functionCall.name}\n\n`;
+            }
+            else if (request.functionCall === "auto") {
+                enhancedPrompt += "Call the appropriate function if needed.\n\n";
+            }
+        }
         let payload = {
             inputs: {
-                text: prompt,
+                text: enhancedPrompt,
             },
             parameters: {
-                temperature: config.temperature,
-                max_new_tokens: config.maxTokens,
-                top_p: config.topP,
+                temperature: config.temperature || 0.1,
+                max_new_tokens: config.maxTokens || 500,
+                top_p: config.topP || 0.9,
                 return_full_text: false,
             },
         };
@@ -178,8 +300,8 @@ class HuggingFaceModel extends base_model_1.BaseModel {
                 "Content-Type": "application/json",
             },
         });
-        // Parse response
-        return this.parseResponse(response);
+        // Parse response with function call extraction
+        return this.parseResponseWithFunctionCalls(response);
     }
     /**
      * Try generating with flat inputs format (common in some models)
@@ -188,13 +310,25 @@ class HuggingFaceModel extends base_model_1.BaseModel {
         const prompt = request.systemPrompt
             ? `${request.systemPrompt}\n\n${request.prompt}`
             : request.prompt;
+        // Handle function calling by adding function definitions to the prompt
+        let enhancedPrompt = prompt;
+        if (request.functions && request.functions.length > 0) {
+            const functionText = JSON.stringify({ functions: request.functions }, null, 2);
+            enhancedPrompt = `${enhancedPrompt}\n\nAvailable functions:\n\`\`\`json\n${functionText}\n\`\`\`\n\n`;
+            if (typeof request.functionCall === "object") {
+                enhancedPrompt += `Please call the function: ${request.functionCall.name}\n\n`;
+            }
+            else if (request.functionCall === "auto") {
+                enhancedPrompt += "Call the appropriate function if needed.\n\n";
+            }
+        }
         // Some models expect a flat structure with inputs as a string
         let payload = {
-            inputs: prompt,
+            inputs: enhancedPrompt,
             parameters: {
-                temperature: config.temperature,
-                max_new_tokens: config.maxTokens,
-                top_p: config.topP,
+                temperature: config.temperature || 0.1,
+                max_new_tokens: config.maxTokens || 500,
+                top_p: config.topP || 0.9,
                 return_full_text: false,
             },
         };
@@ -218,13 +352,13 @@ class HuggingFaceModel extends base_model_1.BaseModel {
                 "Content-Type": "application/json",
             },
         });
-        // Parse response
-        return this.parseResponse(response);
+        // Parse response with function call extraction
+        return this.parseResponseWithFunctionCalls(response);
     }
     /**
-     * Helper to parse HuggingFace response in various formats
+     * Helper to parse HuggingFace response with function call extraction
      */
-    parseResponse(response) {
+    parseResponseWithFunctionCalls(response) {
         let text = "";
         if (Array.isArray(response.data)) {
             text = response.data[0]?.generated_text || "";
@@ -238,8 +372,11 @@ class HuggingFaceModel extends base_model_1.BaseModel {
         else {
             text = JSON.stringify(response.data);
         }
+        // Extract function calls from the response text
+        const functionCalls = this.extractFunctionCallsFromText(text);
         return {
             text,
+            functionCalls,
             raw: response.data,
         };
     }
@@ -249,11 +386,23 @@ class HuggingFaceModel extends base_model_1.BaseModel {
     async generateWithMultipartForm(request, config, model) {
         // Create a multipart form-data payload for multimodal models
         const formData = new FormData();
-        // Add text prompt
+        // Add text prompt with function definitions
         const prompt = request.systemPrompt
             ? `${request.systemPrompt}\n\n${request.prompt}`
             : request.prompt;
-        formData.append("text", prompt);
+        // Handle function calling by adding function definitions to the prompt
+        let enhancedPrompt = prompt;
+        if (request.functions && request.functions.length > 0) {
+            const functionText = JSON.stringify({ functions: request.functions }, null, 2);
+            enhancedPrompt = `${enhancedPrompt}\n\nAvailable functions:\n\`\`\`json\n${functionText}\n\`\`\`\n\n`;
+            if (typeof request.functionCall === "object") {
+                enhancedPrompt += `Please call the function: ${request.functionCall.name}\n\n`;
+            }
+            else if (request.functionCall === "auto") {
+                enhancedPrompt += "Call the appropriate function if needed.\n\n";
+            }
+        }
+        formData.append("text", enhancedPrompt);
         // Process the convenience 'image' property
         if (request.image) {
             const { base64 } = await (0, image_utils_1.processImage)(request.image);
@@ -304,8 +453,11 @@ class HuggingFaceModel extends base_model_1.BaseModel {
         else {
             text = JSON.stringify(response.data);
         }
+        // Extract function calls from the response text
+        const functionCalls = this.extractFunctionCallsFromText(text);
         return {
             text,
+            functionCalls,
             raw: response.data,
         };
     }

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

@@ -6,6 +6,14 @@ export declare class OllamaModel extends BaseModel {
     constructor(config: AIModelConfig);
     generate(request: AIModelRequest): Promise<AIModelResponse>;
     stream(request: AIModelRequest): AsyncGenerator<string, void, unknown>;
+    /**
+     * 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,19 +18,70 @@ class OllamaModel extends base_model_1.BaseModel {
     async generate(request) {
         const config = this.mergeConfig(request.options);
         try {
+            // 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",
+                },
+            });
+            // 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(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,
                 },
-                raw: response.data,
+                functionCalls,
+                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) &&
@@ -39,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;
         }
     }
@@ -46,8 +107,13 @@ 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",
+                },
             });
             const reader = response.data;
             for await (const chunk of reader) {
@@ -55,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;
                         }
                     }
@@ -77,25 +149,205 @@ class OllamaModel extends base_model_1.BaseModel {
             throw error;
         }
     }
+    /**
+     * Extract function calls from text using various patterns
+     */
+    extractFunctionCallsFromText(text, currentRequest) {
+        if (!text)
+            return undefined;
+        try {
+            // 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 = [...fixedText.matchAll(jsonRegex)];
+            if (jsonMatches.length > 0) {
+                return jsonMatches.map((match) => {
+                    try {
+                        // Try to parse the arguments as JSON
+                        let argsText = match[2];
+                        // Fix potential incomplete JSON in arguments
+                        argsText = this.tryFixIncompleteJSON(argsText);
+                        let args;
+                        try {
+                            args = JSON.parse(argsText);
+                            return {
+                                name: match[1],
+                                arguments: JSON.stringify(args),
+                            };
+                        }
+                        catch (e) {
+                            // 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: this.tryFixIncompleteJSON(argsText, true),
+                            };
+                        }
+                    }
+                    catch (e) {
+                        console.warn("Error parsing function call:", e);
+                        return {
+                            name: match[1],
+                            arguments: "{}",
+                        };
+                    }
+                });
+            }
+            // Pattern 2: Function call pattern: functionName({"key": "value"})
+            const functionRegex = /([a-zA-Z0-9_]+)\s*\(\s*(\{[\s\S]*?\})\s*\)/g;
+            const functionMatches = [...fixedText.matchAll(functionRegex)];
+            if (functionMatches.length > 0) {
+                return functionMatches.map((match) => {
+                    const argsText = this.tryFixIncompleteJSON(match[2]);
+                    return {
+                        name: match[1],
+                        arguments: argsText,
+                    };
+                });
+            }
+            // Pattern 3: Looking for direct JSON objects - for function specific forced calls
+            if (currentRequest.functionCall &&
+                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 }),
+                            },
+                        ];
+                    }
+                }
+            }
+            // 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),
+                                },
+                            ];
+                        }
+                    }
+                }
+            }
+        }
+        catch (e) {
+            console.warn("Error in extractFunctionCallsFromText:", e);
+        }
+        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
      */
     async createRequestPayload(request, config, isStream = false) {
         // Base payload
         const payload = {
-            model: config.model || "llama2",
+            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;
         }
-        // If there are any image inputs, use the messages format
-        if (request.image ||
-            (request.content && request.content.some((item) => item.type === "image"))) {
-            // Create a messages array for multimodal models (similar to OpenAI format)
+        // Check if we should use chat format (messages array) or text format
+        const useMessagesFormat = request.image ||
+            (request.content &&
+                request.content.some((item) => item.type === "image")) ||
+            (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 (chat endpoint)
             const messages = [];
             // Add system prompt if provided
             if (request.systemPrompt) {
@@ -104,27 +356,48 @@ class OllamaModel extends base_model_1.BaseModel {
                     content: request.systemPrompt,
                 });
             }
-            // Create a user message with potentially multiple content parts
-            const userMessage = { role: "user", content: [] };
-            // Add the main prompt as text content
+            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
             if (request.prompt) {
-                userMessage.content.push({
+                userContent.push({
                     type: "text",
                     text: request.prompt,
                 });
             }
-            // Process structured content if available
+            // Add structured content
             if (request.content) {
                 for (const item of request.content) {
                     if (item.type === "text") {
-                        userMessage.content.push({
+                        userContent.push({
                             type: "text",
                             text: item.text,
                         });
                     }
                     else if (item.type === "image") {
                         const { base64, mimeType } = await (0, image_utils_1.processImage)(item.source);
-                        userMessage.content.push({
+                        userContent.push({
                             type: "image",
                             image: {
                                 data: base64,
@@ -134,10 +407,10 @@ class OllamaModel extends base_model_1.BaseModel {
                     }
                 }
             }
-            // Handle the convenience image property
+            // Add simple image if provided
             if (request.image) {
                 const { base64, mimeType } = await (0, image_utils_1.processImage)(request.image);
-                userMessage.content.push({
+                userContent.push({
                     type: "image",
                     image: {
                         data: base64,
@@ -145,14 +418,32 @@ class OllamaModel extends base_model_1.BaseModel {
                     },
                 });
             }
-            // Add the user message
+            // Create the user message
+            let userMessage = {
+                role: "user",
+            };
+            // If we have a single text content, use string format
+            if (userContent.length === 1 && userContent[0].type === "text") {
+                userMessage.content = userContent[0].text;
+            }
+            else if (userContent.length > 0) {
+                userMessage.content = userContent;
+            }
+            else {
+                // Add empty string if no content provided to avoid invalid request
+                userMessage.content = "";
+            }
             messages.push(userMessage);
-            // Set the messages in the payload
             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/dist/models/openai-model.d.ts

@@ -6,6 +6,14 @@ export declare class OpenAIModel extends BaseModel {
     constructor(config: AIModelConfig);
     generate(request: AIModelRequest): Promise<AIModelResponse>;
     stream(request: AIModelRequest): AsyncGenerator<string, void, unknown>;
+    /**
+     * Prepare OpenAI function calling options
+     */
+    private prepareFunctionCalling;
+    /**
+     * Process function calls from OpenAI response
+     */
+    private processFunctionCalls;
     /**
      * Format messages for OpenAI API, including handling multimodal content
      */

package/dist/models/openai-model.js

@@ -20,13 +20,18 @@ class OpenAIModel extends base_model_1.BaseModel {
         const config = this.mergeConfig(request.options);
         // Process messages for OpenAI API
         const messages = await this.formatMessages(request);
+        // Prepare function calling if requested
+        const functionOptions = this.prepareFunctionCalling(request);
         const response = await this.client.chat.completions.create({
             model: config.model || "gpt-3.5-turbo",
             messages,
             temperature: config.temperature,
             max_tokens: config.maxTokens,
             top_p: config.topP,
+            ...functionOptions,
         });
+        // Process function calls if any are present
+        const functionCalls = this.processFunctionCalls(response);
         return {
             text: response.choices[0].message.content || "",
             usage: {
@@ -34,6 +39,7 @@ class OpenAIModel extends base_model_1.BaseModel {
                 completionTokens: response.usage?.completion_tokens,
                 totalTokens: response.usage?.total_tokens,
             },
+            functionCalls,
             raw: response,
         };
     }
@@ -41,14 +47,19 @@ class OpenAIModel extends base_model_1.BaseModel {
         const config = this.mergeConfig(request.options);
         // Process messages for OpenAI API
         const messages = await this.formatMessages(request);
-        const stream = await this.client.chat.completions.create({
+        // Prepare function calling if requested
+        const functionOptions = this.prepareFunctionCalling(request);
+        const response = await this.client.chat.completions.create({
             model: config.model || "gpt-3.5-turbo",
             messages,
             temperature: config.temperature,
             max_tokens: config.maxTokens,
             top_p: config.topP,
             stream: true,
+            ...functionOptions,
         });
+        // Using a more compatible approach with Stream API
+        const stream = response;
         for await (const chunk of stream) {
             const content = chunk.choices[0]?.delta?.content || "";
             if (content) {
@@ -56,6 +67,58 @@ class OpenAIModel extends base_model_1.BaseModel {
             }
         }
     }
+    /**
+     * Prepare OpenAI function calling options
+     */
+    prepareFunctionCalling(request) {
+        if (!request.functions || request.functions.length === 0) {
+            return {};
+        }
+        // Transform our function definitions to OpenAI's format
+        const tools = request.functions.map((func) => ({
+            type: "function",
+            function: {
+                name: func.name,
+                description: func.description,
+                parameters: func.parameters,
+            },
+        }));
+        // Handle tool_choice (functionCall in our API)
+        let tool_choice = undefined;
+        if (request.functionCall) {
+            if (request.functionCall === "auto") {
+                tool_choice = "auto";
+            }
+            else if (request.functionCall === "none") {
+                tool_choice = "none";
+            }
+            else if (typeof request.functionCall === "object") {
+                tool_choice = {
+                    type: "function",
+                    function: { name: request.functionCall.name },
+                };
+            }
+        }
+        return {
+            tools,
+            tool_choice,
+        };
+    }
+    /**
+     * Process function calls from OpenAI response
+     */
+    processFunctionCalls(response) {
+        const toolCalls = response.choices[0]?.message?.tool_calls;
+        if (!toolCalls || toolCalls.length === 0) {
+            return undefined;
+        }
+        return toolCalls
+            .filter((call) => call.type === "function")
+            .map((call) => ({
+            name: call.function.name,
+            arguments: call.function.arguments,
+        }));
+    }
     /**
      * Format messages for OpenAI API, including handling multimodal content
      */

package/dist/types.d.ts

@@ -23,6 +23,19 @@ export interface ImageContent {
     source: string | Buffer;
 }
 export type Content = TextContent | ImageContent;
+export interface FunctionDefinition {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties?: Record<string, any>;
+        required?: string[];
+    };
+}
+export interface FunctionCall {
+    name: string;
+    arguments: string;
+}
 export interface AIModelResponse {
     text: string;
     usage?: {
@@ -30,6 +43,7 @@ export interface AIModelResponse {
         completionTokens?: number;
         totalTokens?: number;
     };
+    functionCalls?: FunctionCall[];
     raw?: any;
 }
 export interface AIModelRequest {
@@ -38,6 +52,10 @@ export interface AIModelRequest {
     options?: Partial<AIModelConfig>;
     content?: Content[];
     image?: string | Buffer;
+    functions?: FunctionDefinition[];
+    functionCall?: "auto" | "none" | {
+        name: string;
+    };
 }
 export interface AIModel {
     provider: AIProvider;

package/package.json

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