overai 1.4.0

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,165 @@
+"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-5-nano');
+        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-5-nano';
+        logger_1.Logger.debug('PraisonAIAgents initialized', { config });
+    }
+    async start() {
+        logger_1.Logger.debug('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() {
+        const startTime = process.env.LOGLEVEL === 'debug' ? Date.now() : 0;
+        logger_1.Logger.debug('Starting hierarchical execution');
+        const results = [];
+        for (const task of this.tasks) {
+            const taskStartTime = process.env.LOGLEVEL === 'debug' ? Date.now() : 0;
+            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;
+            if (process.env.LOGLEVEL === 'debug') {
+                logger_1.Logger.debug(`Task execution time for ${task.name}: ${Date.now() - taskStartTime}ms`);
+            }
+            logger_1.Logger.debug(`Completed task: ${task.name}`, { result });
+        }
+        if (process.env.LOGLEVEL === 'debug') {
+            logger_1.Logger.debug(`Total hierarchical execution time: ${Date.now() - startTime}ms`);
+        }
+        return results;
+    }
+}
+exports.PraisonAIAgents = PraisonAIAgents;

package/dist/ai/agent-loop.d.ts

@@ -0,0 +1,177 @@
+/**
+ * Agent Loop - Manual Agent Loop Control
+ *
+ * Provides utilities for manual control of agent execution loops.
+ */
+import type { Message } from './types';
+export interface AgentLoopConfig {
+    /** Model to use */
+    model: string;
+    /** System prompt */
+    system?: string;
+    /** Available tools */
+    tools?: Record<string, AgentTool>;
+    /** Maximum steps (default: 10) */
+    maxSteps?: number;
+    /** Stop condition */
+    stopWhen?: StopCondition;
+    /** On step finish callback */
+    onStepFinish?: (step: AgentStep) => void | Promise<void>;
+    /** On tool call callback (for approval) */
+    onToolCall?: (toolCall: ToolCallInfo) => Promise<boolean>;
+}
+export interface AgentTool {
+    description: string;
+    parameters: any;
+    execute: (args: any) => Promise<any>;
+}
+export interface AgentStep {
+    stepNumber: number;
+    text: string;
+    toolCalls: ToolCallInfo[];
+    toolResults: ToolResultInfo[];
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    finishReason: string;
+}
+export interface ToolCallInfo {
+    toolCallId: string;
+    toolName: string;
+    args: any;
+}
+export interface ToolResultInfo {
+    toolCallId: string;
+    toolName: string;
+    result: any;
+    isError?: boolean;
+}
+export type StopCondition = {
+    type: 'stepCount';
+    count: number;
+} | {
+    type: 'noToolCalls';
+} | {
+    type: 'custom';
+    check: (step: AgentStep) => boolean;
+};
+export interface AgentLoopResult {
+    text: string;
+    steps: AgentStep[];
+    totalUsage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    finishReason: string;
+}
+/**
+ * Create a manual agent loop for fine-grained control.
+ *
+ * @example Basic usage
+ * ```typescript
+ * const loop = createAgentLoop({
+ *   model: 'gpt-4o',
+ *   system: 'You are a helpful assistant',
+ *   tools: {
+ *     search: {
+ *       description: 'Search the web',
+ *       parameters: z.object({ query: z.string() }),
+ *       execute: async ({ query }) => searchWeb(query)
+ *     }
+ *   },
+ *   maxSteps: 5
+ * });
+ *
+ * const result = await loop.run('Find information about AI');
+ * ```
+ *
+ * @example With approval
+ * ```typescript
+ * const loop = createAgentLoop({
+ *   model: 'gpt-4o',
+ *   tools: { ... },
+ *   onToolCall: async (toolCall) => {
+ *     const approved = await askUserForApproval(toolCall);
+ *     return approved;
+ *   }
+ * });
+ * ```
+ *
+ * @example Step-by-step control
+ * ```typescript
+ * const loop = createAgentLoop({ model: 'gpt-4o', tools: { ... } });
+ *
+ * // Initialize with a prompt
+ * loop.addMessage({ role: 'user', content: 'Hello' });
+ *
+ * // Run one step at a time
+ * while (!loop.isComplete()) {
+ *   const step = await loop.step();
+ *   console.log('Step:', step);
+ *
+ *   // Optionally modify messages or tools between steps
+ *   if (needsMoreContext) {
+ *     loop.addMessage({ role: 'user', content: 'Additional context...' });
+ *   }
+ * }
+ *
+ * const result = loop.getResult();
+ * ```
+ */
+export declare function createAgentLoop(config: AgentLoopConfig): AgentLoop;
+export declare class AgentLoop {
+    private config;
+    private messages;
+    private steps;
+    private currentStep;
+    private complete;
+    private totalUsage;
+    constructor(config: AgentLoopConfig);
+    /**
+     * Add a message to the conversation.
+     */
+    addMessage(message: Message): void;
+    /**
+     * Get all messages in the conversation.
+     */
+    getMessages(): Message[];
+    /**
+     * Check if the loop is complete.
+     */
+    isComplete(): boolean;
+    /**
+     * Run a single step of the agent loop.
+     */
+    step(): Promise<AgentStep>;
+    /**
+     * Run the full agent loop until completion.
+     */
+    run(prompt: string): Promise<AgentLoopResult>;
+    /**
+     * Get the final result.
+     */
+    getResult(): AgentLoopResult;
+    /**
+     * Check if the loop should stop.
+     */
+    private shouldStop;
+    /**
+     * Reset the agent loop.
+     */
+    reset(): void;
+}
+/**
+ * Create a stop condition that stops after N steps.
+ */
+export declare function stopAfterSteps(count: number): StopCondition;
+/**
+ * Create a stop condition that stops when no tool calls are made.
+ */
+export declare function stopWhenNoToolCalls(): StopCondition;
+/**
+ * Create a custom stop condition.
+ */
+export declare function stopWhen(check: (step: AgentStep) => boolean): StopCondition;

package/dist/ai/agent-loop.js

@@ -0,0 +1,313 @@
+"use strict";
+/**
+ * Agent Loop - Manual Agent Loop Control
+ *
+ * Provides utilities for manual control of agent execution loops.
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentLoop = void 0;
+exports.createAgentLoop = createAgentLoop;
+exports.stopAfterSteps = stopAfterSteps;
+exports.stopWhenNoToolCalls = stopWhenNoToolCalls;
+exports.stopWhen = stopWhen;
+/**
+ * Create a manual agent loop for fine-grained control.
+ *
+ * @example Basic usage
+ * ```typescript
+ * const loop = createAgentLoop({
+ *   model: 'gpt-4o',
+ *   system: 'You are a helpful assistant',
+ *   tools: {
+ *     search: {
+ *       description: 'Search the web',
+ *       parameters: z.object({ query: z.string() }),
+ *       execute: async ({ query }) => searchWeb(query)
+ *     }
+ *   },
+ *   maxSteps: 5
+ * });
+ *
+ * const result = await loop.run('Find information about AI');
+ * ```
+ *
+ * @example With approval
+ * ```typescript
+ * const loop = createAgentLoop({
+ *   model: 'gpt-4o',
+ *   tools: { ... },
+ *   onToolCall: async (toolCall) => {
+ *     const approved = await askUserForApproval(toolCall);
+ *     return approved;
+ *   }
+ * });
+ * ```
+ *
+ * @example Step-by-step control
+ * ```typescript
+ * const loop = createAgentLoop({ model: 'gpt-4o', tools: { ... } });
+ *
+ * // Initialize with a prompt
+ * loop.addMessage({ role: 'user', content: 'Hello' });
+ *
+ * // Run one step at a time
+ * while (!loop.isComplete()) {
+ *   const step = await loop.step();
+ *   console.log('Step:', step);
+ *
+ *   // Optionally modify messages or tools between steps
+ *   if (needsMoreContext) {
+ *     loop.addMessage({ role: 'user', content: 'Additional context...' });
+ *   }
+ * }
+ *
+ * const result = loop.getResult();
+ * ```
+ */
+function createAgentLoop(config) {
+    return new AgentLoop(config);
+}
+class AgentLoop {
+    constructor(config) {
+        this.messages = [];
+        this.steps = [];
+        this.currentStep = 0;
+        this.complete = false;
+        this.totalUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+        this.config = {
+            maxSteps: 10,
+            ...config,
+        };
+        // Add system message if provided
+        if (config.system) {
+            this.messages.push({ role: 'system', content: config.system });
+        }
+    }
+    /**
+     * Add a message to the conversation.
+     */
+    addMessage(message) {
+        this.messages.push(message);
+    }
+    /**
+     * Get all messages in the conversation.
+     */
+    getMessages() {
+        return [...this.messages];
+    }
+    /**
+     * Check if the loop is complete.
+     */
+    isComplete() {
+        return this.complete;
+    }
+    /**
+     * Run a single step of the agent loop.
+     */
+    async step() {
+        if (this.complete) {
+            throw new Error('Agent loop is already complete');
+        }
+        this.currentStep++;
+        // Check max steps
+        if (this.currentStep > (this.config.maxSteps || 10)) {
+            this.complete = true;
+            throw new Error(`Maximum steps (${this.config.maxSteps}) reached`);
+        }
+        // Import and call generateText
+        const { generateText } = await Promise.resolve().then(() => __importStar(require('./generate-text')));
+        const result = await generateText({
+            model: this.config.model,
+            messages: this.messages,
+            tools: this.config.tools,
+            maxSteps: 1, // Single step
+        });
+        // Build step result
+        const step = {
+            stepNumber: this.currentStep,
+            text: result.text,
+            toolCalls: result.toolCalls.map(tc => ({
+                toolCallId: tc.toolCallId,
+                toolName: tc.toolName,
+                args: tc.args,
+            })),
+            toolResults: result.toolResults.map(tr => ({
+                toolCallId: tr.toolCallId,
+                toolName: tr.toolName,
+                result: tr.result,
+            })),
+            usage: result.usage,
+            finishReason: result.finishReason,
+        };
+        // Update total usage
+        this.totalUsage.promptTokens += result.usage.promptTokens;
+        this.totalUsage.completionTokens += result.usage.completionTokens;
+        this.totalUsage.totalTokens += result.usage.totalTokens;
+        // Add assistant message
+        if (result.text) {
+            this.messages.push({ role: 'assistant', content: result.text });
+        }
+        // Handle tool calls
+        if (step.toolCalls.length > 0) {
+            // Check for approval if callback provided
+            if (this.config.onToolCall) {
+                for (const toolCall of step.toolCalls) {
+                    const approved = await this.config.onToolCall(toolCall);
+                    if (!approved) {
+                        this.complete = true;
+                        step.finishReason = 'tool_rejected';
+                        break;
+                    }
+                }
+            }
+            // Add tool call message
+            const toolCallParts = step.toolCalls.map(tc => ({
+                type: 'tool-call',
+                toolCallId: tc.toolCallId,
+                toolName: tc.toolName,
+                args: tc.args,
+            }));
+            this.messages.push({ role: 'assistant', content: '', toolCalls: toolCallParts });
+            // Add tool results
+            for (const tr of step.toolResults) {
+                const toolResultPart = {
+                    type: 'tool-result',
+                    toolCallId: tr.toolCallId,
+                    toolName: tr.toolName,
+                    result: tr.result,
+                };
+                this.messages.push({
+                    role: 'tool',
+                    content: [toolResultPart],
+                    toolCallId: tr.toolCallId,
+                });
+            }
+        }
+        // Store step
+        this.steps.push(step);
+        // Call step finish callback
+        if (this.config.onStepFinish) {
+            await this.config.onStepFinish(step);
+        }
+        // Check stop conditions
+        if (this.shouldStop(step)) {
+            this.complete = true;
+        }
+        return step;
+    }
+    /**
+     * Run the full agent loop until completion.
+     */
+    async run(prompt) {
+        // Add user message
+        this.addMessage({ role: 'user', content: prompt });
+        // Run steps until complete
+        while (!this.isComplete()) {
+            try {
+                await this.step();
+            }
+            catch (error) {
+                if (error.message.includes('Maximum steps')) {
+                    break;
+                }
+                throw error;
+            }
+        }
+        return this.getResult();
+    }
+    /**
+     * Get the final result.
+     */
+    getResult() {
+        const lastStep = this.steps[this.steps.length - 1];
+        return {
+            text: lastStep?.text || '',
+            steps: this.steps,
+            totalUsage: this.totalUsage,
+            finishReason: lastStep?.finishReason || 'unknown',
+        };
+    }
+    /**
+     * Check if the loop should stop.
+     */
+    shouldStop(step) {
+        // Check custom stop condition
+        if (this.config.stopWhen) {
+            switch (this.config.stopWhen.type) {
+                case 'stepCount':
+                    return this.currentStep >= this.config.stopWhen.count;
+                case 'noToolCalls':
+                    return step.toolCalls.length === 0;
+                case 'custom':
+                    return this.config.stopWhen.check(step);
+            }
+        }
+        // Default: stop when no tool calls
+        return step.toolCalls.length === 0 && step.finishReason === 'stop';
+    }
+    /**
+     * Reset the agent loop.
+     */
+    reset() {
+        this.messages = [];
+        this.steps = [];
+        this.currentStep = 0;
+        this.complete = false;
+        this.totalUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+        if (this.config.system) {
+            this.messages.push({ role: 'system', content: this.config.system });
+        }
+    }
+}
+exports.AgentLoop = AgentLoop;
+/**
+ * Create a stop condition that stops after N steps.
+ */
+function stopAfterSteps(count) {
+    return { type: 'stepCount', count };
+}
+/**
+ * Create a stop condition that stops when no tool calls are made.
+ */
+function stopWhenNoToolCalls() {
+    return { type: 'noToolCalls' };
+}
+/**
+ * Create a custom stop condition.
+ */
+function stopWhen(check) {
+    return { type: 'custom', check };
+}