praisonai 1.0.16 → 1.0.17

package/README.md

@@ -220,4 +220,30 @@ src/
 
 ## License
 
-MIT License - see the LICENSE file for details
+MIT License - see the LICENSE file for details
+
+## Testing
+
+### Manual Testing
+
+```bash
+export OPENAI_API_KEY='your-api-key'
+npx ts-node tests/development/simple/single-agent.ts
+npx ts-node tests/development/simple/multi-agent.ts
+npx ts-node tests/development/simple/multi-agents-simple.js
+```
+
+## Examples Testing
+
+```bash
+export OPENAI_API_KEY='your-api-key'
+npx ts-node examples/simple/single-agent.ts
+npx ts-node examples/simple/multi-agent.ts
+```
+
+### Automated Testing (WIP)
+
+```bash
+npm run test
+```
+

package/dist/agent/proxy.d.ts

@@ -3,6 +3,7 @@ import { TaskAgentConfig } from './types';
 import { Task } from './types';
 export interface ProxyAgentConfig extends Partial<SimpleAgentConfig>, Partial<TaskAgentConfig> {
     task?: Task;
+    tools?: any[];
 }
 export declare class Agent {
     private simpleAgent;

package/dist/agent/proxy.js

@@ -28,10 +28,41 @@ class Agent {
                 name: config.name,
                 verbose: config.verbose,
                 llm: config.llm,
-                markdown: config.markdown
+                markdown: config.markdown,
+                tools: config.tools
             };
             this.simpleAgent = new simple_1.Agent(simpleConfig);
         }
+        // Register tool functions if provided
+        if (config.tools && this.simpleAgent) {
+            // Look for tool functions in the global scope
+            for (const tool of config.tools) {
+                if (tool.type === 'function' && tool.function && tool.function.name) {
+                    const funcName = tool.function.name;
+                    // Check if function exists in global scope using a safer approach
+                    const globalAny = global;
+                    if (typeof globalAny[funcName] === 'function') {
+                        this.simpleAgent.registerToolFunction(funcName, globalAny[funcName]);
+                    }
+                    else if (typeof globalAny['get_' + funcName] === 'function') {
+                        // Try with 'get_' prefix (common convention)
+                        this.simpleAgent.registerToolFunction(funcName, globalAny['get_' + funcName]);
+                    }
+                    else {
+                        // Try to find the function in the global scope by iterating through all properties
+                        for (const key in globalAny) {
+                            if (key.toLowerCase() === funcName.toLowerCase() ||
+                                key.toLowerCase() === 'get_' + funcName.toLowerCase()) {
+                                if (typeof globalAny[key] === 'function') {
+                                    this.simpleAgent.registerToolFunction(funcName, globalAny[key]);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
     }
     getInstructions() {
         return this.instructions;

package/dist/agent/simple.d.ts

@@ -6,6 +6,7 @@ export interface SimpleAgentConfig {
     llm?: string;
     markdown?: boolean;
     stream?: boolean;
+    tools?: any[];
 }
 export declare class Agent {
     private instructions;
@@ -16,8 +17,22 @@ export declare class Agent {
     private markdown;
     private stream;
     private llmService;
+    private tools?;
+    private toolFunctions;
     constructor(config: SimpleAgentConfig);
     private createSystemPrompt;
+    /**
+     * Register a tool function that can be called by the model
+     * @param name Function name
+     * @param fn Function implementation
+     */
+    registerToolFunction(name: string, fn: Function): void;
+    /**
+     * Process tool calls from the model
+     * @param toolCalls Tool calls from the model
+     * @returns Array of tool results
+     */
+    private processToolCalls;
     start(prompt: string, previousResult?: string): Promise<string>;
     chat(prompt: string, previousResult?: string): Promise<string>;
     execute(previousResult?: string): Promise<string>;

package/dist/agent/simple.js

@@ -5,6 +5,7 @@ const openai_1 = require("../llm/openai");
 const logger_1 = require("../utils/logger");
 class Agent {
     constructor(config) {
+        this.toolFunctions = {};
         this.instructions = config.instructions;
         this.name = config.name || `Agent_${Math.random().toString(36).substr(2, 9)}`;
         this.verbose = config.verbose ?? process.env.PRAISON_VERBOSE !== 'false';
@@ -12,6 +13,7 @@ class Agent {
         this.llm = config.llm || 'gpt-4o-mini';
         this.markdown = config.markdown ?? true;
         this.stream = config.stream ?? true;
+        this.tools = config.tools;
         this.llmService = new openai_1.OpenAIService(this.llm);
         // Configure logging
         logger_1.Logger.setVerbose(this.verbose);
@@ -24,6 +26,53 @@ class Agent {
         }
         return prompt;
     }
+    /**
+     * Register a tool function that can be called by the model
+     * @param name Function name
+     * @param fn Function implementation
+     */
+    registerToolFunction(name, fn) {
+        this.toolFunctions[name] = fn;
+        logger_1.Logger.debug(`Registered tool function: ${name}`);
+    }
+    /**
+     * Process tool calls from the model
+     * @param toolCalls Tool calls from the model
+     * @returns Array of tool results
+     */
+    async processToolCalls(toolCalls) {
+        const results = [];
+        for (const toolCall of toolCalls) {
+            const { id, function: { name, arguments: argsString } } = toolCall;
+            await logger_1.Logger.debug(`Processing tool call: ${name}`, { arguments: argsString });
+            try {
+                // Parse arguments
+                const args = JSON.parse(argsString);
+                // Check if function exists
+                if (!this.toolFunctions[name]) {
+                    throw new Error(`Function ${name} not registered`);
+                }
+                // Call the function
+                const result = await this.toolFunctions[name](...Object.values(args));
+                // Add result to messages
+                results.push({
+                    role: 'tool',
+                    tool_call_id: id,
+                    content: result.toString()
+                });
+                await logger_1.Logger.debug(`Tool call result for ${name}:`, { result });
+            }
+            catch (error) {
+                await logger_1.Logger.error(`Error executing tool ${name}:`, error);
+                results.push({
+                    role: 'tool',
+                    tool_call_id: id,
+                    content: `Error: ${error.message || 'Unknown error'}`
+                });
+            }
+        }
+        return results;
+    }
     async start(prompt, previousResult) {
         await logger_1.Logger.debug(`Agent ${this.name} starting with prompt: ${prompt}`);
         try {
@@ -31,19 +80,61 @@ class Agent {
             if (previousResult) {
                 prompt = prompt.replace('{{previous}}', previousResult);
             }
-            let response;
-            if (this.stream) {
+            // Initialize messages array
+            const messages = [
+                { role: 'system', content: this.createSystemPrompt() },
+                { role: 'user', content: prompt }
+            ];
+            let finalResponse = '';
+            if (this.stream && !this.tools) {
+                // Use streaming without tools
                 let fullResponse = '';
                 await this.llmService.streamText(prompt, this.createSystemPrompt(), 0.7, (token) => {
                     process.stdout.write(token);
                     fullResponse += token;
                 });
-                response = fullResponse;
+                finalResponse = fullResponse;
+            }
+            else if (this.tools) {
+                // Use tools (non-streaming for now to simplify implementation)
+                let continueConversation = true;
+                let iterations = 0;
+                const maxIterations = 5; // Prevent infinite loops
+                while (continueConversation && iterations < maxIterations) {
+                    iterations++;
+                    // Get response from LLM
+                    const response = await this.llmService.generateChat(messages, 0.7, this.tools);
+                    // Add assistant response to messages
+                    messages.push({
+                        role: 'assistant',
+                        content: response.content || '',
+                        tool_calls: response.tool_calls
+                    });
+                    // Check if there are tool calls to process
+                    if (response.tool_calls && response.tool_calls.length > 0) {
+                        // Process tool calls
+                        const toolResults = await this.processToolCalls(response.tool_calls);
+                        // Add tool results to messages
+                        messages.push(...toolResults);
+                        // Continue conversation to get final response
+                        continueConversation = true;
+                    }
+                    else {
+                        // No tool calls, we have our final response
+                        finalResponse = response.content || '';
+                        continueConversation = false;
+                    }
+                }
+                if (iterations >= maxIterations) {
+                    await logger_1.Logger.warn(`Reached maximum iterations (${maxIterations}) for tool calls`);
+                }
             }
             else {
-                response = await this.llmService.generateText(prompt, this.createSystemPrompt());
+                // Use regular text generation without streaming
+                const response = await this.llmService.generateText(prompt, this.createSystemPrompt());
+                finalResponse = response;
             }
-            return response;
+            return finalResponse;
         }
         catch (error) {
             await logger_1.Logger.error('Error in agent execution', error);

package/dist/llm/openai.d.ts

@@ -1,20 +1,38 @@
+import type { ChatCompletionTool, ChatCompletionToolChoiceOption } from 'openai/resources/chat/completions';
 export interface LLMResponse {
     content: string;
     role: string;
+    tool_calls?: Array<{
+        id: string;
+        type: string;
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
 }
-type ChatRole = 'system' | 'user' | 'assistant';
+type ChatRole = 'system' | 'user' | 'assistant' | 'tool';
 interface ChatMessage {
     role: ChatRole;
-    content: string;
+    content: string | null;
+    tool_call_id?: string;
+    tool_calls?: Array<{
+        id: string;
+        type: string;
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
 }
 export declare class OpenAIService {
     private model;
     private client;
     constructor(model?: string);
     private getClient;
-    generateText(prompt: string, systemPrompt?: string, temperature?: number): Promise<string>;
-    generateChat(messages: ChatMessage[], temperature?: number): Promise<LLMResponse>;
-    streamText(prompt: string, systemPrompt: string | undefined, temperature: number | undefined, onToken: (token: string) => void): Promise<void>;
-    chatCompletion(messages: ChatMessage[], temperature?: number): Promise<LLMResponse>;
+    generateText(prompt: string, systemPrompt?: string, temperature?: number, tools?: ChatCompletionTool[], tool_choice?: ChatCompletionToolChoiceOption): Promise<string>;
+    generateChat(messages: ChatMessage[], temperature?: number, tools?: ChatCompletionTool[], tool_choice?: ChatCompletionToolChoiceOption): Promise<LLMResponse>;
+    streamText(prompt: string, systemPrompt: string | undefined, temperature: number | undefined, onToken: (token: string) => void, tools?: ChatCompletionTool[], tool_choice?: ChatCompletionToolChoiceOption, onToolCall?: (toolCall: any) => void): Promise<void>;
+    chatCompletion(messages: ChatMessage[], temperature?: number, tools?: ChatCompletionTool[], tool_choice?: ChatCompletionToolChoiceOption): Promise<LLMResponse>;
 }
 export {};

package/dist/llm/openai.js

@@ -12,6 +12,46 @@ dotenv_1.default.config();
 if (!process.env.OPENAI_API_KEY) {
     throw new Error('OPENAI_API_KEY not found in environment variables');
 }
+// Convert our ChatMessage to OpenAI's ChatCompletionMessageParam
+function convertToOpenAIMessage(message) {
+    // Basic conversion for common message types
+    if (message.role === 'system' || message.role === 'user' || message.role === 'assistant') {
+        return {
+            role: message.role,
+            content: message.content || '',
+            ...(message.tool_calls ? { tool_calls: message.tool_calls } : {})
+        };
+    }
+    // Handle tool messages
+    if (message.role === 'tool') {
+        return {
+            role: 'tool',
+            content: message.content || '',
+            tool_call_id: message.tool_call_id || ''
+        };
+    }
+    // Default fallback
+    return {
+        role: 'user',
+        content: message.content || ''
+    };
+}
+// Convert custom tool format to OpenAI's ChatCompletionTool format
+function convertToOpenAITool(tool) {
+    // If it's already in the correct format, return it
+    if (tool.type === 'function' && typeof tool.type === 'string') {
+        return tool;
+    }
+    // Otherwise, try to convert it
+    return {
+        type: 'function',
+        function: {
+            name: tool.function?.name || '',
+            description: tool.function?.description || '',
+            parameters: tool.function?.parameters || {}
+        }
+    };
+}
 // Singleton instance for OpenAI client
 let openAIInstance = null;
 // Get cached OpenAI client instance
@@ -37,7 +77,7 @@ class OpenAIService {
         }
         return this.client;
     }
-    async generateText(prompt, systemPrompt = '', temperature = 0.7) {
+    async generateText(prompt, systemPrompt = '', temperature = 0.7, tools, tool_choice) {
         await logger_1.Logger.startSpinner('Generating text with OpenAI...');
         const messages = [];
         if (systemPrompt) {
@@ -45,15 +85,31 @@ class OpenAIService {
         }
         messages.push({ role: 'user', content: prompt });
         try {
+            // Convert messages to OpenAI format
+            const openAIMessages = messages.map(convertToOpenAIMessage);
+            // Convert tools to OpenAI format if provided
+            const openAITools = tools ? tools.map(convertToOpenAITool) : undefined;
             const completion = await this.getClient().then(client => client.chat.completions.create({
                 model: this.model,
                 temperature,
-                messages
+                messages: openAIMessages,
+                tools: openAITools,
+                tool_choice
             }));
-            const response = completion.choices[0]?.message?.content;
-            if (!response) {
+            const message = completion.choices[0]?.message;
+            if (!message) {
                 throw new Error('No response from OpenAI');
             }
+            // Check for tool calls
+            if (message.tool_calls && message.tool_calls.length > 0) {
+                await logger_1.Logger.debug('Tool calls detected in generateText', { tool_calls: message.tool_calls });
+                // For backward compatibility, we return a message about tool calls
+                return 'The model wants to use tools. Please use generateChat or chatCompletion instead.';
+            }
+            const response = message.content;
+            if (!response) {
+                throw new Error('No content in response from OpenAI');
+            }
             await logger_1.Logger.stopSpinner(true);
             await logger_1.Logger.section('Generated Response', response);
             return response;
@@ -64,13 +120,19 @@ class OpenAIService {
             throw error;
         }
     }
-    async generateChat(messages, temperature = 0.7) {
+    async generateChat(messages, temperature = 0.7, tools, tool_choice) {
         await logger_1.Logger.startSpinner('Generating chat response...');
         try {
+            // Convert messages to OpenAI format
+            const openAIMessages = messages.map(convertToOpenAIMessage);
+            // Convert tools to OpenAI format if provided
+            const openAITools = tools ? tools.map(convertToOpenAITool) : undefined;
             const completion = await this.getClient().then(client => client.chat.completions.create({
                 model: this.model,
                 temperature,
-                messages
+                messages: openAIMessages,
+                tools: openAITools,
+                tool_choice
             }));
             const response = completion.choices[0]?.message;
             if (!response) {
@@ -81,6 +143,11 @@ class OpenAIService {
                 content: response.content || '',
                 role: response.role
             };
+            // Add tool calls if they exist
+            if (response.tool_calls && response.tool_calls.length > 0) {
+                result.tool_calls = response.tool_calls;
+                await logger_1.Logger.debug('Tool calls detected', { tool_calls: result.tool_calls });
+            }
             await logger_1.Logger.section('Chat Response', result.content);
             return result;
         }
@@ -90,7 +157,7 @@ class OpenAIService {
             throw error;
         }
     }
-    async streamText(prompt, systemPrompt = '', temperature = 0.7, onToken) {
+    async streamText(prompt, systemPrompt = '', temperature = 0.7, onToken, tools, tool_choice, onToolCall) {
         await logger_1.Logger.debug('Starting text stream...', {
             model: this.model,
             temperature
@@ -101,17 +168,52 @@ class OpenAIService {
         }
         messages.push({ role: 'user', content: prompt });
         try {
+            // Convert messages to OpenAI format
+            const openAIMessages = messages.map(convertToOpenAIMessage);
+            // Convert tools to OpenAI format if provided
+            const openAITools = tools ? tools.map(convertToOpenAITool) : undefined;
             const stream = await this.getClient().then(client => client.chat.completions.create({
                 model: this.model,
                 temperature,
-                messages,
+                messages: openAIMessages,
                 stream: true,
+                tools: openAITools,
+                tool_choice
             }));
             let fullResponse = '';
+            const toolCalls = {};
             for await (const chunk of stream) {
-                const token = chunk.choices[0]?.delta?.content || '';
-                fullResponse += token;
-                onToken(token);
+                const delta = chunk.choices[0]?.delta;
+                // Handle content tokens
+                if (delta?.content) {
+                    const token = delta.content;
+                    fullResponse += token;
+                    onToken(token);
+                }
+                // Handle tool calls
+                if (delta?.tool_calls && delta.tool_calls.length > 0) {
+                    for (const toolCall of delta.tool_calls) {
+                        const { index } = toolCall;
+                        if (!toolCalls[index]) {
+                            toolCalls[index] = {
+                                id: toolCall.id,
+                                type: toolCall.type,
+                                function: {
+                                    name: toolCall.function?.name || '',
+                                    arguments: ''
+                                }
+                            };
+                        }
+                        // Accumulate function arguments
+                        if (toolCall.function?.arguments) {
+                            toolCalls[index].function.arguments += toolCall.function.arguments;
+                        }
+                        // Call the onToolCall callback if provided
+                        if (onToolCall) {
+                            onToolCall(toolCalls[index]);
+                        }
+                    }
+                }
             }
             await logger_1.Logger.debug('Stream completed successfully');
         }
@@ -120,18 +222,34 @@ class OpenAIService {
             throw error;
         }
     }
-    async chatCompletion(messages, temperature = 0.7) {
+    async chatCompletion(messages, temperature = 0.7, tools, tool_choice) {
         await logger_1.Logger.startSpinner('Chat completion with OpenAI...');
         try {
+            // Convert messages to OpenAI format
+            const openAIMessages = messages.map(convertToOpenAIMessage);
+            // Convert tools to OpenAI format if provided
+            const openAITools = tools ? tools.map(convertToOpenAITool) : undefined;
             const completion = await this.getClient().then(client => client.chat.completions.create({
                 model: this.model,
                 temperature,
-                messages
+                messages: openAIMessages,
+                tools: openAITools,
+                tool_choice
             }));
+            // Safely access the message
+            if (!completion.choices || completion.choices.length === 0 || !completion.choices[0].message) {
+                throw new Error('No response from OpenAI');
+            }
+            const message = completion.choices[0].message;
             const response = {
-                content: completion.choices[0].message.content || '',
-                role: completion.choices[0].message.role
+                content: message.content || '',
+                role: message.role
             };
+            // Add tool calls if they exist
+            if (message.tool_calls && message.tool_calls.length > 0) {
+                response.tool_calls = message.tool_calls;
+                await logger_1.Logger.debug('Tool calls detected', { tool_calls: response.tool_calls });
+            }
             await logger_1.Logger.stopSpinner(true);
             await logger_1.Logger.section('Chat Completion Response', response.content);
             return response;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praisonai",
-  "version": "1.0.16",
+  "version": "1.0.17",
   "description": "PraisonAI TypeScript AI Agents Framework - Node.js, npm, and Javascript AI Agents Framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",