praisonai 1.0.0 → 1.0.1

package/README.md

@@ -1,3 +1,90 @@
-# praisonai
+# PraisonAI TypeScript Package
 
-AI development tools and utilities for modern JavaScript applications.
+A powerful TypeScript package for AI-driven tools and utilities.
+
+## Installation
+
+```bash
+npm install praisonai
+```
+
+## Development Setup
+
+1. Clone the repository:
+```bash
+git clone https://github.com/MervinPraison/PraisonAI.git
+cd src/praisonai-ts
+```
+
+2. Install dependencies:
+```bash
+npm install
+```
+
+3. Build the package:
+```bash
+npm run build
+```
+
+## Running Examples
+
+The package includes several examples to help you get started. To run an example:
+
+1. Build the package first:
+```bash
+npm run build
+```
+
+2. Run an example using ts-node:
+```bash
+npx ts-node examples/arxiv-search.ts
+```
+
+## Package Structure
+
+```
+src/
+├── agent/         # Agent-related interfaces and implementations
+├── agents/        # Multi-agent system management
+├── knowledge/     # Knowledge base and management
+├── llm/          # Language Model interfaces
+├── memory/       # Memory management systems
+├── process/      # Process management
+├── task/         # Task management
+└── tools/        # Various utility tools
+    ├── arxivTools.ts
+    └── ... (other tools)
+```
+
+## Usage
+
+Here's a simple example of using the ArxivSearchTool:
+
+```typescript
+import { ArxivSearchTool } from 'praisonai';
+
+async function main() {
+    const searchTool = new ArxivSearchTool();
+    const papers = await searchTool.execute('quantum computing', 5);
+    
+    papers.forEach(paper => {
+        console.log(`Title: ${paper.title}`);
+        console.log(`Authors: ${paper.authors.join(', ')}`);
+        console.log('---');
+    });
+}
+
+main();
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+MIT License - see the LICENSE file for details

package/dist/agent/agent.js

@@ -0,0 +1 @@
+"use strict";

package/dist/agent/index.d.ts

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

package/dist/agent/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Task = exports.PraisonAIAgents = exports.Agent = void 0;
+exports.setTaskMode = setTaskMode;
+// Export implementation based on mode
+let useTaskMode = false;
+function setTaskMode(enabled) {
+    useTaskMode = enabled;
+}
+var proxy_1 = require("./proxy");
+Object.defineProperty(exports, "Agent", { enumerable: true, get: function () { return proxy_1.Agent; } });
+Object.defineProperty(exports, "PraisonAIAgents", { enumerable: true, get: function () { return proxy_1.PraisonAIAgents; } });
+Object.defineProperty(exports, "Task", { enumerable: true, get: function () { return proxy_1.Task; } });

package/dist/agent/proxy.d.ts

@@ -0,0 +1,19 @@
+import { SimpleAgentConfig } from './simple';
+import { TaskAgentConfig } from './types';
+import { Task } from './types';
+export interface ProxyAgentConfig extends Partial<SimpleAgentConfig>, Partial<TaskAgentConfig> {
+    task?: Task;
+}
+export declare class Agent {
+    private simpleAgent;
+    private taskAgent;
+    constructor(config: ProxyAgentConfig);
+    execute(input: Task | string): Promise<any>;
+}
+export declare class PraisonAIAgents {
+    private simpleImpl;
+    private taskImpl;
+    constructor(config: any);
+    start(): Promise<any[]>;
+}
+export { Task } from './types';

package/dist/agent/proxy.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Task = exports.PraisonAIAgents = exports.Agent = void 0;
+const simple_1 = require("./simple");
+const types_1 = require("./types");
+const types_2 = require("./types");
+class Agent {
+    constructor(config) {
+        this.simpleAgent = null;
+        this.taskAgent = null;
+        // Auto-detect mode based on task presence
+        if (config.task) {
+            const taskConfig = {
+                name: config.name || 'TaskAgent',
+                role: config.role || 'Assistant',
+                goal: config.goal || 'Help complete the task',
+                backstory: config.backstory || 'You are an AI assistant',
+                verbose: config.verbose,
+                llm: config.llm,
+                markdown: config.markdown
+            };
+            this.taskAgent = new types_1.Agent(taskConfig);
+        }
+        else {
+            const simpleConfig = {
+                instructions: config.instructions || '',
+                name: config.name,
+                verbose: config.verbose,
+                llm: config.llm,
+                markdown: config.markdown
+            };
+            this.simpleAgent = new simple_1.Agent(simpleConfig);
+        }
+    }
+    async execute(input) {
+        if (this.taskAgent) {
+            const task = input;
+            const depResults = task.dependencies.map(dep => dep.result);
+            return this.taskAgent.execute(task, depResults);
+        }
+        else if (this.simpleAgent) {
+            return this.simpleAgent.execute(input);
+        }
+        throw new Error('No agent implementation available');
+    }
+}
+exports.Agent = Agent;
+class PraisonAIAgents {
+    constructor(config) {
+        this.simpleImpl = null;
+        this.taskImpl = null;
+        // Auto-detect mode based on tasks type
+        if (Array.isArray(config.tasks) && config.tasks.length > 0) {
+            const firstTask = config.tasks[0];
+            if (firstTask instanceof types_2.Task) {
+                this.taskImpl = new types_1.PraisonAIAgents({
+                    agents: config.agents,
+                    tasks: config.tasks,
+                    verbose: config.verbose,
+                    process: config.process,
+                    manager_llm: config.manager_llm
+                });
+            }
+            else {
+                this.simpleImpl = new simple_1.PraisonAIAgents({
+                    agents: config.agents,
+                    tasks: config.tasks,
+                    verbose: config.verbose,
+                    process: config.process
+                });
+            }
+        }
+        else {
+            throw new Error('No tasks provided');
+        }
+    }
+    async start() {
+        if (this.taskImpl) {
+            return this.taskImpl.start();
+        }
+        else if (this.simpleImpl) {
+            return this.simpleImpl.start();
+        }
+        throw new Error('No implementation available');
+    }
+}
+exports.PraisonAIAgents = PraisonAIAgents;
+var types_3 = require("./types");
+Object.defineProperty(exports, "Task", { enumerable: true, get: function () { return types_3.Task; } });

package/dist/agent/simple.d.ts

@@ -0,0 +1,35 @@
+export interface SimpleAgentConfig {
+    instructions: string;
+    name?: string;
+    verbose?: boolean;
+    llm?: string;
+    markdown?: boolean;
+}
+export declare class Agent {
+    private instructions;
+    private name;
+    private verbose;
+    private llm;
+    private markdown;
+    private llmService;
+    private result;
+    constructor(config: SimpleAgentConfig);
+    private createSystemPrompt;
+    execute(previousResult?: string): Promise<string>;
+    getResult(): string | null;
+}
+export interface PraisonAIAgentsConfig {
+    agents: Agent[];
+    tasks: string[];
+    verbose?: boolean;
+    process?: 'sequential' | 'parallel';
+}
+export declare class PraisonAIAgents {
+    private agents;
+    private tasks;
+    private verbose;
+    private process;
+    constructor(config: PraisonAIAgentsConfig);
+    start(): Promise<string[]>;
+    private executeSequential;
+}

package/dist/agent/simple.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PraisonAIAgents = exports.Agent = void 0;
+const openai_1 = require("../llm/openai");
+class Agent {
+    constructor(config) {
+        this.result = null;
+        this.instructions = config.instructions;
+        this.name = config.name || `Agent_${Math.random().toString(36).substr(2, 9)}`;
+        this.verbose = config.verbose || false;
+        this.llm = config.llm || 'gpt-4o-mini';
+        this.markdown = config.markdown || true;
+        this.llmService = new openai_1.OpenAIService(this.llm);
+    }
+    createSystemPrompt() {
+        return `You are an AI assistant tasked with helping users with their requests.
+Please provide detailed, accurate, and helpful responses.
+Format your response in markdown if appropriate.`;
+    }
+    async execute(previousResult) {
+        if (this.verbose) {
+            console.log(`Agent ${this.name} executing instructions: ${this.instructions}`);
+        }
+        try {
+            // Replace placeholder with previous result if available
+            const finalInstructions = previousResult
+                ? this.instructions.replace('{previous_result}', previousResult)
+                : this.instructions;
+            if (this.verbose) {
+                console.log('Generating response (streaming)...');
+                await this.llmService.streamText(finalInstructions, this.createSystemPrompt(), 0.7, (token) => process.stdout.write(token));
+                console.log('\n');
+            }
+            // Get the final response
+            this.result = await this.llmService.generateText(finalInstructions, this.createSystemPrompt());
+            return this.result;
+        }
+        catch (error) {
+            console.error(`Error executing instructions: ${error}`);
+            throw error;
+        }
+    }
+    getResult() {
+        return this.result;
+    }
+}
+exports.Agent = Agent;
+class PraisonAIAgents {
+    constructor(config) {
+        this.agents = config.agents;
+        this.tasks = config.tasks;
+        this.verbose = config.verbose || false;
+        this.process = config.process || 'sequential';
+    }
+    async start() {
+        if (this.verbose) {
+            console.log('Starting PraisonAI Agents execution...');
+        }
+        let results;
+        if (this.process === 'parallel') {
+            results = await Promise.all(this.tasks.map((task, index) => this.agents[index].execute()));
+        }
+        else {
+            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);
+            });
+        }
+        return results;
+    }
+    async executeSequential() {
+        const results = [];
+        let previousResult = undefined;
+        for (let i = 0; i < this.tasks.length; i++) {
+            const result = await this.agents[i].execute(previousResult);
+            results.push(result);
+            previousResult = result;
+        }
+        return results;
+    }
+}
+exports.PraisonAIAgents = PraisonAIAgents;

package/dist/agent/types.d.ts

@@ -0,0 +1,56 @@
+export interface TaskConfig {
+    name: string;
+    description: string;
+    expected_output: string;
+    agent?: any;
+    dependencies?: Task[];
+}
+export declare class Task {
+    name: string;
+    description: string;
+    expected_output: string;
+    agent: any;
+    dependencies: Task[];
+    result: any;
+    constructor(config: TaskConfig);
+}
+export interface TaskAgentConfig {
+    name: string;
+    role: string;
+    goal: string;
+    backstory: string;
+    verbose?: boolean;
+    llm?: string;
+    markdown?: boolean;
+}
+export declare class Agent {
+    private name;
+    private role;
+    private goal;
+    private backstory;
+    private verbose;
+    private llm;
+    private markdown;
+    private result;
+    constructor(config: TaskAgentConfig);
+    execute(task: Task, dependencyResults?: any[]): Promise<any>;
+}
+export interface TaskPraisonAIAgentsConfig {
+    agents: Agent[];
+    tasks: Task[];
+    verbose?: boolean;
+    process?: 'sequential' | 'parallel' | 'hierarchical';
+    manager_llm?: string;
+}
+export declare class PraisonAIAgents {
+    private agents;
+    private tasks;
+    private verbose;
+    private process;
+    private manager_llm;
+    constructor(config: TaskPraisonAIAgentsConfig);
+    start(): Promise<any[]>;
+    private executeSequential;
+    private executeHierarchical;
+}
+export type { TaskAgentConfig as AgentConfig };

package/dist/agent/types.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PraisonAIAgents = exports.Agent = exports.Task = void 0;
+const openai_1 = require("../llm/openai");
+const logger_1 = require("../utils/logger");
+class Task {
+    constructor(config) {
+        this.name = config.name;
+        this.description = config.description;
+        this.expected_output = config.expected_output;
+        this.agent = config.agent || null;
+        this.dependencies = config.dependencies || [];
+        this.result = null;
+        logger_1.Logger.debug(`Task created: ${this.name}`, { config });
+    }
+}
+exports.Task = Task;
+class Agent {
+    constructor(config) {
+        this.name = config.name;
+        this.role = config.role;
+        this.goal = config.goal;
+        this.backstory = config.backstory;
+        this.verbose = config.verbose || false;
+        this.llm = new openai_1.OpenAIService(config.llm || 'gpt-4o-mini');
+        this.markdown = config.markdown || true;
+        this.result = '';
+        logger_1.Logger.debug(`Agent created: ${this.name}`, { config });
+    }
+    async execute(task, dependencyResults) {
+        logger_1.Logger.debug(`Agent ${this.name} executing task: ${task.name}`, {
+            task,
+            dependencyResults
+        });
+        const systemPrompt = `You are ${this.name}, a ${this.role}.
+Your goal is to ${this.goal}.
+Background: ${this.backstory}
+
+You must complete the following task:
+Name: ${task.name}
+Description: ${task.description}
+Expected Output: ${task.expected_output}
+
+Respond ONLY with the expected output. Do not include any additional text, explanations, or pleasantries.`;
+        let prompt = '';
+        if (dependencyResults && dependencyResults.length > 0) {
+            prompt = `Here are the results from previous tasks that you should use as input:
+${dependencyResults.map((result, index) => `Task ${index + 1} Result:\n${result}`).join('\n\n')}
+
+Based on these results, please complete your task.`;
+            logger_1.Logger.debug('Using dependency results for prompt', { dependencyResults });
+        }
+        else {
+            prompt = 'Please complete your task.';
+        }
+        logger_1.Logger.debug('Preparing LLM request', {
+            systemPrompt,
+            prompt
+        });
+        if (this.verbose) {
+            logger_1.Logger.info(`\nExecuting task for ${this.name}...`);
+            logger_1.Logger.info(`Task: ${task.name}`);
+            logger_1.Logger.info('Generating response (streaming)...\n');
+        }
+        // Reset result
+        this.result = '';
+        // Stream the response and collect it
+        await this.llm.streamText(prompt, systemPrompt, 0.7, (token) => {
+            if (this.verbose) {
+                process.stdout.write(token);
+            }
+            this.result += token;
+        });
+        if (this.verbose) {
+            console.log('\n'); // Add newline after streaming
+        }
+        logger_1.Logger.debug(`Agent ${this.name} completed task: ${task.name}`, {
+            result: this.result
+        });
+        return this.result;
+    }
+}
+exports.Agent = Agent;
+class PraisonAIAgents {
+    constructor(config) {
+        this.agents = config.agents;
+        this.tasks = config.tasks;
+        this.verbose = config.verbose || false;
+        this.process = config.process || 'sequential';
+        this.manager_llm = config.manager_llm || 'gpt-4o-mini';
+        logger_1.Logger.debug('PraisonAIAgents initialized', { config });
+    }
+    async start() {
+        logger_1.Logger.info('Starting PraisonAI Agents execution...');
+        logger_1.Logger.debug('Starting with process mode:', this.process);
+        let results;
+        switch (this.process) {
+            case 'parallel':
+                logger_1.Logger.debug('Executing tasks in parallel');
+                results = await Promise.all(this.tasks.map(task => {
+                    if (!task.agent)
+                        throw new Error(`No agent assigned to task: ${task.name}`);
+                    return task.agent.execute(task);
+                }));
+                break;
+            case 'hierarchical':
+                logger_1.Logger.debug('Executing tasks hierarchically');
+                results = await this.executeHierarchical();
+                break;
+            default:
+                logger_1.Logger.debug('Executing tasks sequentially');
+                results = await this.executeSequential();
+        }
+        if (this.verbose) {
+            logger_1.Logger.info('\nPraisonAI Agents execution completed.');
+            results.forEach((result, index) => {
+                logger_1.Logger.info(`\nFinal Result from Task ${index + 1}:`);
+                console.log(result);
+            });
+        }
+        logger_1.Logger.debug('Execution completed', { results });
+        return results;
+    }
+    async executeSequential() {
+        logger_1.Logger.debug('Starting sequential execution');
+        const results = [];
+        for (const task of this.tasks) {
+            if (!task.agent)
+                throw new Error(`No agent assigned to task: ${task.name}`);
+            logger_1.Logger.debug(`Executing task: ${task.name}`);
+            const result = await task.agent.execute(task);
+            results.push(result);
+            task.result = result;
+            logger_1.Logger.debug(`Completed task: ${task.name}`, { result });
+        }
+        return results;
+    }
+    async executeHierarchical() {
+        logger_1.Logger.debug('Starting hierarchical execution');
+        const results = [];
+        for (const task of this.tasks) {
+            if (!task.agent)
+                throw new Error(`No agent assigned to task: ${task.name}`);
+            logger_1.Logger.debug(`Executing task: ${task.name}`, {
+                dependencies: task.dependencies.map(d => d.name)
+            });
+            const depResults = task.dependencies.map(dep => dep.result);
+            logger_1.Logger.debug(`Dependency results for task ${task.name}`, { depResults });
+            const result = await task.agent.execute(task, depResults);
+            results.push(result);
+            task.result = result;
+            logger_1.Logger.debug(`Completed task: ${task.name}`, { result });
+        }
+        return results;
+    }
+}
+exports.PraisonAIAgents = PraisonAIAgents;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './agent';
+export * from './knowledge';
+export * from './llm';
+export * from './memory';
+export * from './process';
+export * from './tools';

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Export all public modules
+__exportStar(require("./agent"), exports);
+__exportStar(require("./knowledge"), exports);
+__exportStar(require("./llm"), exports);
+__exportStar(require("./memory"), exports);
+__exportStar(require("./process"), exports);
+__exportStar(require("./tools"), exports);

package/dist/knowledge/chunking.js

@@ -0,0 +1 @@
+"use strict";

package/dist/knowledge/index.d.ts

@@ -0,0 +1,22 @@
+export interface Knowledge {
+    id: string;
+    type: string;
+    content: any;
+    metadata: Record<string, any>;
+}
+export interface KnowledgeBase {
+    addKnowledge(knowledge: Knowledge): void;
+    getKnowledge(id: string): Knowledge | undefined;
+    searchKnowledge(query: string): Knowledge[];
+    updateKnowledge(id: string, knowledge: Partial<Knowledge>): boolean;
+    deleteKnowledge(id: string): boolean;
+}
+export declare class BaseKnowledgeBase implements KnowledgeBase {
+    private knowledge;
+    constructor();
+    addKnowledge(knowledge: Knowledge): void;
+    getKnowledge(id: string): Knowledge | undefined;
+    searchKnowledge(query: string): Knowledge[];
+    updateKnowledge(id: string, update: Partial<Knowledge>): boolean;
+    deleteKnowledge(id: string): boolean;
+}

package/dist/knowledge/index.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseKnowledgeBase = void 0;
+class BaseKnowledgeBase {
+    constructor() {
+        this.knowledge = new Map();
+    }
+    addKnowledge(knowledge) {
+        this.knowledge.set(knowledge.id, knowledge);
+    }
+    getKnowledge(id) {
+        return this.knowledge.get(id);
+    }
+    searchKnowledge(query) {
+        // Basic implementation - should be enhanced with proper search logic
+        return Array.from(this.knowledge.values()).filter(k => JSON.stringify(k).toLowerCase().includes(query.toLowerCase()));
+    }
+    updateKnowledge(id, update) {
+        const existing = this.knowledge.get(id);
+        if (!existing)
+            return false;
+        this.knowledge.set(id, { ...existing, ...update });
+        return true;
+    }
+    deleteKnowledge(id) {
+        return this.knowledge.delete(id);
+    }
+}
+exports.BaseKnowledgeBase = BaseKnowledgeBase;

package/dist/knowledge/knowledge.js

@@ -0,0 +1 @@
+"use strict";