overai 1.4.0

package/dist/planning/index.js

@@ -0,0 +1,475 @@
+"use strict";
+/**
+ * Planning System - Plans, Steps, and TodoLists
+ */
+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.TaskAgent = exports.PlanningAgent = exports.PlanStorage = exports.TodoList = exports.TodoItem = exports.Plan = exports.PlanStep = void 0;
+exports.createPlan = createPlan;
+exports.createTodoList = createTodoList;
+exports.createPlanStorage = createPlanStorage;
+exports.createPlanningAgent = createPlanningAgent;
+exports.createTaskAgent = createTaskAgent;
+/**
+ * PlanStep - A single step in a plan
+ */
+class PlanStep {
+    constructor(config) {
+        this.id = `step_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        this.description = config.description;
+        this.status = config.status ?? 'pending';
+        this.order = config.order ?? 0;
+        this.dependencies = config.dependencies ?? [];
+        this.metadata = config.metadata ?? {};
+    }
+    start() {
+        this.status = 'in_progress';
+        this.startedAt = Date.now();
+        return this;
+    }
+    complete() {
+        this.status = 'completed';
+        this.completedAt = Date.now();
+        return this;
+    }
+    fail() {
+        this.status = 'failed';
+        this.completedAt = Date.now();
+        return this;
+    }
+    cancel() {
+        this.status = 'cancelled';
+        return this;
+    }
+}
+exports.PlanStep = PlanStep;
+/**
+ * Plan - A collection of steps to accomplish a goal
+ */
+class Plan {
+    constructor(config) {
+        this.steps = [];
+        this.status = 'pending';
+        this.id = `plan_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        this.name = config.name;
+        this.description = config.description;
+        this.metadata = config.metadata ?? {};
+        this.createdAt = Date.now();
+        this.updatedAt = Date.now();
+    }
+    addStep(step) {
+        step.order = this.steps.length;
+        this.steps.push(step);
+        this.updatedAt = Date.now();
+        return this;
+    }
+    removeStep(stepId) {
+        const index = this.steps.findIndex(s => s.id === stepId);
+        if (index >= 0) {
+            this.steps.splice(index, 1);
+            this.updatedAt = Date.now();
+            return true;
+        }
+        return false;
+    }
+    getStep(stepId) {
+        return this.steps.find(s => s.id === stepId);
+    }
+    getNextStep() {
+        return this.steps.find(s => s.status === 'pending');
+    }
+    getProgress() {
+        const completed = this.steps.filter(s => s.status === 'completed').length;
+        const total = this.steps.length;
+        return {
+            completed,
+            total,
+            percentage: total > 0 ? Math.round((completed / total) * 100) : 0
+        };
+    }
+    start() {
+        this.status = 'in_progress';
+        this.updatedAt = Date.now();
+        return this;
+    }
+    complete() {
+        this.status = 'completed';
+        this.updatedAt = Date.now();
+        return this;
+    }
+}
+exports.Plan = Plan;
+/**
+ * TodoItem - A single todo item
+ */
+class TodoItem {
+    constructor(config) {
+        this.id = `todo_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        this.content = config.content;
+        this.priority = config.priority ?? 'medium';
+        this.status = config.status ?? 'pending';
+        this.dueDate = config.dueDate;
+        this.metadata = config.metadata ?? {};
+        this.createdAt = Date.now();
+    }
+    start() {
+        this.status = 'in_progress';
+        return this;
+    }
+    complete() {
+        this.status = 'completed';
+        this.completedAt = Date.now();
+        return this;
+    }
+    reset() {
+        this.status = 'pending';
+        this.completedAt = undefined;
+        return this;
+    }
+}
+exports.TodoItem = TodoItem;
+/**
+ * TodoList - A collection of todo items
+ */
+class TodoList {
+    constructor(name = 'Todo List') {
+        this.items = [];
+        this.id = `todolist_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        this.name = name;
+        this.createdAt = Date.now();
+    }
+    add(item) {
+        this.items.push(item);
+        return this;
+    }
+    remove(itemId) {
+        const index = this.items.findIndex(i => i.id === itemId);
+        if (index >= 0) {
+            this.items.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+    get(itemId) {
+        return this.items.find(i => i.id === itemId);
+    }
+    getPending() {
+        return this.items.filter(i => i.status === 'pending');
+    }
+    getCompleted() {
+        return this.items.filter(i => i.status === 'completed');
+    }
+    getByPriority(priority) {
+        return this.items.filter(i => i.priority === priority);
+    }
+    getProgress() {
+        const completed = this.items.filter(i => i.status === 'completed').length;
+        const total = this.items.length;
+        return {
+            completed,
+            total,
+            percentage: total > 0 ? Math.round((completed / total) * 100) : 0
+        };
+    }
+    clear() {
+        this.items = [];
+        return this;
+    }
+}
+exports.TodoList = TodoList;
+/**
+ * PlanStorage - Persist plans (in-memory implementation)
+ */
+class PlanStorage {
+    constructor() {
+        this.plans = new Map();
+        this.todoLists = new Map();
+    }
+    savePlan(plan) {
+        this.plans.set(plan.id, plan);
+    }
+    getPlan(planId) {
+        return this.plans.get(planId);
+    }
+    deletePlan(planId) {
+        return this.plans.delete(planId);
+    }
+    listPlans() {
+        return Array.from(this.plans.values());
+    }
+    saveTodoList(list) {
+        this.todoLists.set(list.id, list);
+    }
+    getTodoList(listId) {
+        return this.todoLists.get(listId);
+    }
+    deleteTodoList(listId) {
+        return this.todoLists.delete(listId);
+    }
+    listTodoLists() {
+        return Array.from(this.todoLists.values());
+    }
+}
+exports.PlanStorage = PlanStorage;
+/**
+ * Create a Plan
+ */
+function createPlan(config) {
+    return new Plan(config);
+}
+/**
+ * Create a TodoList
+ */
+function createTodoList(name) {
+    return new TodoList(name);
+}
+/**
+ * Create a PlanStorage
+ */
+function createPlanStorage() {
+    return new PlanStorage();
+}
+// Import Agent dynamically to avoid circular dependency
+let AgentClass = null;
+async function getAgentClass() {
+    if (!AgentClass) {
+        const { Agent } = await Promise.resolve().then(() => __importStar(require('../agent/simple')));
+        AgentClass = Agent;
+    }
+    return AgentClass;
+}
+class PlanningAgent {
+    constructor(config = {}) {
+        this.agent = null;
+        this.currentPlan = null;
+        this.config = {
+            instructions: config.instructions || 'You are a planning agent that breaks down complex tasks into steps.',
+            name: config.name || 'PlanningAgent',
+            llm: config.llm,
+            verbose: config.verbose ?? true,
+            maxSteps: config.maxSteps ?? 10
+        };
+    }
+    async getAgent() {
+        if (!this.agent) {
+            const Agent = await getAgentClass();
+            this.agent = new Agent({
+                name: this.config.name,
+                instructions: this.config.instructions,
+                llm: this.config.llm,
+                verbose: this.config.verbose
+            });
+        }
+        return this.agent;
+    }
+    /**
+     * Create a plan for a task
+     */
+    async createPlan(task) {
+        const agent = await this.getAgent();
+        const planPrompt = `Create a step-by-step plan for: ${task}
+
+Return ONLY a numbered list of steps, one per line. Example:
+1. First step
+2. Second step
+3. Third step`;
+        const response = await agent.chat(planPrompt);
+        // Parse the response into steps
+        const plan = new Plan({ name: task });
+        const lines = response.split('\n').filter((l) => l.trim());
+        for (const line of lines) {
+            // Extract step description (remove numbering)
+            const match = line.match(/^\d+[\.\)]\s*(.+)/);
+            if (match) {
+                plan.addStep(new PlanStep({ description: match[1].trim() }));
+            }
+        }
+        this.currentPlan = plan;
+        return plan;
+    }
+    /**
+     * Execute a single step
+     */
+    async executeStep(step) {
+        const agent = await this.getAgent();
+        step.start();
+        try {
+            const response = await agent.chat(`Execute this step: ${step.description}`);
+            step.complete();
+            return response;
+        }
+        catch (error) {
+            step.fail();
+            throw error;
+        }
+    }
+    /**
+     * Plan and execute a task in one call
+     */
+    async planAndExecute(task) {
+        const plan = await this.createPlan(task);
+        const results = [];
+        let success = true;
+        plan.start();
+        for (const step of plan.steps.slice(0, this.config.maxSteps)) {
+            try {
+                if (this.config.verbose) {
+                    console.log(`[${plan.getProgress().percentage}%] Executing: ${step.description}`);
+                }
+                const result = await this.executeStep(step);
+                results.push(result);
+            }
+            catch (error) {
+                success = false;
+                results.push(`Error: ${error}`);
+                break;
+            }
+        }
+        if (success) {
+            plan.complete();
+        }
+        return { plan, results, success };
+    }
+    /**
+     * Get the current plan
+     */
+    getPlan() {
+        return this.currentPlan;
+    }
+    /**
+     * Simple chat (without planning)
+     */
+    async chat(message) {
+        const agent = await this.getAgent();
+        return agent.chat(message);
+    }
+}
+exports.PlanningAgent = PlanningAgent;
+/**
+ * Create a planning agent
+ */
+function createPlanningAgent(config) {
+    return new PlanningAgent(config);
+}
+/**
+ * TaskAgent - Agent with built-in todo list management
+ *
+ * @example Simple usage (4 lines)
+ * ```typescript
+ * import { TaskAgent } from 'praisonai';
+ *
+ * const agent = new TaskAgent();
+ * await agent.addTask('Fix critical bug', 'high');
+ * await agent.addTask('Write docs', 'medium');
+ * console.log(agent.getPendingTasks());
+ * ```
+ */
+class TaskAgent {
+    constructor(config) {
+        this.agent = null;
+        this.todos = new TodoList('Agent Tasks');
+        this.config = config || {};
+    }
+    async getAgent() {
+        if (!this.agent) {
+            const Agent = await getAgentClass();
+            this.agent = new Agent({
+                name: this.config.name || 'TaskAgent',
+                instructions: 'You are a task management assistant.',
+                llm: this.config.llm,
+                verbose: this.config.verbose ?? false
+            });
+        }
+        return this.agent;
+    }
+    /**
+     * Add a task
+     */
+    addTask(content, priority = 'medium') {
+        const item = new TodoItem({ content, priority });
+        this.todos.add(item);
+        return item;
+    }
+    /**
+     * Complete a task by content (partial match)
+     */
+    completeTask(contentMatch) {
+        const item = this.todos.items.find(t => t.content.toLowerCase().includes(contentMatch.toLowerCase()) && t.status !== 'completed');
+        if (item) {
+            item.complete();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get pending tasks
+     */
+    getPendingTasks() {
+        return this.todos.getPending();
+    }
+    /**
+     * Get all tasks
+     */
+    getAllTasks() {
+        return [...this.todos.items];
+    }
+    /**
+     * Get progress
+     */
+    getProgress() {
+        return this.todos.getProgress();
+    }
+    /**
+     * Clear all tasks
+     */
+    clearTasks() {
+        this.todos.clear();
+    }
+    /**
+     * Chat with AI about tasks
+     */
+    async chat(message) {
+        const agent = await this.getAgent();
+        const context = `Current tasks:\n${this.todos.items.map(t => `- [${t.status}] ${t.content} (${t.priority})`).join('\n') || 'No tasks'}`;
+        return agent.chat(`${context}\n\nUser: ${message}`);
+    }
+}
+exports.TaskAgent = TaskAgent;
+/**
+ * Create a task agent
+ */
+function createTaskAgent(config) {
+    return new TaskAgent(config);
+}

package/dist/process/index.d.ts

@@ -0,0 +1,25 @@
+export interface ProcessConfig {
+    maxRetries?: number;
+    timeout?: number;
+    metadata?: Record<string, any>;
+}
+export interface Process {
+    id: string;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    config: ProcessConfig;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getStatus(): string;
+    getResult(): any;
+}
+export declare class BaseProcess implements Process {
+    id: string;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    config: ProcessConfig;
+    private result;
+    constructor(id: string, config?: ProcessConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getStatus(): string;
+    getResult(): any;
+}

package/dist/process/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseProcess = void 0;
+class BaseProcess {
+    constructor(id, config = {}) {
+        this.id = id;
+        this.status = 'pending';
+        this.config = {
+            maxRetries: 3,
+            timeout: 30000,
+            ...config
+        };
+    }
+    async start() {
+        this.status = 'running';
+        try {
+            // Implement process logic here
+            this.status = 'completed';
+        }
+        catch (error) {
+            this.status = 'failed';
+            throw error;
+        }
+    }
+    async stop() {
+        if (this.status === 'running') {
+            this.status = 'failed';
+        }
+    }
+    getStatus() {
+        return this.status;
+    }
+    getResult() {
+        return this.result;
+    }
+}
+exports.BaseProcess = BaseProcess;

package/dist/process/process.js

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

package/dist/session/index.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Session Management - Session, Run, and Trace tracking
+ */
+export interface SessionConfig {
+    id?: string;
+    metadata?: Record<string, any>;
+}
+export interface RunConfig {
+    id?: string;
+    metadata?: Record<string, any>;
+}
+export interface TraceConfig {
+    id?: string;
+    name: string;
+    attributes?: Record<string, any>;
+}
+export type RunStatus = 'pending' | 'running' | 'completed' | 'failed';
+export type TraceStatus = 'pending' | 'running' | 'completed' | 'failed';
+export interface Message {
+    id: string;
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | null;
+    name?: string;
+    tool_call_id?: string;
+    tool_calls?: any[];
+    timestamp: number;
+    runId?: string;
+}
+/**
+ * Trace represents a span within a run (e.g., LLM call, tool call)
+ */
+export declare class Trace {
+    readonly id: string;
+    readonly runId: string;
+    readonly name: string;
+    readonly parentId: string | null;
+    readonly startTime: number;
+    endTime: number | null;
+    status: TraceStatus;
+    attributes: Record<string, any>;
+    private children;
+    constructor(runId: string, config: TraceConfig, parentId?: string | null);
+    start(): this;
+    complete(attributes?: Record<string, any>): this;
+    fail(error?: Error): this;
+    get duration(): number | null;
+    createChild(config: TraceConfig): Trace;
+    getChildren(): Trace[];
+    toJSON(): Record<string, any>;
+}
+/**
+ * Run represents a single execution within a session (e.g., one chat call)
+ */
+export declare class Run {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly startTime: number;
+    endTime: number | null;
+    status: RunStatus;
+    error: Error | null;
+    metadata: Record<string, any>;
+    private traces;
+    private messages;
+    constructor(sessionId: string, config?: RunConfig);
+    start(): this;
+    complete(metadata?: Record<string, any>): this;
+    fail(error: Error): this;
+    get duration(): number | null;
+    createTrace(config: TraceConfig): Trace;
+    addMessage(message: Omit<Message, 'id' | 'timestamp' | 'runId'>): Message;
+    getTraces(): Trace[];
+    getMessages(): Message[];
+    toJSON(): Record<string, any>;
+}
+/**
+ * Session represents a conversation session with message history
+ */
+export declare class Session {
+    readonly id: string;
+    readonly createdAt: number;
+    metadata: Record<string, any>;
+    private _runs;
+    private _messages;
+    constructor(config?: SessionConfig);
+    createRun(config?: RunConfig): Run;
+    get runs(): Run[];
+    get messages(): Message[];
+    addMessage(message: Omit<Message, 'id' | 'timestamp'>): Message;
+    getMessagesForLLM(): Array<{
+        role: string;
+        content: string | null;
+        tool_call_id?: string;
+        tool_calls?: any[];
+    }>;
+    clearMessages(): void;
+    toJSON(): Record<string, any>;
+}
+/**
+ * SessionManager for managing multiple sessions
+ */
+export declare class SessionManager {
+    private sessions;
+    create(config?: SessionConfig): Session;
+    get(id: string): Session | undefined;
+    getOrCreate(id: string, config?: Omit<SessionConfig, 'id'>): Session;
+    list(): Session[];
+    delete(id: string): boolean;
+    clear(): void;
+    toJSON(): Record<string, any>;
+}
+export declare function getSessionManager(): SessionManager;