praisonai 1.0.13 → 1.0.15

package/dist/agent/proxy.d.ts

@@ -7,7 +7,9 @@ export interface ProxyAgentConfig extends Partial<SimpleAgentConfig>, Partial<Ta
 export declare class Agent {
     private simpleAgent;
     private taskAgent;
+    private instructions;
     constructor(config: ProxyAgentConfig);
+    getInstructions(): string;
     execute(input: Task | string): Promise<any>;
     start(prompt: string, previousResult?: string): Promise<string>;
     chat(prompt: string, previousResult?: string): Promise<string>;

package/dist/agent/proxy.js

@@ -8,6 +8,7 @@ class Agent {
     constructor(config) {
         this.simpleAgent = null;
         this.taskAgent = null;
+        this.instructions = config.instructions || '';
         // Auto-detect mode based on task presence
         if (config.task) {
             const taskConfig = {
@@ -23,7 +24,7 @@ class Agent {
         }
         else {
             const simpleConfig = {
-                instructions: config.instructions || '',
+                instructions: this.instructions,
                 name: config.name,
                 verbose: config.verbose,
                 llm: config.llm,
@@ -32,6 +33,9 @@ class Agent {
             this.simpleAgent = new simple_1.Agent(simpleConfig);
         }
     }
+    getInstructions() {
+        return this.instructions;
+    }
     async execute(input) {
         if (this.taskAgent) {
             const task = input;
@@ -82,9 +86,9 @@ class PraisonAIAgents {
         this.simpleImpl = null;
         this.taskImpl = null;
         // Auto-detect mode based on tasks type
-        if (Array.isArray(config.tasks) && config.tasks.length > 0) {
-            // If tasks are strings, use simple mode
-            if (typeof config.tasks[0] === 'string') {
+        if (Array.isArray(config.tasks)) {
+            // If tasks are provided and are strings, use simple mode
+            if (config.tasks.length > 0 && typeof config.tasks[0] === 'string') {
                 this.simpleImpl = new simple_1.PraisonAIAgents({
                     agents: config.agents,
                     tasks: config.tasks,
@@ -92,8 +96,8 @@ class PraisonAIAgents {
                     process: config.process
                 });
             }
-            else {
-                // Otherwise, use task mode
+            else if (config.tasks.length > 0) {
+                // If tasks are provided but not strings, use task mode
                 this.taskImpl = new types_1.PraisonAIAgents({
                     agents: config.agents,
                     tasks: config.tasks,
@@ -103,8 +107,13 @@ class PraisonAIAgents {
                 });
             }
         }
-        else {
-            throw new Error('No tasks provided');
+        // If no tasks provided, create simple implementation with auto-generated tasks
+        if (!this.simpleImpl && !this.taskImpl) {
+            this.simpleImpl = new simple_1.PraisonAIAgents({
+                agents: config.agents,
+                verbose: config.verbose,
+                process: config.process
+            });
         }
     }
     async start() {

package/dist/agent/simple.d.ts

@@ -22,10 +22,11 @@ export declare class Agent {
     chat(prompt: string, previousResult?: string): Promise<string>;
     execute(previousResult?: string): Promise<string>;
     getResult(): string | null;
+    getInstructions(): string;
 }
 export interface PraisonAIAgentsConfig {
     agents: Agent[];
-    tasks: string[];
+    tasks?: string[];
     verbose?: boolean;
     pretty?: boolean;
     process?: 'sequential' | 'parallel';
@@ -37,7 +38,8 @@ export declare class PraisonAIAgents {
     private pretty;
     private process;
     constructor(config: PraisonAIAgentsConfig);
+    private generateTasks;
+    private executeSequential;
     start(): Promise<string[]>;
     chat(): Promise<string[]>;
-    private executeSequential;
 }

package/dist/agent/simple.js

@@ -60,51 +60,75 @@ class Agent {
     getResult() {
         return null;
     }
+    getInstructions() {
+        return this.instructions;
+    }
 }
 exports.Agent = Agent;
 class PraisonAIAgents {
     constructor(config) {
         this.agents = config.agents;
-        this.tasks = config.tasks;
-        this.verbose = config.verbose || false;
-        this.pretty = config.pretty || false;
+        this.verbose = config.verbose ?? process.env.PRAISON_VERBOSE !== 'false';
+        this.pretty = config.pretty ?? process.env.PRAISON_PRETTY === 'true';
         this.process = config.process || 'sequential';
+        // Auto-generate tasks if not provided
+        this.tasks = config.tasks || this.generateTasks();
         // Configure logging
-        logger_1.Logger.setVerbose(config.verbose ?? process.env.PRAISON_VERBOSE !== 'false');
-        logger_1.Logger.setPretty(config.pretty ?? process.env.PRAISON_PRETTY === 'true');
+        logger_1.Logger.setVerbose(this.verbose);
+        logger_1.Logger.setPretty(this.pretty);
+    }
+    generateTasks() {
+        return this.agents.map(agent => {
+            const instructions = agent.getInstructions();
+            // Extract task from instructions - get first sentence or whole instruction if no period
+            const task = instructions.split('.')[0].trim();
+            return task;
+        });
+    }
+    async executeSequential() {
+        const results = [];
+        let previousResult;
+        for (let i = 0; i < this.agents.length; i++) {
+            const agent = this.agents[i];
+            const task = this.tasks[i];
+            await logger_1.Logger.debug(`Running agent ${i + 1}: ${agent.name}`);
+            await logger_1.Logger.debug(`Task: ${task}`);
+            // For first agent, use task directly
+            // For subsequent agents, append previous result to their instructions
+            const prompt = i === 0 ? task : `${task}\n\nHere is the input: ${previousResult}`;
+            const result = await agent.start(prompt, previousResult);
+            results.push(result);
+            previousResult = result;
+        }
+        return results;
     }
     async start() {
         await logger_1.Logger.debug('Starting PraisonAI Agents execution...');
+        await logger_1.Logger.debug('Process mode:', this.process);
+        await logger_1.Logger.debug('Tasks:', this.tasks);
         let results;
         if (this.process === 'parallel') {
-            results = await Promise.all(this.tasks.map((task, index) => this.agents[index].start(task)));
+            // Run all agents in parallel
+            const promises = this.agents.map((agent, i) => {
+                const task = this.tasks[i];
+                return agent.start(task);
+            });
+            results = await Promise.all(promises);
         }
         else {
+            // Run agents sequentially (default)
             results = await this.executeSequential();
         }
         if (this.verbose) {
-            console.log('PraisonAI Agents execution completed.');
-            results.forEach((result, index) => {
-                console.log(`\nResult from Agent ${index + 1}:`);
-                console.log(result);
-            });
+            await logger_1.Logger.info('PraisonAI Agents execution completed.');
+            for (let i = 0; i < results.length; i++) {
+                await logger_1.Logger.section(`Result from Agent ${i + 1}`, results[i]);
+            }
         }
         return results;
     }
     async chat() {
         return this.start();
     }
-    async executeSequential() {
-        const results = [];
-        for (let i = 0; i < this.agents.length; i++) {
-            const agent = this.agents[i];
-            const task = this.tasks[i];
-            const previousResult = i > 0 ? results[i - 1] : undefined;
-            await logger_1.Logger.info(`Agent ${agent.name} starting with prompt: ${task}`);
-            const result = await agent.start(task, previousResult);
-            results.push(result);
-        }
-        return results;
-    }
 }
 exports.PraisonAIAgents = PraisonAIAgents;

package/dist/llm/openai.js

@@ -20,7 +20,7 @@ async function getOpenAIClient() {
         openAIInstance = new openai_1.default({
             apiKey: process.env.OPENAI_API_KEY
         });
-        await logger_1.Logger.success('OpenAI client initialized');
+        await logger_1.Logger.debug('OpenAI client initialized');
     }
     return openAIInstance;
 }
@@ -113,7 +113,7 @@ class OpenAIService {
                 fullResponse += token;
                 onToken(token);
             }
-            await logger_1.Logger.success('Stream completed successfully');
+            await logger_1.Logger.debug('Stream completed successfully');
         }
         catch (error) {
             await logger_1.Logger.error('Error in text stream', error);

package/package.json

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