praisonai 1.0.17 → 1.0.19

package/dist/agent/index.d.ts

@@ -1,5 +1,6 @@
 export declare function setTaskMode(enabled: boolean): void;
 export { Agent, PraisonAIAgents, Task } from './proxy';
+export type { ProxyAgentConfig } from './proxy';
 export type { AgentConfig } from './types';
 export type { TaskConfig } from './types';
-export type { PraisonAIAgentsConfig } from './simple';
+export type { PraisonAIAgentsConfig, SimpleAgentConfig } from './simple';

package/dist/agent/proxy.d.ts

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

package/dist/agent/proxy.js

@@ -29,7 +29,8 @@ class Agent {
                 verbose: config.verbose,
                 llm: config.llm,
                 markdown: config.markdown,
-                tools: config.tools
+                tools: config.tools,
+                toolFunctions: config.toolFunctions
             };
             this.simpleAgent = new simple_1.Agent(simpleConfig);
         }

package/dist/agent/simple.d.ts

@@ -6,7 +6,8 @@ export interface SimpleAgentConfig {
     llm?: string;
     markdown?: boolean;
     stream?: boolean;
-    tools?: any[];
+    tools?: any[] | Function[];
+    toolFunctions?: Record<string, Function>;
 }
 export declare class Agent {
     private instructions;
@@ -27,6 +28,18 @@ export declare class Agent {
      * @param fn Function implementation
      */
     registerToolFunction(name: string, fn: Function): void;
+    /**
+     * Check if a tool definition exists for the given function name
+     * @param name Function name
+     * @returns True if a tool definition exists
+     */
+    private hasToolDefinition;
+    /**
+     * Auto-generate a tool definition based on the function
+     * @param name Function name
+     * @param func Function implementation
+     */
+    private addAutoGeneratedToolDefinition;
     /**
      * Process tool calls from the model
      * @param toolCalls Tool calls from the model

package/dist/agent/simple.js

@@ -18,6 +18,50 @@ class Agent {
         // Configure logging
         logger_1.Logger.setVerbose(this.verbose);
         logger_1.Logger.setPretty(this.pretty);
+        // Process tools array - handle both tool definitions and functions
+        if (config.tools && Array.isArray(config.tools)) {
+            // Convert tools array to proper format if it contains functions
+            const processedTools = [];
+            for (let i = 0; i < config.tools.length; i++) {
+                const tool = config.tools[i];
+                if (typeof tool === 'function') {
+                    // If it's a function, extract its name and register it
+                    const funcName = tool.name || `function_${i}`;
+                    // Skip functions with empty names
+                    if (funcName && funcName.trim() !== '') {
+                        this.registerToolFunction(funcName, tool);
+                        // Auto-generate tool definition
+                        this.addAutoGeneratedToolDefinition(funcName, tool);
+                    }
+                    else {
+                        // Generate a random name for functions without names
+                        const randomName = `function_${Math.random().toString(36).substring(2, 9)}`;
+                        this.registerToolFunction(randomName, tool);
+                        // Auto-generate tool definition
+                        this.addAutoGeneratedToolDefinition(randomName, tool);
+                    }
+                }
+                else {
+                    // If it's already a tool definition, add it as is
+                    processedTools.push(tool);
+                }
+            }
+            // Add any pre-defined tool definitions
+            if (processedTools.length > 0) {
+                this.tools = this.tools || [];
+                this.tools.push(...processedTools);
+            }
+        }
+        // Register directly provided tool functions if any
+        if (config.toolFunctions) {
+            for (const [name, func] of Object.entries(config.toolFunctions)) {
+                this.registerToolFunction(name, func);
+                // Auto-generate tool definition if not already provided
+                if (!this.hasToolDefinition(name)) {
+                    this.addAutoGeneratedToolDefinition(name, func);
+                }
+            }
+        }
     }
     createSystemPrompt() {
         let prompt = this.instructions;
@@ -35,6 +79,70 @@ class Agent {
         this.toolFunctions[name] = fn;
         logger_1.Logger.debug(`Registered tool function: ${name}`);
     }
+    /**
+     * Check if a tool definition exists for the given function name
+     * @param name Function name
+     * @returns True if a tool definition exists
+     */
+    hasToolDefinition(name) {
+        if (!this.tools)
+            return false;
+        return this.tools.some(tool => {
+            if (tool.type === 'function' && tool.function) {
+                return tool.function.name === name;
+            }
+            return false;
+        });
+    }
+    /**
+     * Auto-generate a tool definition based on the function
+     * @param name Function name
+     * @param func Function implementation
+     */
+    addAutoGeneratedToolDefinition(name, func) {
+        if (!this.tools) {
+            this.tools = [];
+        }
+        // Ensure we have a valid function name
+        const functionName = name || func.name || `function_${Math.random().toString(36).substring(2, 9)}`;
+        // Extract parameter names from function
+        const funcStr = func.toString();
+        const paramMatch = funcStr.match(/\(([^)]*)\)/);
+        const params = paramMatch ? paramMatch[1].split(',').map(p => p.trim()).filter(p => p) : [];
+        // Create a basic tool definition
+        const toolDef = {
+            type: "function",
+            function: {
+                name: functionName,
+                description: `Auto-generated function for ${functionName}`,
+                parameters: {
+                    type: "object",
+                    properties: {},
+                    required: []
+                }
+            }
+        };
+        // Add parameters to the definition
+        if (params.length > 0) {
+            const properties = {};
+            const required = [];
+            params.forEach(param => {
+                // Remove type annotations if present
+                const paramName = param.split(':')[0].trim();
+                if (paramName) {
+                    properties[paramName] = {
+                        type: "string",
+                        description: `Parameter ${paramName} for function ${name}`
+                    };
+                    required.push(paramName);
+                }
+            });
+            toolDef.function.parameters.properties = properties;
+            toolDef.function.parameters.required = required;
+        }
+        this.tools.push(toolDef);
+        logger_1.Logger.debug(`Auto-generated tool definition for ${functionName}`);
+    }
     /**
      * Process tool calls from the model
      * @param toolCalls Tool calls from the model

package/dist/llm/openai.js

@@ -40,14 +40,22 @@ function convertToOpenAIMessage(message) {
 function convertToOpenAITool(tool) {
     // If it's already in the correct format, return it
     if (tool.type === 'function' && typeof tool.type === 'string') {
+        // Ensure the function name is valid
+        if (!tool.function?.name || tool.function.name.trim() === '') {
+            tool.function.name = `function_${Math.random().toString(36).substring(2, 9)}`;
+        }
         return tool;
     }
+    // Generate a valid function name if none is provided
+    const functionName = tool.function?.name && tool.function.name.trim() !== ''
+        ? tool.function.name
+        : `function_${Math.random().toString(36).substring(2, 9)}`;
     // Otherwise, try to convert it
     return {
         type: 'function',
         function: {
-            name: tool.function?.name || '',
-            description: tool.function?.description || '',
+            name: functionName,
+            description: tool.function?.description || `Function ${functionName}`,
             parameters: tool.function?.parameters || {}
         }
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praisonai",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "PraisonAI TypeScript AI Agents Framework - Node.js, npm, and Javascript AI Agents Framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -62,7 +62,7 @@
     "fast-xml-parser": "^4.5.1",
     "node-fetch": "^2.6.9",
     "openai": "^4.81.0",
-    "praisonai": "^1.0.12"
+    "praisonai": "^1.0.18"
   },
   "optionalDependencies": {
     "boxen": "^7.1.1",