praisonai 1.2.3 → 1.3.0

package/dist/agent/index.d.ts

@@ -1,6 +1,16 @@
+/**
+ * Agent Module - Core agent classes for PraisonAI
+ *
+ * The primary exports are:
+ * - Agent: Single agent with instructions, tools, and optional persistence
+ * - Agents: Multi-agent orchestration (alias for PraisonAIAgents)
+ * - Workflow: Step-based workflow execution (from workflows module)
+ */
+export { Agent, PraisonAIAgents, Agents } from './simple';
+export type { SimpleAgentConfig, PraisonAIAgentsConfig } from './simple';
+export { Task } from './types';
+export type { TaskConfig, AgentConfig as TaskAgentConfig } from './types';
+/**
+ * @deprecated Task mode is no longer needed. Use Agent with role/goal/backstory instead.
+ */
 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, SimpleAgentConfig } from './simple';

package/dist/agent/index.js

@@ -1,13 +1,31 @@
 "use strict";
+/**
+ * Agent Module - Core agent classes for PraisonAI
+ *
+ * The primary exports are:
+ * - Agent: Single agent with instructions, tools, and optional persistence
+ * - Agents: Multi-agent orchestration (alias for PraisonAIAgents)
+ * - Workflow: Step-based workflow execution (from workflows module)
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Task = exports.PraisonAIAgents = exports.Agent = void 0;
+exports.Task = exports.Agents = exports.PraisonAIAgents = exports.Agent = void 0;
 exports.setTaskMode = setTaskMode;
-// Export implementation based on mode
+// Core exports - the main API surface
+var simple_1 = require("./simple");
+Object.defineProperty(exports, "Agent", { enumerable: true, get: function () { return simple_1.Agent; } });
+Object.defineProperty(exports, "PraisonAIAgents", { enumerable: true, get: function () { return simple_1.PraisonAIAgents; } });
+Object.defineProperty(exports, "Agents", { enumerable: true, get: function () { return simple_1.Agents; } });
+// Task support (for advanced use cases)
+var types_1 = require("./types");
+Object.defineProperty(exports, "Task", { enumerable: true, get: function () { return types_1.Task; } });
+// Legacy compatibility - setTaskMode is deprecated but kept for backward compat
 let useTaskMode = false;
+/**
+ * @deprecated Task mode is no longer needed. Use Agent with role/goal/backstory instead.
+ */
 function setTaskMode(enabled) {
+    if (enabled) {
+        console.warn('setTaskMode() is deprecated. Use Agent({ role, goal, backstory }) instead of task mode.');
+    }
     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/simple.d.ts

@@ -1,13 +1,77 @@
+import type { DbAdapter } from '../db/types';
+/**
+ * Agent Configuration
+ *
+ * The Agent class is the primary entry point for PraisonAI.
+ * It supports both simple instruction-based agents and advanced configurations.
+ *
+ * @example Simple usage (3 lines)
+ * ```typescript
+ * import { Agent } from 'praisonai';
+ * const agent = new Agent({ instructions: "You are helpful" });
+ * await agent.chat("Hello!");
+ * ```
+ *
+ * @example With tools (5 lines)
+ * ```typescript
+ * const getWeather = (city: string) => `Weather in ${city}: 20°C`;
+ * const agent = new Agent({
+ *   instructions: "You provide weather info",
+ *   tools: [getWeather]
+ * });
+ * await agent.chat("Weather in Paris?");
+ * ```
+ *
+ * @example With persistence (4 lines)
+ * ```typescript
+ * import { Agent, db } from 'praisonai';
+ * const agent = new Agent({
+ *   instructions: "You are helpful",
+ *   db: db("sqlite:./data.db"),
+ *   sessionId: "my-session"
+ * });
+ * await agent.chat("Hello!");
+ * ```
+ */
 export interface SimpleAgentConfig {
+    /** Agent instructions/system prompt (required) */
     instructions: string;
+    /** Agent name (auto-generated if not provided) */
     name?: string;
+    /** Enable verbose logging (default: true) */
     verbose?: boolean;
+    /** Enable pretty output formatting */
     pretty?: boolean;
+    /**
+     * LLM model to use. Accepts:
+     * - Model name: "gpt-4o-mini", "claude-3-sonnet"
+     * - Provider/model: "openai/gpt-4o", "anthropic/claude-3"
+     * Default: "gpt-4o-mini"
+     */
     llm?: string;
+    /** Enable markdown formatting in responses */
     markdown?: boolean;
+    /** Enable streaming responses (default: true) */
     stream?: boolean;
+    /**
+     * Tools available to the agent.
+     * Can be plain functions (auto-schema) or OpenAI tool definitions.
+     */
     tools?: any[] | Function[];
+    /** Map of tool function implementations */
     toolFunctions?: Record<string, Function>;
+    /** Database adapter for persistence */
+    db?: DbAdapter;
+    /** Session ID for conversation persistence */
+    sessionId?: string;
+    /** Run ID for tracing (auto-generated if not provided) */
+    runId?: string;
+    /** Agent role (advanced mode) */
+    role?: string;
+    /** Agent goal (advanced mode) */
+    goal?: string;
+    /** Agent backstory (advanced mode) */
+    backstory?: string;
 }
 export declare class Agent {
     private instructions;
@@ -20,6 +84,10 @@ export declare class Agent {
     private llmService;
     private tools?;
     private toolFunctions;
+    private dbAdapter?;
+    private sessionId;
+    private runId;
+    private messages;
     constructor(config: SimpleAgentConfig);
     private createSystemPrompt;
     /**
@@ -49,9 +117,24 @@ export declare class Agent {
     start(prompt: string, previousResult?: string): Promise<string>;
     chat(prompt: string, previousResult?: string): Promise<string>;
     execute(previousResult?: string): Promise<string>;
+    /**
+     * Persist a message to the database
+     */
+    private persistMessage;
+    /**
+     * Get the session ID for this agent
+     */
+    getSessionId(): string;
+    /**
+     * Get the run ID for this agent
+     */
+    getRunId(): string;
     getResult(): string | null;
     getInstructions(): string;
 }
+/**
+ * Configuration for multi-agent orchestration
+ */
 export interface PraisonAIAgentsConfig {
     agents: Agent[];
     tasks?: string[];
@@ -59,15 +142,59 @@ export interface PraisonAIAgentsConfig {
     pretty?: boolean;
     process?: 'sequential' | 'parallel';
 }
+/**
+ * Multi-agent orchestration class
+ *
+ * @example Simple array syntax
+ * ```typescript
+ * import { Agent, Agents } from 'praisonai';
+ *
+ * const researcher = new Agent({ instructions: "Research the topic" });
+ * const writer = new Agent({ instructions: "Write based on research" });
+ *
+ * const agents = new Agents([researcher, writer]);
+ * await agents.start();
+ * ```
+ *
+ * @example Config object syntax
+ * ```typescript
+ * const agents = new Agents({
+ *   agents: [researcher, writer],
+ *   process: 'parallel'
+ * });
+ * ```
+ */
 export declare class PraisonAIAgents {
     private agents;
     private tasks;
     private verbose;
     private pretty;
     private process;
-    constructor(config: PraisonAIAgentsConfig);
+    /**
+     * Create a multi-agent orchestration
+     * @param configOrAgents - Either an array of agents or a config object
+     */
+    constructor(configOrAgents: PraisonAIAgentsConfig | Agent[]);
     private generateTasks;
     private executeSequential;
     start(): Promise<string[]>;
     chat(): Promise<string[]>;
 }
+/**
+ * Agents - Alias for PraisonAIAgents
+ *
+ * This is the recommended class name for multi-agent orchestration.
+ * PraisonAIAgents is kept for backward compatibility.
+ *
+ * @example
+ * ```typescript
+ * import { Agent, Agents } from 'praisonai';
+ *
+ * const agents = new Agents([
+ *   new Agent({ instructions: "Research the topic" }),
+ *   new Agent({ instructions: "Write based on research" })
+ * ]);
+ * await agents.start();
+ * ```
+ */
+export declare const Agents: typeof PraisonAIAgents;

package/dist/agent/simple.js

@@ -1,19 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PraisonAIAgents = exports.Agent = void 0;
+exports.Agents = exports.PraisonAIAgents = exports.Agent = void 0;
 const openai_1 = require("../llm/openai");
 const logger_1 = require("../utils/logger");
+const crypto_1 = require("crypto");
 class Agent {
     constructor(config) {
         this.toolFunctions = {};
-        this.instructions = config.instructions;
+        this.messages = [];
+        // Build instructions from either simple or advanced mode
+        if (config.instructions) {
+            this.instructions = config.instructions;
+        }
+        else if (config.role || config.goal || config.backstory) {
+            // Advanced mode: construct instructions from role/goal/backstory
+            const parts = [];
+            if (config.role)
+                parts.push(`You are a ${config.role}.`);
+            if (config.goal)
+                parts.push(`Your goal is: ${config.goal}`);
+            if (config.backstory)
+                parts.push(`Background: ${config.backstory}`);
+            this.instructions = parts.join('\n');
+        }
+        else {
+            this.instructions = 'You are a helpful AI assistant.';
+        }
         this.name = config.name || `Agent_${Math.random().toString(36).substr(2, 9)}`;
         this.verbose = config.verbose ?? process.env.PRAISON_VERBOSE !== 'false';
         this.pretty = config.pretty ?? process.env.PRAISON_PRETTY === 'true';
-        this.llm = config.llm || 'gpt-4o-mini';
+        this.llm = config.llm || process.env.OPENAI_MODEL_NAME || process.env.PRAISONAI_MODEL || 'gpt-4o-mini';
         this.markdown = config.markdown ?? true;
         this.stream = config.stream ?? true;
         this.tools = config.tools;
+        this.dbAdapter = config.db;
+        this.sessionId = config.sessionId || (0, crypto_1.randomUUID)();
+        this.runId = config.runId || (0, crypto_1.randomUUID)();
         this.llmService = new openai_1.OpenAIService(this.llm);
         // Configure logging
         logger_1.Logger.setVerbose(this.verbose);
@@ -250,12 +272,54 @@ class Agent {
         }
     }
     async chat(prompt, previousResult) {
-        return this.start(prompt, previousResult);
+        // Persist user message if db is configured
+        if (this.dbAdapter) {
+            await this.persistMessage('user', prompt);
+        }
+        const response = await this.start(prompt, previousResult);
+        // Persist assistant response if db is configured
+        if (this.dbAdapter) {
+            await this.persistMessage('assistant', response);
+        }
+        return response;
     }
     async execute(previousResult) {
         // For backward compatibility and multi-agent support
         return this.start(this.instructions, previousResult);
     }
+    /**
+     * Persist a message to the database
+     */
+    async persistMessage(role, content) {
+        if (!this.dbAdapter)
+            return;
+        try {
+            const message = {
+                id: (0, crypto_1.randomUUID)(),
+                sessionId: this.sessionId,
+                runId: this.runId,
+                role,
+                content,
+                createdAt: Date.now()
+            };
+            await this.dbAdapter.saveMessage(message);
+        }
+        catch (error) {
+            await logger_1.Logger.warn('Failed to persist message:', error);
+        }
+    }
+    /**
+     * Get the session ID for this agent
+     */
+    getSessionId() {
+        return this.sessionId;
+    }
+    /**
+     * Get the run ID for this agent
+     */
+    getRunId() {
+        return this.runId;
+    }
     getResult() {
         return null;
     }
@@ -264,8 +328,38 @@ class Agent {
     }
 }
 exports.Agent = Agent;
+/**
+ * Multi-agent orchestration class
+ *
+ * @example Simple array syntax
+ * ```typescript
+ * import { Agent, Agents } from 'praisonai';
+ *
+ * const researcher = new Agent({ instructions: "Research the topic" });
+ * const writer = new Agent({ instructions: "Write based on research" });
+ *
+ * const agents = new Agents([researcher, writer]);
+ * await agents.start();
+ * ```
+ *
+ * @example Config object syntax
+ * ```typescript
+ * const agents = new Agents({
+ *   agents: [researcher, writer],
+ *   process: 'parallel'
+ * });
+ * ```
+ */
 class PraisonAIAgents {
-    constructor(config) {
+    /**
+     * Create a multi-agent orchestration
+     * @param configOrAgents - Either an array of agents or a config object
+     */
+    constructor(configOrAgents) {
+        // Support array syntax: new Agents([a1, a2])
+        const config = Array.isArray(configOrAgents)
+            ? { agents: configOrAgents }
+            : configOrAgents;
         this.agents = config.agents;
         this.verbose = config.verbose ?? process.env.PRAISON_VERBOSE !== 'false';
         this.pretty = config.pretty ?? process.env.PRAISON_PRETTY === 'true';
@@ -331,3 +425,21 @@ class PraisonAIAgents {
     }
 }
 exports.PraisonAIAgents = PraisonAIAgents;
+/**
+ * Agents - Alias for PraisonAIAgents
+ *
+ * This is the recommended class name for multi-agent orchestration.
+ * PraisonAIAgents is kept for backward compatibility.
+ *
+ * @example
+ * ```typescript
+ * import { Agent, Agents } from 'praisonai';
+ *
+ * const agents = new Agents([
+ *   new Agent({ instructions: "Research the topic" }),
+ *   new Agent({ instructions: "Write based on research" })
+ * ]);
+ * await agents.start();
+ * ```
+ */
+exports.Agents = PraisonAIAgents;

package/dist/cli/commands/agent.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Agent command - Run a single agent with instructions
+ *
+ * Usage:
+ *   praisonai-ts agent chat "Hello, how are you?"
+ *   praisonai-ts agent run --instructions "You are helpful" "Tell me a joke"
+ */
+export interface AgentOptions {
+    instructions?: string;
+    model?: string;
+    stream?: boolean;
+    verbose?: boolean;
+    profile?: string;
+    config?: string;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+    sessionId?: string;
+}
+/**
+ * Execute agent chat subcommand
+ */
+export declare function executeChat(args: string[], options: AgentOptions): Promise<void>;
+/**
+ * Execute agent run subcommand (same as chat but requires instructions)
+ */
+export declare function executeRun(args: string[], options: AgentOptions): Promise<void>;
+/**
+ * Main execute function - routes to subcommands
+ */
+export declare function execute(args: string[], options: AgentOptions): Promise<void>;

package/dist/cli/commands/agent.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * Agent command - Run a single agent with instructions
+ *
+ * Usage:
+ *   praisonai-ts agent chat "Hello, how are you?"
+ *   praisonai-ts agent run --instructions "You are helpful" "Tell me a joke"
+ */
+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.executeChat = executeChat;
+exports.executeRun = executeRun;
+exports.execute = execute;
+const agent_1 = require("../../agent");
+const resolve_1 = require("../config/resolve");
+const json_1 = require("../output/json");
+const pretty = __importStar(require("../output/pretty"));
+const cli_spec_1 = require("../spec/cli-spec");
+const errors_1 = require("../output/errors");
+/**
+ * Execute agent chat subcommand
+ */
+async function executeChat(args, options) {
+    const prompt = args[0];
+    if (!prompt) {
+        if (options.json || options.output === 'json') {
+            (0, json_1.printError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide a prompt');
+        }
+        else {
+            await pretty.error('Please provide a prompt');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    const config = (0, resolve_1.resolveConfig)({
+        configPath: options.config,
+        profile: options.profile,
+        model: options.model,
+        verbose: options.verbose,
+        stream: options.stream
+    });
+    const startTime = Date.now();
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    try {
+        const agent = new agent_1.Agent({
+            instructions: options.instructions || 'You are a helpful AI assistant.',
+            llm: config.model,
+            stream: config.stream && outputFormat !== 'json',
+            verbose: config.verbose,
+            sessionId: options.sessionId
+        });
+        const response = await agent.chat(prompt);
+        const duration = Date.now() - startTime;
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatSuccess)({
+                response,
+                agent: agent.name,
+                sessionId: agent.getSessionId()
+            }, {
+                duration_ms: duration,
+                model: config.model
+            }));
+        }
+        else if (outputFormat === 'text') {
+            console.log(response);
+        }
+        else {
+            // Pretty output - response already printed if streaming
+            if (!config.stream) {
+                console.log(response);
+            }
+            console.log(); // Newline
+            await pretty.dim(`Completed in ${duration}ms`);
+        }
+    }
+    catch (error) {
+        const cliError = (0, errors_1.normalizeError)(error);
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(cliError.code, cliError.message, cliError.details));
+        }
+        else {
+            await pretty.error(cliError.message);
+            if (config.verbose && error instanceof Error && error.stack) {
+                await pretty.dim(error.stack);
+            }
+        }
+        process.exit(cliError.exitCode);
+    }
+}
+/**
+ * Execute agent run subcommand (same as chat but requires instructions)
+ */
+async function executeRun(args, options) {
+    if (!options.instructions) {
+        if (options.json || options.output === 'json') {
+            (0, json_1.printError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide --instructions');
+        }
+        else {
+            await pretty.error('Please provide --instructions');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    return executeChat(args, options);
+}
+/**
+ * Main execute function - routes to subcommands
+ */
+async function execute(args, options) {
+    const subcommand = args[0];
+    const subArgs = args.slice(1);
+    switch (subcommand) {
+        case 'chat':
+            return executeChat(subArgs, options);
+        case 'run':
+            return executeRun(subArgs, options);
+        default:
+            // If no subcommand, treat the first arg as a prompt for chat
+            if (subcommand) {
+                return executeChat(args, options);
+            }
+            if (options.json || options.output === 'json') {
+                (0, json_1.printError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide a subcommand (chat, run) or a prompt');
+            }
+            else {
+                await pretty.error('Usage: praisonai-ts agent [chat|run] <prompt>');
+                await pretty.info('  agent chat "Hello"           - Chat with default agent');
+                await pretty.info('  agent run --instructions "..." "Hello" - Run with custom instructions');
+            }
+            process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+}

package/dist/cli/commands/agents.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Agents command - Run multi-agent orchestration
+ *
+ * Usage:
+ *   praisonai-ts agents run --agents "researcher,writer" "Research AI trends"
+ */
+export interface AgentsOptions {
+    agents?: string;
+    process?: 'sequential' | 'parallel';
+    model?: string;
+    verbose?: boolean;
+    profile?: string;
+    config?: string;
+    output?: 'json' | 'text' | 'pretty';
+    json?: boolean;
+}
+/**
+ * Execute agents run subcommand
+ */
+export declare function executeRun(args: string[], options: AgentsOptions): Promise<void>;
+/**
+ * Main execute function - routes to subcommands
+ */
+export declare function execute(args: string[], options: AgentsOptions): Promise<void>;

package/dist/cli/commands/agents.js

@@ -0,0 +1,177 @@
+"use strict";
+/**
+ * Agents command - Run multi-agent orchestration
+ *
+ * Usage:
+ *   praisonai-ts agents run --agents "researcher,writer" "Research AI trends"
+ */
+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.executeRun = executeRun;
+exports.execute = execute;
+const agent_1 = require("../../agent");
+const resolve_1 = require("../config/resolve");
+const json_1 = require("../output/json");
+const pretty = __importStar(require("../output/pretty"));
+const cli_spec_1 = require("../spec/cli-spec");
+const errors_1 = require("../output/errors");
+/**
+ * Parse agent definitions from comma-separated string
+ */
+function parseAgentDefinitions(agentsStr) {
+    return agentsStr.split(',').map(s => s.trim()).filter(s => s.length > 0);
+}
+/**
+ * Execute agents run subcommand
+ */
+async function executeRun(args, options) {
+    const prompt = args[0];
+    if (!prompt) {
+        if (options.json || options.output === 'json') {
+            (0, json_1.printError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide a prompt/task');
+        }
+        else {
+            await pretty.error('Please provide a prompt/task');
+        }
+        process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    const config = (0, resolve_1.resolveConfig)({
+        configPath: options.config,
+        profile: options.profile,
+        model: options.model,
+        verbose: options.verbose
+    });
+    const startTime = Date.now();
+    const outputFormat = options.json ? 'json' : (options.output || 'pretty');
+    try {
+        // Create agents from definitions or use defaults
+        let agentList;
+        if (options.agents) {
+            const definitions = parseAgentDefinitions(options.agents);
+            agentList = definitions.map((instructions, i) => new agent_1.Agent({
+                instructions,
+                name: `Agent_${i + 1}`,
+                llm: config.model,
+                verbose: config.verbose
+            }));
+        }
+        else {
+            // Default: create a researcher and writer
+            agentList = [
+                new agent_1.Agent({
+                    instructions: `Research the following topic thoroughly: ${prompt}`,
+                    name: 'Researcher',
+                    llm: config.model,
+                    verbose: config.verbose
+                }),
+                new agent_1.Agent({
+                    instructions: 'Summarize and write a clear report based on the research provided.',
+                    name: 'Writer',
+                    llm: config.model,
+                    verbose: config.verbose
+                })
+            ];
+        }
+        if (outputFormat !== 'json') {
+            await pretty.heading(`Running ${agentList.length} agents (${options.process || 'sequential'})`);
+        }
+        const agents = new agent_1.Agents({
+            agents: agentList,
+            process: options.process || 'sequential',
+            verbose: config.verbose
+        });
+        const results = await agents.start();
+        const duration = Date.now() - startTime;
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatSuccess)({
+                results,
+                agentCount: agentList.length,
+                process: options.process || 'sequential'
+            }, {
+                duration_ms: duration,
+                model: config.model
+            }));
+        }
+        else if (outputFormat === 'text') {
+            results.forEach((result, i) => {
+                console.log(`\n--- Agent ${i + 1} ---\n${result}`);
+            });
+        }
+        else {
+            // Pretty output
+            console.log();
+            await pretty.success(`Completed ${agentList.length} agents in ${duration}ms`);
+        }
+    }
+    catch (error) {
+        const cliError = (0, errors_1.normalizeError)(error);
+        if (outputFormat === 'json') {
+            (0, json_1.outputJson)((0, json_1.formatError)(cliError.code, cliError.message, cliError.details));
+        }
+        else {
+            await pretty.error(cliError.message);
+            if (config.verbose && error instanceof Error && error.stack) {
+                await pretty.dim(error.stack);
+            }
+        }
+        process.exit(cliError.exitCode);
+    }
+}
+/**
+ * Main execute function - routes to subcommands
+ */
+async function execute(args, options) {
+    const subcommand = args[0];
+    const subArgs = args.slice(1);
+    switch (subcommand) {
+        case 'run':
+            return executeRun(subArgs, options);
+        default:
+            // If no subcommand, treat as run
+            if (subcommand) {
+                return executeRun(args, options);
+            }
+            if (options.json || options.output === 'json') {
+                (0, json_1.printError)(errors_1.ERROR_CODES.MISSING_ARG, 'Please provide a task/prompt');
+            }
+            else {
+                await pretty.error('Usage: praisonai-ts agents [run] <task>');
+                await pretty.info('  agents run "Research AI"     - Run with default agents');
+                await pretty.info('  agents run --agents "..." "Research AI" - Run with custom agents');
+                await pretty.info('  agents run --process parallel "Research AI" - Run in parallel');
+            }
+            process.exit(cli_spec_1.EXIT_CODES.INVALID_ARGUMENTS);
+    }
+}

package/dist/db/index.d.ts

@@ -1,5 +1,14 @@
 /**
  * Database Module - Exports for persistence layer
+ *
+ * Usage (Python-like simplicity):
+ *   import { db } from 'praisonai';
+ *
+ *   const agent = new Agent({
+ *     instructions: "You are helpful",
+ *     db: db("sqlite:./data.db"),  // URL-style string
+ *     sessionId: "my-session"
+ *   });
  */
 export * from './types';
 export { MemoryDbAdapter } from './memory-adapter';
@@ -17,7 +26,17 @@ export declare function getDefaultDbAdapter(): DbAdapter;
  */
 export declare function setDefaultDbAdapter(adapter: DbAdapter): void;
 /**
- * Shortcut function for creating a database adapter
- * Usage: db({ type: 'memory' }) or db({ type: 'sqlite', path: './data.db' })
+ * Factory function for creating a database adapter
+ *
+ * Accepts either:
+ * - URL string: db("sqlite:./data.db"), db("postgres://..."), db("redis://...")
+ * - Config object: db({ type: 'sqlite', path: './data.db' })
+ *
+ * Examples:
+ *   db("sqlite:./data.db")           // SQLite file
+ *   db("postgres://localhost/mydb")  // PostgreSQL
+ *   db("redis://localhost:6379")     // Redis
+ *   db("memory:")                    // In-memory (default)
+ *   db()                             // In-memory (default)
  */
-export declare function db(config?: DbConfig): DbAdapter;
+export declare function db(configOrUrl?: string | DbConfig): DbAdapter;

package/dist/db/index.js

@@ -1,6 +1,15 @@
 "use strict";
 /**
  * Database Module - Exports for persistence layer
+ *
+ * Usage (Python-like simplicity):
+ *   import { db } from 'praisonai';
+ *
+ *   const agent = new Agent({
+ *     instructions: "You are helpful",
+ *     db: db("sqlite:./data.db"),  // URL-style string
+ *     sessionId: "my-session"
+ *   });
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -28,6 +37,51 @@ Object.defineProperty(exports, "MemoryDbAdapter", { enumerable: true, get: funct
 const memory_adapter_2 = require("./memory-adapter");
 // Default adapter instance
 let defaultAdapter = null;
+/**
+ * Parse a database URL string into a DbConfig
+ * Supports: sqlite:./path, postgres://..., redis://..., memory:
+ */
+function parseDbUrl(url) {
+    // Handle memory shorthand
+    if (url === 'memory' || url === 'memory:' || url === ':memory:') {
+        return { type: 'memory' };
+    }
+    // Handle sqlite: prefix
+    if (url.startsWith('sqlite:')) {
+        const path = url.slice(7); // Remove 'sqlite:'
+        return { type: 'sqlite', path: path || ':memory:' };
+    }
+    // Handle postgres:// or postgresql://
+    if (url.startsWith('postgres://') || url.startsWith('postgresql://')) {
+        return { type: 'postgres', connectionString: url };
+    }
+    // Handle neon:// (Neon Postgres)
+    if (url.startsWith('neon://')) {
+        // Convert neon:// to postgres:// for compatibility
+        const connectionString = url.replace('neon://', 'postgres://');
+        return { type: 'postgres', connectionString };
+    }
+    // Handle redis:// or rediss://
+    if (url.startsWith('redis://') || url.startsWith('rediss://')) {
+        return { type: 'redis', connectionString: url };
+    }
+    // Handle upstash:// (Upstash Redis)
+    if (url.startsWith('upstash://')) {
+        // Convert upstash:// to rediss:// for compatibility
+        const connectionString = url.replace('upstash://', 'rediss://');
+        return { type: 'redis', connectionString };
+    }
+    // Default: treat as file path for sqlite
+    if (url.endsWith('.db') || url.endsWith('.sqlite') || url.endsWith('.sqlite3')) {
+        return { type: 'sqlite', path: url };
+    }
+    throw new Error(`Invalid database URL: ${url}\n` +
+        `Supported formats:\n` +
+        `  - sqlite:./data.db\n` +
+        `  - postgres://user:pass@host:port/db\n` +
+        `  - redis://host:port\n` +
+        `  - memory:`);
+}
 /**
  * Create a database adapter based on configuration
  */
@@ -35,15 +89,21 @@ function createDbAdapter(config) {
     switch (config.type) {
         case 'memory':
             return new memory_adapter_2.MemoryDbAdapter();
-        case 'sqlite':
-            // SQLite adapter would be implemented here
-            throw new Error('SQLite adapter not yet implemented. Use memory adapter for now.');
-        case 'postgres':
-            // PostgreSQL adapter would be implemented here
-            throw new Error('PostgreSQL adapter not yet implemented. Use memory adapter for now.');
-        case 'redis':
-            // Redis adapter would be implemented here
-            throw new Error('Redis adapter not yet implemented. Use memory adapter for now.');
+        case 'sqlite': {
+            // Lazy load SQLite adapter
+            const { SQLiteDbAdapter } = require('./sqlite');
+            return new SQLiteDbAdapter(config.path || ':memory:');
+        }
+        case 'postgres': {
+            // Lazy load Postgres adapter
+            const { PostgresDbAdapter } = require('./postgres');
+            return new PostgresDbAdapter(config.connectionString || '');
+        }
+        case 'redis': {
+            // Lazy load Redis adapter
+            const { RedisDbAdapter } = require('./redis');
+            return new RedisDbAdapter(config.connectionString || '');
+        }
         default:
             throw new Error(`Unknown database type: ${config.type}`);
     }
@@ -64,9 +124,23 @@ function setDefaultDbAdapter(adapter) {
     defaultAdapter = adapter;
 }
 /**
- * Shortcut function for creating a database adapter
- * Usage: db({ type: 'memory' }) or db({ type: 'sqlite', path: './data.db' })
+ * Factory function for creating a database adapter
+ *
+ * Accepts either:
+ * - URL string: db("sqlite:./data.db"), db("postgres://..."), db("redis://...")
+ * - Config object: db({ type: 'sqlite', path: './data.db' })
+ *
+ * Examples:
+ *   db("sqlite:./data.db")           // SQLite file
+ *   db("postgres://localhost/mydb")  // PostgreSQL
+ *   db("redis://localhost:6379")     // Redis
+ *   db("memory:")                    // In-memory (default)
+ *   db()                             // In-memory (default)
  */
-function db(config = { type: 'memory' }) {
-    return createDbAdapter(config);
+function db(configOrUrl = { type: 'memory' }) {
+    if (typeof configOrUrl === 'string') {
+        const config = parseDbUrl(configOrUrl);
+        return createDbAdapter(config);
+    }
+    return createDbAdapter(configOrUrl);
 }

package/dist/index.d.ts

@@ -1,24 +1,64 @@
-export * from './agent';
-export * from './knowledge';
-export * from './llm';
-export * from './memory';
-export * from './process';
+/**
+ * PraisonAI TypeScript SDK
+ *
+ * The primary API surface consists of three core classes:
+ * - Agent: Single AI agent with instructions, tools, and optional persistence
+ * - Agents: Multi-agent orchestration (sequential or parallel)
+ * - Workflow: Step-based workflow execution
+ *
+ * @example Quickstart (3 lines)
+ * ```typescript
+ * import { Agent } from 'praisonai';
+ * const agent = new Agent({ instructions: "You are helpful" });
+ * await agent.chat("Hello!");
+ * ```
+ *
+ * @example With tools (5 lines)
+ * ```typescript
+ * const getWeather = (city: string) => `Weather in ${city}: 20°C`;
+ * const agent = new Agent({ instructions: "You provide weather", tools: [getWeather] });
+ * await agent.chat("Weather in Paris?");
+ * ```
+ *
+ * @example With persistence (4 lines)
+ * ```typescript
+ * import { Agent, db } from 'praisonai';
+ * const agent = new Agent({ instructions: "You are helpful", db: db("sqlite:./data.db") });
+ * await agent.chat("Hello!");
+ * ```
+ *
+ * @example Multi-agent (6 lines)
+ * ```typescript
+ * import { Agent, Agents } from 'praisonai';
+ * const researcher = new Agent({ instructions: "Research the topic" });
+ * const writer = new Agent({ instructions: "Write based on research" });
+ * const agents = new Agents([researcher, writer]);
+ * await agents.start();
+ * ```
+ */
+export { Agent, Agents, PraisonAIAgents } from './agent';
+export type { SimpleAgentConfig, PraisonAIAgentsConfig } from './agent';
+export { Workflow, parallel, route, loop, repeat } from './workflows';
+export type { WorkflowStep, WorkflowContext, StepResult } from './workflows';
+export { db, createDbAdapter, getDefaultDbAdapter, setDefaultDbAdapter } from './db';
+export type { DbAdapter, DbConfig, DbMessage, DbRun, DbTrace } from './db';
 export { BaseTool, ToolResult, ToolValidationError, validateTool, createTool, FunctionTool, tool, ToolRegistry, getRegistry, registerTool, getTool, type ToolConfig, type ToolContext, type ToolParameters } from './tools';
 export * from './tools/arxivTools';
 export * from './tools/mcpSse';
 export * from './session';
-export * from './db';
-export * from './workflows';
+export * from './knowledge';
+export * from './llm';
+export * from './process';
 export * from './guardrails';
 export { Handoff, handoff, handoffFilters, type HandoffConfig, type HandoffContext, type HandoffResult } from './agent/handoff';
 export { RouterAgent, createRouter, routeConditions, type RouterConfig, type RouteConfig, type RouteContext } from './agent/router';
 export { ContextAgent, createContextAgent, type ContextAgentConfig, type ContextMessage } from './agent/context';
-export { KnowledgeBase, createKnowledgeBase, type Document, type SearchResult, type EmbeddingProvider, type KnowledgeBaseConfig } from './knowledge/rag';
 export { accuracyEval, performanceEval, reliabilityEval, EvalSuite, type EvalResult, type PerformanceResult, type AccuracyEvalConfig, type PerformanceEvalConfig, type ReliabilityEvalConfig } from './eval';
 export { MemoryObservabilityAdapter, ConsoleObservabilityAdapter, setObservabilityAdapter, getObservabilityAdapter, type ObservabilityAdapter, type TraceContext, type SpanContext, type SpanData, type TraceData } from './observability';
 export { SkillManager, createSkillManager, parseSkillFile, type Skill, type SkillMetadata, type SkillDiscoveryOptions } from './skills';
 export { parseArgs, executeCommand, CLI_SPEC_VERSION } from './cli';
-export { Memory, createMemory, type MemoryEntry, type MemoryConfig, type SearchResult as MemorySearchResult } from './memory/memory';
+export { Memory, createMemory } from './memory/memory';
+export type { MemoryEntry, MemoryConfig } from './memory/memory';
 export { FileMemory, createFileMemory, type FileMemoryConfig, type FileMemoryEntry } from './memory/file-memory';
 export { AutoMemory, createAutoMemory, createLLMSummarizer, DEFAULT_POLICIES, type AutoMemoryConfig, type AutoMemoryPolicy, type AutoMemoryContext, type VectorStoreAdapter as AutoMemoryVectorStore, type KnowledgeBaseAdapter as AutoMemoryKnowledgeBase } from './memory/auto-memory';
 export { TelemetryCollector, getTelemetry, enableTelemetry, disableTelemetry, cleanupTelemetry, type TelemetryEvent, type TelemetryConfig } from './telemetry';
@@ -27,13 +67,12 @@ export { ImageAgent, createImageAgent, type ImageAgentConfig, type ImageGenerati
 export { DeepResearchAgent, createDeepResearchAgent, type DeepResearchConfig, type ResearchResponse, type Citation, type ReasoningStep } from './agent/research';
 export { QueryRewriterAgent, createQueryRewriterAgent, type QueryRewriterConfig, type RewriteResult, type RewriteStrategy } from './agent/query-rewriter';
 export { PromptExpanderAgent, createPromptExpanderAgent, type PromptExpanderConfig, type ExpandResult, type ExpandStrategy } from './agent/prompt-expander';
-export { Chunking, createChunking, type ChunkingConfig, type Chunk, type ChunkStrategy } from './knowledge/chunking';
 export { LLMGuardrail, createLLMGuardrail, type LLMGuardrailConfig, type LLMGuardrailResult } from './guardrails/llm-guardrail';
 export { Plan, PlanStep, TodoList, TodoItem, PlanStorage, createPlan, createTodoList, createPlanStorage, type PlanConfig, type PlanStepConfig, type TodoItemConfig, type PlanStatus, type TodoStatus } from './planning';
 export { BaseCache, MemoryCache, FileCache, createMemoryCache, createFileCache, type CacheConfig, type CacheEntry } from './cache';
 export { PubSub, EventEmitterPubSub, AgentEventBus, AgentEvents, createEventBus, createPubSub, type Event, type EventHandler } from './events';
 export { parseYAMLWorkflow, createWorkflowFromYAML, loadWorkflowFromFile, validateWorkflowDefinition, type YAMLWorkflowDefinition, type YAMLStepDefinition, type ParsedWorkflow } from './workflows/yaml-parser';
-export { SQLiteAdapter, createSQLiteAdapter, type SQLiteConfig, type DbMessage, type DbRun, type DbTrace } from './db/sqlite';
+export { SQLiteAdapter, createSQLiteAdapter, type SQLiteConfig } from './db/sqlite';
 export { UpstashRedisAdapter, MemoryRedisAdapter, createUpstashRedis, createMemoryRedis, type RedisConfig, type RedisAdapter } from './db/redis';
 export { NeonPostgresAdapter, MemoryPostgresAdapter, PostgresSessionStorage, createNeonPostgres, createMemoryPostgres, createPostgresSessionStorage, type PostgresConfig, type PostgresAdapter } from './db/postgres';
 export { BaseVectorStore, MemoryVectorStore, createMemoryVectorStore, PineconeVectorStore, createPineconeStore, WeaviateVectorStore, createWeaviateStore, QdrantVectorStore, createQdrantStore, ChromaVectorStore, createChromaStore, type VectorDocument, type QueryResult as VectorQueryResult, type IndexStats } from './integrations/vector';

package/dist/index.js

@@ -1,4 +1,42 @@
 "use strict";
+/**
+ * PraisonAI TypeScript SDK
+ *
+ * The primary API surface consists of three core classes:
+ * - Agent: Single AI agent with instructions, tools, and optional persistence
+ * - Agents: Multi-agent orchestration (sequential or parallel)
+ * - Workflow: Step-based workflow execution
+ *
+ * @example Quickstart (3 lines)
+ * ```typescript
+ * import { Agent } from 'praisonai';
+ * const agent = new Agent({ instructions: "You are helpful" });
+ * await agent.chat("Hello!");
+ * ```
+ *
+ * @example With tools (5 lines)
+ * ```typescript
+ * const getWeather = (city: string) => `Weather in ${city}: 20°C`;
+ * const agent = new Agent({ instructions: "You provide weather", tools: [getWeather] });
+ * await agent.chat("Weather in Paris?");
+ * ```
+ *
+ * @example With persistence (4 lines)
+ * ```typescript
+ * import { Agent, db } from 'praisonai';
+ * const agent = new Agent({ instructions: "You are helpful", db: db("sqlite:./data.db") });
+ * await agent.chat("Hello!");
+ * ```
+ *
+ * @example Multi-agent (6 lines)
+ * ```typescript
+ * import { Agent, Agents } from 'praisonai';
+ * const researcher = new Agent({ instructions: "Research the topic" });
+ * const writer = new Agent({ instructions: "Write based on research" });
+ * const agents = new Agents([researcher, writer]);
+ * await agents.start();
+ * ```
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -14,18 +52,35 @@ 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 });
-exports.ImageAgent = exports.createAutoAgents = exports.AutoAgents = exports.cleanupTelemetry = exports.disableTelemetry = exports.enableTelemetry = exports.getTelemetry = exports.TelemetryCollector = exports.DEFAULT_POLICIES = exports.createLLMSummarizer = exports.createAutoMemory = exports.AutoMemory = exports.createFileMemory = exports.FileMemory = exports.createMemory = exports.Memory = exports.CLI_SPEC_VERSION = exports.executeCommand = exports.parseArgs = exports.parseSkillFile = exports.createSkillManager = exports.SkillManager = exports.getObservabilityAdapter = exports.setObservabilityAdapter = exports.ConsoleObservabilityAdapter = exports.MemoryObservabilityAdapter = exports.EvalSuite = exports.reliabilityEval = exports.performanceEval = exports.accuracyEval = exports.createKnowledgeBase = exports.KnowledgeBase = exports.createContextAgent = exports.ContextAgent = exports.routeConditions = exports.createRouter = exports.RouterAgent = exports.handoffFilters = exports.handoff = exports.Handoff = exports.getTool = exports.registerTool = exports.getRegistry = exports.ToolRegistry = exports.tool = exports.FunctionTool = exports.createTool = exports.validateTool = exports.ToolValidationError = exports.BaseTool = void 0;
-exports.PineconeVectorStore = exports.createMemoryVectorStore = exports.MemoryVectorStore = exports.BaseVectorStore = exports.createPostgresSessionStorage = exports.createMemoryPostgres = exports.createNeonPostgres = exports.PostgresSessionStorage = exports.MemoryPostgresAdapter = exports.NeonPostgresAdapter = exports.createMemoryRedis = exports.createUpstashRedis = exports.MemoryRedisAdapter = exports.UpstashRedisAdapter = exports.createSQLiteAdapter = exports.SQLiteAdapter = exports.validateWorkflowDefinition = exports.loadWorkflowFromFile = exports.createWorkflowFromYAML = exports.parseYAMLWorkflow = exports.createPubSub = exports.createEventBus = exports.AgentEvents = exports.AgentEventBus = exports.EventEmitterPubSub = exports.PubSub = exports.createFileCache = exports.createMemoryCache = exports.FileCache = exports.MemoryCache = exports.BaseCache = exports.createPlanStorage = exports.createTodoList = exports.createPlan = exports.PlanStorage = exports.TodoItem = exports.TodoList = exports.PlanStep = exports.Plan = exports.createLLMGuardrail = exports.LLMGuardrail = exports.createChunking = exports.Chunking = exports.createPromptExpanderAgent = exports.PromptExpanderAgent = exports.createQueryRewriterAgent = exports.QueryRewriterAgent = exports.createDeepResearchAgent = exports.DeepResearchAgent = exports.createImageAgent = void 0;
-exports.InteractiveTUI = exports.MODEL_PRICING = exports.formatCost = exports.estimateTokens = exports.createCostTracker = exports.CostTracker = exports.isSlashCommand = exports.executeSlashCommand = exports.parseSlashCommand = exports.registerCommand = exports.createSlashCommandHandler = exports.SlashCommandHandler = exports.BaseProvider = exports.GoogleProvider = exports.AnthropicProvider = exports.OpenAIProvider = exports.getAvailableProviders = exports.isProviderAvailable = exports.parseModelString = exports.getDefaultProvider = exports.createProvider = exports.createGraphRAG = exports.GraphRAG = exports.GraphStore = exports.createLLMReranker = exports.createCrossEncoderReranker = exports.createCohereReranker = exports.LLMReranker = exports.CrossEncoderReranker = exports.CohereReranker = exports.BaseReranker = exports.createElevenLabsVoice = exports.createOpenAIVoice = exports.ElevenLabsVoiceProvider = exports.OpenAIVoiceProvider = exports.BaseVoiceProvider = exports.createLangfuseObservability = exports.createMemoryObservability = exports.createConsoleObservability = exports.LangfuseObservabilityProvider = exports.MemoryObservabilityProvider = exports.ConsoleObservabilityProvider = exports.BaseObservabilityProvider = exports.createChromaStore = exports.ChromaVectorStore = exports.createQdrantStore = exports.QdrantVectorStore = exports.createWeaviateStore = exports.WeaviateVectorStore = exports.createPineconeStore = void 0;
-exports.createN8NIntegration = exports.N8NIntegration = exports.externalAgentAsTool = exports.createExternalAgent = exports.getExternalAgentRegistry = exports.GenericExternalAgent = exports.AiderAgent = exports.CodexCliAgent = exports.GeminiCliAgent = exports.ClaudeCodeAgent = exports.BaseExternalAgent = exports.renderWorkflow = exports.createFlowDisplay = exports.FlowDisplay = exports.createFileCheckpointStorage = exports.FileCheckpointStorage = exports.MemoryCheckpointStorage = exports.createCheckpointManager = exports.CheckpointManager = exports.createFileJobStorage = exports.FileJobStorage = exports.MemoryJobStorage = exports.createJobQueue = exports.JobQueue = exports.cronExpressions = exports.createScheduler = exports.Scheduler = exports.MODE_POLICIES = exports.cliApprovalPrompt = exports.createAutonomyManager = exports.AutonomyManager = exports.DEFAULT_BLOCKED_PATHS = exports.DEFAULT_BLOCKED_COMMANDS = exports.CommandValidator = exports.sandboxExec = exports.createSandboxExecutor = exports.SandboxExecutor = exports.createDiffViewer = exports.DiffViewer = exports.createGitManager = exports.GitManager = exports.DEFAULT_IGNORE_PATTERNS = exports.getRepoTree = exports.createRepoMap = exports.RepoMap = exports.createHistoryManager = exports.HistoryManager = exports.createStatusDisplay = exports.StatusDisplay = exports.createInteractiveTUI = void 0;
-exports.getQuickContext = exports.createFastContext = exports.FastContext = exports.triggerN8NWebhook = void 0;
-// Export all public modules
-__exportStar(require("./agent"), exports);
-__exportStar(require("./knowledge"), exports);
-__exportStar(require("./llm"), exports);
-__exportStar(require("./memory"), exports);
-__exportStar(require("./process"), exports);
-// Export tools (excluding conflicting types)
+exports.createAutoMemory = exports.AutoMemory = exports.createFileMemory = exports.FileMemory = exports.createMemory = exports.Memory = exports.CLI_SPEC_VERSION = exports.executeCommand = exports.parseArgs = exports.parseSkillFile = exports.createSkillManager = exports.SkillManager = exports.getObservabilityAdapter = exports.setObservabilityAdapter = exports.ConsoleObservabilityAdapter = exports.MemoryObservabilityAdapter = exports.EvalSuite = exports.reliabilityEval = exports.performanceEval = exports.accuracyEval = exports.createContextAgent = exports.ContextAgent = exports.routeConditions = exports.createRouter = exports.RouterAgent = exports.handoffFilters = exports.handoff = exports.Handoff = exports.getTool = exports.registerTool = exports.getRegistry = exports.ToolRegistry = exports.tool = exports.FunctionTool = exports.createTool = exports.validateTool = exports.ToolValidationError = exports.BaseTool = exports.setDefaultDbAdapter = exports.getDefaultDbAdapter = exports.createDbAdapter = exports.db = exports.repeat = exports.loop = exports.route = exports.parallel = exports.Workflow = exports.PraisonAIAgents = exports.Agents = exports.Agent = void 0;
+exports.MemoryPostgresAdapter = exports.NeonPostgresAdapter = exports.createMemoryRedis = exports.createUpstashRedis = exports.MemoryRedisAdapter = exports.UpstashRedisAdapter = exports.createSQLiteAdapter = exports.SQLiteAdapter = exports.validateWorkflowDefinition = exports.loadWorkflowFromFile = exports.createWorkflowFromYAML = exports.parseYAMLWorkflow = exports.createPubSub = exports.createEventBus = exports.AgentEvents = exports.AgentEventBus = exports.EventEmitterPubSub = exports.PubSub = exports.createFileCache = exports.createMemoryCache = exports.FileCache = exports.MemoryCache = exports.BaseCache = exports.createPlanStorage = exports.createTodoList = exports.createPlan = exports.PlanStorage = exports.TodoItem = exports.TodoList = exports.PlanStep = exports.Plan = exports.createLLMGuardrail = exports.LLMGuardrail = exports.createPromptExpanderAgent = exports.PromptExpanderAgent = exports.createQueryRewriterAgent = exports.QueryRewriterAgent = exports.createDeepResearchAgent = exports.DeepResearchAgent = exports.createImageAgent = exports.ImageAgent = exports.createAutoAgents = exports.AutoAgents = exports.cleanupTelemetry = exports.disableTelemetry = exports.enableTelemetry = exports.getTelemetry = exports.TelemetryCollector = exports.DEFAULT_POLICIES = exports.createLLMSummarizer = void 0;
+exports.parseSlashCommand = exports.registerCommand = exports.createSlashCommandHandler = exports.SlashCommandHandler = exports.BaseProvider = exports.GoogleProvider = exports.AnthropicProvider = exports.OpenAIProvider = exports.getAvailableProviders = exports.isProviderAvailable = exports.parseModelString = exports.getDefaultProvider = exports.createProvider = exports.createGraphRAG = exports.GraphRAG = exports.GraphStore = exports.createLLMReranker = exports.createCrossEncoderReranker = exports.createCohereReranker = exports.LLMReranker = exports.CrossEncoderReranker = exports.CohereReranker = exports.BaseReranker = exports.createElevenLabsVoice = exports.createOpenAIVoice = exports.ElevenLabsVoiceProvider = exports.OpenAIVoiceProvider = exports.BaseVoiceProvider = exports.createLangfuseObservability = exports.createMemoryObservability = exports.createConsoleObservability = exports.LangfuseObservabilityProvider = exports.MemoryObservabilityProvider = exports.ConsoleObservabilityProvider = exports.BaseObservabilityProvider = exports.createChromaStore = exports.ChromaVectorStore = exports.createQdrantStore = exports.QdrantVectorStore = exports.createWeaviateStore = exports.WeaviateVectorStore = exports.createPineconeStore = exports.PineconeVectorStore = exports.createMemoryVectorStore = exports.MemoryVectorStore = exports.BaseVectorStore = exports.createPostgresSessionStorage = exports.createMemoryPostgres = exports.createNeonPostgres = exports.PostgresSessionStorage = void 0;
+exports.GeminiCliAgent = exports.ClaudeCodeAgent = exports.BaseExternalAgent = exports.renderWorkflow = exports.createFlowDisplay = exports.FlowDisplay = exports.createFileCheckpointStorage = exports.FileCheckpointStorage = exports.MemoryCheckpointStorage = exports.createCheckpointManager = exports.CheckpointManager = exports.createFileJobStorage = exports.FileJobStorage = exports.MemoryJobStorage = exports.createJobQueue = exports.JobQueue = exports.cronExpressions = exports.createScheduler = exports.Scheduler = exports.MODE_POLICIES = exports.cliApprovalPrompt = exports.createAutonomyManager = exports.AutonomyManager = exports.DEFAULT_BLOCKED_PATHS = exports.DEFAULT_BLOCKED_COMMANDS = exports.CommandValidator = exports.sandboxExec = exports.createSandboxExecutor = exports.SandboxExecutor = exports.createDiffViewer = exports.DiffViewer = exports.createGitManager = exports.GitManager = exports.DEFAULT_IGNORE_PATTERNS = exports.getRepoTree = exports.createRepoMap = exports.RepoMap = exports.createHistoryManager = exports.HistoryManager = exports.createStatusDisplay = exports.StatusDisplay = exports.createInteractiveTUI = exports.InteractiveTUI = exports.MODEL_PRICING = exports.formatCost = exports.estimateTokens = exports.createCostTracker = exports.CostTracker = exports.isSlashCommand = exports.executeSlashCommand = void 0;
+exports.getQuickContext = exports.createFastContext = exports.FastContext = exports.triggerN8NWebhook = exports.createN8NIntegration = exports.N8NIntegration = exports.externalAgentAsTool = exports.createExternalAgent = exports.getExternalAgentRegistry = exports.GenericExternalAgent = exports.AiderAgent = exports.CodexCliAgent = void 0;
+// ============================================================================
+// CORE API - The main classes users should use
+// ============================================================================
+// Agent - Single agent with instructions, tools, and optional persistence
+var agent_1 = require("./agent");
+Object.defineProperty(exports, "Agent", { enumerable: true, get: function () { return agent_1.Agent; } });
+Object.defineProperty(exports, "Agents", { enumerable: true, get: function () { return agent_1.Agents; } });
+Object.defineProperty(exports, "PraisonAIAgents", { enumerable: true, get: function () { return agent_1.PraisonAIAgents; } });
+// Workflow - Step-based workflow execution
+var workflows_1 = require("./workflows");
+Object.defineProperty(exports, "Workflow", { enumerable: true, get: function () { return workflows_1.Workflow; } });
+Object.defineProperty(exports, "parallel", { enumerable: true, get: function () { return workflows_1.parallel; } });
+Object.defineProperty(exports, "route", { enumerable: true, get: function () { return workflows_1.route; } });
+Object.defineProperty(exports, "loop", { enumerable: true, get: function () { return workflows_1.loop; } });
+Object.defineProperty(exports, "repeat", { enumerable: true, get: function () { return workflows_1.repeat; } });
+// Database factory - Python-like db() shortcut
+var db_1 = require("./db");
+Object.defineProperty(exports, "db", { enumerable: true, get: function () { return db_1.db; } });
+Object.defineProperty(exports, "createDbAdapter", { enumerable: true, get: function () { return db_1.createDbAdapter; } });
+Object.defineProperty(exports, "getDefaultDbAdapter", { enumerable: true, get: function () { return db_1.getDefaultDbAdapter; } });
+Object.defineProperty(exports, "setDefaultDbAdapter", { enumerable: true, get: function () { return db_1.setDefaultDbAdapter; } });
+// ============================================================================
+// TOOLS - Function tools and tool registry
+// ============================================================================
 var tools_1 = require("./tools");
 Object.defineProperty(exports, "BaseTool", { enumerable: true, get: function () { return tools_1.BaseTool; } });
 Object.defineProperty(exports, "ToolValidationError", { enumerable: true, get: function () { return tools_1.ToolValidationError; } });
@@ -39,12 +94,22 @@ Object.defineProperty(exports, "registerTool", { enumerable: true, get: function
 Object.defineProperty(exports, "getTool", { enumerable: true, get: function () { return tools_1.getTool; } });
 __exportStar(require("./tools/arxivTools"), exports);
 __exportStar(require("./tools/mcpSse"), exports);
-// Export session management
+// ============================================================================
+// SESSION & MEMORY
+// ============================================================================
 __exportStar(require("./session"), exports);
-// Export database adapters
-__exportStar(require("./db"), exports);
-// Export workflows
-__exportStar(require("./workflows"), exports);
+// ============================================================================
+// KNOWLEDGE & RAG
+// ============================================================================
+__exportStar(require("./knowledge"), exports);
+// ============================================================================
+// LLM PROVIDERS
+// ============================================================================
+__exportStar(require("./llm"), exports);
+__exportStar(require("./process"), exports);
+// ============================================================================
+// WORKFLOWS (additional exports)
+// ============================================================================
 // Export guardrails
 __exportStar(require("./guardrails"), exports);
 // Export handoff
@@ -61,10 +126,6 @@ Object.defineProperty(exports, "routeConditions", { enumerable: true, get: funct
 var context_1 = require("./agent/context");
 Object.defineProperty(exports, "ContextAgent", { enumerable: true, get: function () { return context_1.ContextAgent; } });
 Object.defineProperty(exports, "createContextAgent", { enumerable: true, get: function () { return context_1.createContextAgent; } });
-// Export knowledge base (RAG)
-var rag_1 = require("./knowledge/rag");
-Object.defineProperty(exports, "KnowledgeBase", { enumerable: true, get: function () { return rag_1.KnowledgeBase; } });
-Object.defineProperty(exports, "createKnowledgeBase", { enumerable: true, get: function () { return rag_1.createKnowledgeBase; } });
 // Export evaluation framework
 var eval_1 = require("./eval");
 Object.defineProperty(exports, "accuracyEval", { enumerable: true, get: function () { return eval_1.accuracyEval; } });
@@ -87,7 +148,7 @@ var cli_1 = require("./cli");
 Object.defineProperty(exports, "parseArgs", { enumerable: true, get: function () { return cli_1.parseArgs; } });
 Object.defineProperty(exports, "executeCommand", { enumerable: true, get: function () { return cli_1.executeCommand; } });
 Object.defineProperty(exports, "CLI_SPEC_VERSION", { enumerable: true, get: function () { return cli_1.CLI_SPEC_VERSION; } });
-// Export Memory
+// Export Memory (explicit for convenience)
 var memory_1 = require("./memory/memory");
 Object.defineProperty(exports, "Memory", { enumerable: true, get: function () { return memory_1.Memory; } });
 Object.defineProperty(exports, "createMemory", { enumerable: true, get: function () { return memory_1.createMemory; } });
@@ -128,10 +189,6 @@ Object.defineProperty(exports, "createQueryRewriterAgent", { enumerable: true, g
 var prompt_expander_1 = require("./agent/prompt-expander");
 Object.defineProperty(exports, "PromptExpanderAgent", { enumerable: true, get: function () { return prompt_expander_1.PromptExpanderAgent; } });
 Object.defineProperty(exports, "createPromptExpanderAgent", { enumerable: true, get: function () { return prompt_expander_1.createPromptExpanderAgent; } });
-// Export Chunking
-var chunking_1 = require("./knowledge/chunking");
-Object.defineProperty(exports, "Chunking", { enumerable: true, get: function () { return chunking_1.Chunking; } });
-Object.defineProperty(exports, "createChunking", { enumerable: true, get: function () { return chunking_1.createChunking; } });
 // Export LLMGuardrail
 var llm_guardrail_1 = require("./guardrails/llm-guardrail");
 Object.defineProperty(exports, "LLMGuardrail", { enumerable: true, get: function () { return llm_guardrail_1.LLMGuardrail; } });

package/dist/workflows/index.d.ts

@@ -59,6 +59,27 @@ export declare class Workflow<TInput = any, TOutput = any> {
      * Add a step using a simpler syntax
      */
     step<TStepInput = any, TStepOutput = any>(name: string, execute: StepFunction<TStepInput, TStepOutput>): this;
+    /**
+     * Add an agent step to the workflow
+     *
+     * @example
+     * ```typescript
+     * import { Agent, Workflow } from 'praisonai';
+     *
+     * const researcher = new Agent({ instructions: "Research the topic" });
+     * const writer = new Agent({ instructions: "Write based on research" });
+     *
+     * const workflow = new Workflow("Research Pipeline")
+     *   .agent(researcher, "Research AI trends")
+     *   .agent(writer, "Write article based on research");
+     *
+     * await workflow.run("AI in 2025");
+     * ```
+     */
+    agent(agentInstance: {
+        chat: (prompt: string) => Promise<string>;
+        name?: string;
+    }, task?: string): this;
     /**
      * Run the workflow
      */

package/dist/workflows/index.js

@@ -134,6 +134,37 @@ class Workflow {
     step(name, execute) {
         return this.addStep({ name, execute });
     }
+    /**
+     * Add an agent step to the workflow
+     *
+     * @example
+     * ```typescript
+     * import { Agent, Workflow } from 'praisonai';
+     *
+     * const researcher = new Agent({ instructions: "Research the topic" });
+     * const writer = new Agent({ instructions: "Write based on research" });
+     *
+     * const workflow = new Workflow("Research Pipeline")
+     *   .agent(researcher, "Research AI trends")
+     *   .agent(writer, "Write article based on research");
+     *
+     * await workflow.run("AI in 2025");
+     * ```
+     */
+    agent(agentInstance, task) {
+        const agentName = agentInstance.name || 'Agent';
+        const stepName = task ? `${agentName}: ${task.slice(0, 30)}...` : agentName;
+        return this.addStep({
+            name: stepName,
+            execute: async (input, context) => {
+                // Build prompt from task and previous step output
+                const prompt = task
+                    ? `${task}\n\nInput: ${typeof input === 'string' ? input : JSON.stringify(input)}`
+                    : typeof input === 'string' ? input : JSON.stringify(input);
+                return agentInstance.chat(prompt);
+            }
+        });
+    }
     /**
      * Run the workflow
      */

package/package.json

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