neural-ai-sdk 0.1.2 → 0.1.4

package/README.md

@@ -42,12 +42,13 @@ async function generateResponse() {
 generateResponse();
 ```
 
-### Environment Variables Support
+### Automatic Environment Variables Support
 
-You can provide API keys and base URLs through environment variables instead of directly in code:
+The SDK automatically loads environment variables from `.env` files when imported, so you don't need to manually configure dotenv. Simply create a `.env` file in your project root, and the API keys will be automatically detected:
 
 ```typescript
-// No need to provide API keys in code if they're set as environment variables
+// No need to provide API keys in code if they're set in .env files
+// No need to manually call require('dotenv').config()
 const openaiModel = NeuralAI.createModel(AIProvider.OPENAI, {
   model: "gpt-4",
 });
@@ -229,11 +230,7 @@ HUGGINGFACE_API_KEY=your_huggingface_key_here
 OLLAMA_BASE_URL=http://localhost:11434/api
 ```
 
-Make sure to load environment variables from your `.env` file using a package like `dotenv`:
-
-```javascript
-require("dotenv").config();
-```
+The SDK automatically loads environment variables from `.env` files when imported, so you don't need to manually configure dotenv.
 
 ## Configuration Options
 

package/dist/index.js

@@ -22,6 +22,9 @@ const google_model_2 = require("./models/google-model");
 const deepseek_model_2 = require("./models/deepseek-model");
 const ollama_model_2 = require("./models/ollama-model");
 const huggingface_model_2 = require("./models/huggingface-model");
+const utils_1 = require("./utils");
+// Automatically load environment variables when the module is imported
+(0, utils_1.loadEnvVariables)();
 class NeuralAI {
     /**
      * Create an AI model instance based on the provider and configuration

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,10 @@ 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;
     /**
      * Creates the request payload for Ollama, handling multimodal content if provided
      */

package/dist/models/ollama-model.js

@@ -18,8 +18,18 @@ 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
             const payload = await this.createRequestPayload(request, config);
-            const response = await axios_1.default.post(`${this.baseURL}/generate`, payload);
+            const response = await axios_1.default.post(`${this.baseURL}/generate`, payload, {
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            });
+            if (!response.data || !response.data.response) {
+                throw new Error("Invalid response from Ollama API");
+            }
+            // Try to extract function calls from the response
+            const functionCalls = this.extractFunctionCallsFromText(response.data.response, request);
             return {
                 text: response.data.response,
                 usage: {
@@ -27,6 +37,7 @@ class OllamaModel extends base_model_1.BaseModel {
                     completionTokens: response.data.eval_count,
                     totalTokens: response.data.prompt_eval_count + response.data.eval_count,
                 },
+                functionCalls,
                 raw: response.data,
             };
         }
@@ -48,6 +59,9 @@ class OllamaModel extends base_model_1.BaseModel {
             const payload = await this.createRequestPayload(request, config, true);
             const response = await axios_1.default.post(`${this.baseURL}/generate`, payload, {
                 responseType: "stream",
+                headers: {
+                    "Content-Type": "application/json",
+                },
             });
             const reader = response.data;
             for await (const chunk of reader) {
@@ -77,13 +91,105 @@ 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 {
+            // Try multiple patterns for function calls
+            // 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)];
+            if (jsonMatches.length > 0) {
+                return jsonMatches.map((match) => {
+                    try {
+                        // Try to parse the arguments as JSON
+                        const argsText = match[2];
+                        let args;
+                        try {
+                            args = JSON.parse(argsText);
+                            return {
+                                name: match[1],
+                                arguments: JSON.stringify(args),
+                            };
+                        }
+                        catch (e) {
+                            // If parsing fails, use the raw text
+                            return {
+                                name: match[1],
+                                arguments: argsText,
+                            };
+                        }
+                    }
+                    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 = [...text.matchAll(functionRegex)];
+            if (functionMatches.length > 0) {
+                return functionMatches.map((match) => ({
+                    name: match[1],
+                    arguments: match[2],
+                }));
+            }
+            // Pattern 3: Look for more specific calculator patterns
+            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 }),
+                        },
+                    ];
+                }
+            }
+            // 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 }),
+                        },
+                    ];
+                }
+            }
+        }
+        catch (e) {
+            console.warn("Error in extractFunctionCallsFromText:", e);
+        }
+        return undefined;
+    }
     /**
      * 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,
@@ -92,10 +198,13 @@ class OllamaModel extends base_model_1.BaseModel {
         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);
+        if (useMessagesFormat) {
+            // Modern message-based format for Ollama
             const messages = [];
             // Add system prompt if provided
             if (request.systemPrompt) {
@@ -104,27 +213,27 @@ 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
+            // 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 +243,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,9 +254,46 @@ 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 {
+                userMessage.content = userContent;
+            }
             messages.push(userMessage);
-            // Set the messages in the payload
+            // 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,
+                    });
+                }
+            }
             payload.messages = messages;
         }
         else {

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/dist/utils.d.ts

@@ -1,6 +1,11 @@
 /**
  * Utilities for the Neural AI SDK
  */
+/**
+ * Try to load environment variables from .env files
+ * This is done automatically when the module is imported
+ */
+export declare function loadEnvVariables(): void;
 /**
  * Get an API key from config or environment variables
  * @param configKey The API key from the config object

package/dist/utils.js

@@ -3,8 +3,30 @@
  * Utilities for the Neural AI SDK
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadEnvVariables = loadEnvVariables;
 exports.getApiKey = getApiKey;
 exports.getBaseUrl = getBaseUrl;
+/**
+ * Try to load environment variables from .env files
+ * This is done automatically when the module is imported
+ */
+function loadEnvVariables() {
+    try {
+        // Only require dotenv if it's available
+        // This avoids errors if the user hasn't installed dotenv
+        const dotenv = require('dotenv');
+        // Load from .env file in the project root by default
+        dotenv.config();
+        // Also try to load from any parent directories to support monorepos
+        // and projects where the .env file might be in a different location
+        dotenv.config({ path: '../../.env' });
+        dotenv.config({ path: '../.env' });
+    }
+    catch (error) {
+        // Silent fail if dotenv is not available
+        // This is intentional to not break the module if dotenv is not installed
+    }
+}
 /**
  * Get an API key from config or environment variables
  * @param configKey The API key from the config object

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neural-ai-sdk",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Unified SDK for interacting with various AI LLM providers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -45,6 +45,7 @@
   "dependencies": {
     "@google/generative-ai": "^0.2.0",
     "axios": "^1.6.0",
+    "dotenv": "^16.3.1",
     "openai": "^4.28.0"
   },
   "devDependencies": {
@@ -52,7 +53,6 @@
     "@types/node": "^20.8.3",
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
-    "dotenv": "^16.3.1",
     "eslint": "^8.51.0",
     "jest": "^29.7.0",
     "rimraf": "^5.0.10",