praisonai 1.0.19 → 1.2.0

package/dist/agent/router.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Router Agent - Route requests to specialized agents
+ */
+import type { EnhancedAgent } from './enhanced';
+export interface RouteConfig {
+    agent: EnhancedAgent;
+    condition: (input: string, context?: RouteContext) => boolean | Promise<boolean>;
+    priority?: number;
+}
+export interface RouteContext {
+    history?: string[];
+    metadata?: Record<string, any>;
+}
+export interface RouterConfig {
+    name?: string;
+    routes: RouteConfig[];
+    defaultAgent?: EnhancedAgent;
+    verbose?: boolean;
+}
+/**
+ * Router Agent - Routes requests to the most appropriate agent
+ */
+export declare class RouterAgent {
+    readonly name: string;
+    private routes;
+    private defaultAgent?;
+    private verbose;
+    constructor(config: RouterConfig);
+    /**
+     * Route a request to the appropriate agent
+     */
+    route(input: string, context?: RouteContext): Promise<{
+        agent: EnhancedAgent;
+        response: string;
+    } | null>;
+    /**
+     * Add a route
+     */
+    addRoute(config: RouteConfig): this;
+    /**
+     * Get all routes
+     */
+    getRoutes(): RouteConfig[];
+}
+/**
+ * Route condition helpers
+ */
+export declare const routeConditions: {
+    /**
+     * Match by keywords
+     */
+    keywords: (keywords: string | string[]) => (input: string) => boolean;
+    /**
+     * Match by regex
+     */
+    pattern: (regex: RegExp) => (input: string) => boolean;
+    /**
+     * Match by metadata
+     */
+    metadata: (key: string, value: any) => (_input: string, context?: RouteContext) => boolean;
+    /**
+     * Always match (for default routes)
+     */
+    always: () => () => boolean;
+    /**
+     * Combine conditions with AND
+     */
+    and: (...conditions: Array<(input: string, context?: RouteContext) => boolean>) => (input: string, context?: RouteContext) => boolean;
+    /**
+     * Combine conditions with OR
+     */
+    or: (...conditions: Array<(input: string, context?: RouteContext) => boolean>) => (input: string, context?: RouteContext) => boolean;
+};
+/**
+ * Create a router agent
+ */
+export declare function createRouter(config: RouterConfig): RouterAgent;

package/dist/agent/router.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Router Agent - Route requests to specialized agents
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routeConditions = exports.RouterAgent = void 0;
+exports.createRouter = createRouter;
+/**
+ * Router Agent - Routes requests to the most appropriate agent
+ */
+class RouterAgent {
+    constructor(config) {
+        this.name = config.name || 'Router';
+        this.routes = config.routes.sort((a, b) => (b.priority || 0) - (a.priority || 0));
+        this.defaultAgent = config.defaultAgent;
+        this.verbose = config.verbose ?? false;
+    }
+    /**
+     * Route a request to the appropriate agent
+     */
+    async route(input, context) {
+        for (const route of this.routes) {
+            const matches = await route.condition(input, context);
+            if (matches) {
+                if (this.verbose) {
+                    console.log(`[Router] Routing to: ${route.agent.name}`);
+                }
+                const response = await route.agent.chat(input);
+                return { agent: route.agent, response: response.text };
+            }
+        }
+        if (this.defaultAgent) {
+            if (this.verbose) {
+                console.log(`[Router] Using default agent: ${this.defaultAgent.name}`);
+            }
+            const response = await this.defaultAgent.chat(input);
+            return { agent: this.defaultAgent, response: response.text };
+        }
+        return null;
+    }
+    /**
+     * Add a route
+     */
+    addRoute(config) {
+        this.routes.push(config);
+        this.routes.sort((a, b) => (b.priority || 0) - (a.priority || 0));
+        return this;
+    }
+    /**
+     * Get all routes
+     */
+    getRoutes() {
+        return [...this.routes];
+    }
+}
+exports.RouterAgent = RouterAgent;
+/**
+ * Route condition helpers
+ */
+exports.routeConditions = {
+    /**
+     * Match by keywords
+     */
+    keywords: (keywords) => {
+        const keywordList = Array.isArray(keywords) ? keywords : [keywords];
+        return (input) => {
+            const lower = input.toLowerCase();
+            return keywordList.some(kw => lower.includes(kw.toLowerCase()));
+        };
+    },
+    /**
+     * Match by regex
+     */
+    pattern: (regex) => {
+        return (input) => regex.test(input);
+    },
+    /**
+     * Match by metadata
+     */
+    metadata: (key, value) => {
+        return (_input, context) => {
+            return context?.metadata?.[key] === value;
+        };
+    },
+    /**
+     * Always match (for default routes)
+     */
+    always: () => {
+        return () => true;
+    },
+    /**
+     * Combine conditions with AND
+     */
+    and: (...conditions) => {
+        return (input, context) => {
+            return conditions.every(c => c(input, context));
+        };
+    },
+    /**
+     * Combine conditions with OR
+     */
+    or: (...conditions) => {
+        return (input, context) => {
+            return conditions.some(c => c(input, context));
+        };
+    }
+};
+/**
+ * Create a router agent
+ */
+function createRouter(config) {
+    return new RouterAgent(config);
+}

package/dist/agent/simple.js

@@ -10,7 +10,7 @@ class Agent {
         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 || 'gpt-5-nano';
         this.markdown = config.markdown ?? true;
         this.stream = config.stream ?? true;
         this.tools = config.tools;

package/dist/agent/types.js

@@ -22,7 +22,7 @@ class Agent {
         this.goal = config.goal;
         this.backstory = config.backstory;
         this.verbose = config.verbose || false;
-        this.llm = new openai_1.OpenAIService(config.llm || 'gpt-4o-mini');
+        this.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 });
@@ -87,7 +87,7 @@ class PraisonAIAgents {
         this.tasks = config.tasks;
         this.verbose = config.verbose || false;
         this.process = config.process || 'sequential';
-        this.manager_llm = config.manager_llm || 'gpt-4o-mini';
+        this.manager_llm = config.manager_llm || 'gpt-5-nano';
         logger_1.Logger.debug('PraisonAIAgents initialized', { config });
     }
     async start() {

package/dist/auto/index.d.ts

@@ -0,0 +1,56 @@
+/**
+ * AutoAgents - Automatic agent generation from task descriptions
+ */
+export interface AgentConfig {
+    name: string;
+    role: string;
+    goal: string;
+    backstory?: string;
+    instructions?: string;
+    tools?: string[];
+}
+export interface TaskConfig {
+    description: string;
+    expectedOutput?: string;
+    agent?: string;
+}
+export interface TeamStructure {
+    agents: AgentConfig[];
+    tasks: TaskConfig[];
+    pattern: 'sequential' | 'parallel' | 'hierarchical';
+}
+export interface AutoAgentsConfig {
+    llm?: string;
+    pattern?: 'sequential' | 'parallel' | 'routing' | 'orchestrator-workers' | 'evaluator-optimizer';
+    singleAgent?: boolean;
+    verbose?: boolean;
+}
+/**
+ * AutoAgents - Generate agent configurations from task descriptions
+ */
+export declare class AutoAgents {
+    private provider;
+    private pattern;
+    private singleAgent;
+    private verbose;
+    constructor(config?: AutoAgentsConfig);
+    /**
+     * Generate agent configuration from task description
+     */
+    generate(taskDescription: string): Promise<TeamStructure>;
+    /**
+     * Recommend a pattern for the task
+     */
+    recommendPattern(taskDescription: string): string;
+    /**
+     * Analyze task complexity
+     */
+    analyzeComplexity(taskDescription: string): 'simple' | 'moderate' | 'complex';
+    private getSystemPrompt;
+    private buildPrompt;
+    private parseResponse;
+}
+/**
+ * Create an AutoAgents instance
+ */
+export declare function createAutoAgents(config?: AutoAgentsConfig): AutoAgents;

package/dist/auto/index.js

@@ -0,0 +1,142 @@
+"use strict";
+/**
+ * AutoAgents - Automatic agent generation from task descriptions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoAgents = void 0;
+exports.createAutoAgents = createAutoAgents;
+const providers_1 = require("../llm/providers");
+/**
+ * AutoAgents - Generate agent configurations from task descriptions
+ */
+class AutoAgents {
+    constructor(config = {}) {
+        this.provider = (0, providers_1.createProvider)(config.llm || 'openai/gpt-4o-mini');
+        this.pattern = config.pattern || 'sequential';
+        this.singleAgent = config.singleAgent ?? false;
+        this.verbose = config.verbose ?? false;
+    }
+    /**
+     * Generate agent configuration from task description
+     */
+    async generate(taskDescription) {
+        const prompt = this.buildPrompt(taskDescription);
+        const result = await this.provider.generateText({
+            messages: [
+                { role: 'system', content: this.getSystemPrompt() },
+                { role: 'user', content: prompt }
+            ]
+        });
+        return this.parseResponse(result.text);
+    }
+    /**
+     * Recommend a pattern for the task
+     */
+    recommendPattern(taskDescription) {
+        const lower = taskDescription.toLowerCase();
+        if (lower.includes('parallel') || lower.includes('concurrent') || lower.includes('simultaneously')) {
+            return 'parallel';
+        }
+        if (lower.includes('route') || lower.includes('classify') || lower.includes('categorize')) {
+            return 'routing';
+        }
+        if (lower.includes('orchestrat') || lower.includes('coordinat') || lower.includes('manage')) {
+            return 'orchestrator-workers';
+        }
+        if (lower.includes('evaluat') || lower.includes('optimi') || lower.includes('improv')) {
+            return 'evaluator-optimizer';
+        }
+        return 'sequential';
+    }
+    /**
+     * Analyze task complexity
+     */
+    analyzeComplexity(taskDescription) {
+        const words = taskDescription.split(/\s+/).length;
+        const hasMultipleSteps = /step|then|after|before|first|second|third|finally/i.test(taskDescription);
+        const hasMultipleAgents = /team|multiple|several|different|various/i.test(taskDescription);
+        if (words < 20 && !hasMultipleSteps && !hasMultipleAgents) {
+            return 'simple';
+        }
+        if (words > 100 || (hasMultipleSteps && hasMultipleAgents)) {
+            return 'complex';
+        }
+        return 'moderate';
+    }
+    getSystemPrompt() {
+        return `You are an AI agent architect. Your job is to analyze task descriptions and generate optimal agent configurations.
+
+Output a JSON object with the following structure:
+{
+  "agents": [
+    {
+      "name": "AgentName",
+      "role": "Role description",
+      "goal": "Agent's goal",
+      "backstory": "Optional backstory",
+      "instructions": "Specific instructions",
+      "tools": ["tool1", "tool2"]
+    }
+  ],
+  "tasks": [
+    {
+      "description": "Task description",
+      "expectedOutput": "What the task should produce",
+      "agent": "AgentName"
+    }
+  ],
+  "pattern": "sequential|parallel|hierarchical"
+}
+
+Guidelines:
+- For simple tasks, use 1 agent
+- For moderate tasks, use 2-3 agents
+- For complex tasks, use 3-5 agents
+- Match the pattern to the task requirements
+- Be specific about roles and goals`;
+    }
+    buildPrompt(taskDescription) {
+        const complexity = this.analyzeComplexity(taskDescription);
+        const recommendedPattern = this.recommendPattern(taskDescription);
+        return `Task Description: ${taskDescription}
+
+Complexity: ${complexity}
+Recommended Pattern: ${this.pattern || recommendedPattern}
+Single Agent Mode: ${this.singleAgent}
+
+Generate an optimal agent configuration for this task.`;
+    }
+    parseResponse(response) {
+        try {
+            // Extract JSON from response
+            const jsonMatch = response.match(/\{[\s\S]*\}/);
+            if (jsonMatch) {
+                return JSON.parse(jsonMatch[0]);
+            }
+        }
+        catch (error) {
+            // Fallback to default structure
+        }
+        // Default fallback
+        return {
+            agents: [{
+                    name: 'GeneralAgent',
+                    role: 'General purpose agent',
+                    goal: 'Complete the assigned task',
+                    instructions: 'Follow the task description carefully'
+                }],
+            tasks: [{
+                    description: 'Complete the task',
+                    agent: 'GeneralAgent'
+                }],
+            pattern: 'sequential'
+        };
+    }
+}
+exports.AutoAgents = AutoAgents;
+/**
+ * Create an AutoAgents instance
+ */
+function createAutoAgents(config) {
+    return new AutoAgents(config);
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+/**
+ * PraisonAI TypeScript CLI
+ */
+interface CLIOptions {
+    model?: string;
+    stream?: boolean;
+    verbose?: boolean;
+    sessionId?: string;
+}
+declare function chat(prompt: string, options?: CLIOptions): Promise<string>;
+declare function listProviders(): Promise<void>;
+declare function version(): Promise<void>;
+declare function help(): Promise<void>;
+declare function parseArgs(args: string[]): {
+    command: string;
+    prompt: string;
+    options: CLIOptions;
+};
+export { chat, listProviders, version, help, parseArgs };

package/dist/cli/index.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * PraisonAI TypeScript CLI
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chat = chat;
+exports.listProviders = listProviders;
+exports.version = version;
+exports.help = help;
+exports.parseArgs = parseArgs;
+const providers_1 = require("../llm/providers");
+const session_1 = require("../session");
+async function chat(prompt, options = {}) {
+    const model = options.model || process.env.PRAISONAI_MODEL || 'openai/gpt-4o-mini';
+    const provider = (0, providers_1.createProvider)(model);
+    const session = new session_1.Session({ id: options.sessionId });
+    session.addMessage({ role: 'user', content: prompt });
+    if (options.stream) {
+        let fullText = '';
+        const stream = await provider.streamText({
+            messages: [{ role: 'user', content: prompt }],
+            onToken: (token) => {
+                process.stdout.write(token);
+                fullText += token;
+            }
+        });
+        for await (const chunk of stream) {
+            // Stream is consumed by onToken
+        }
+        console.log(); // New line after streaming
+        return fullText;
+    }
+    else {
+        const result = await provider.generateText({
+            messages: [{ role: 'user', content: prompt }]
+        });
+        console.log(result.text);
+        return result.text;
+    }
+}
+async function listProviders() {
+    console.log('Available Providers:');
+    const available = (0, providers_1.getAvailableProviders)();
+    const providers = ['openai', 'anthropic', 'google'];
+    for (const p of providers) {
+        const status = available.includes(p) ? '✅' : '❌';
+        console.log(`  ${status} ${p}`);
+    }
+}
+async function version() {
+    const pkg = require('../../package.json');
+    console.log(`praisonai v${pkg.version}`);
+}
+async function help() {
+    console.log(`
+PraisonAI TypeScript CLI
+
+Usage:
+  praisonai-ts chat <prompt>     Chat with an AI agent
+  praisonai-ts providers         List available providers
+  praisonai-ts version           Show version
+  praisonai-ts help              Show this help
+
+Options:
+  --model, -m <model>     Model to use (e.g., openai/gpt-4o-mini)
+  --stream, -s            Enable streaming output
+  --verbose, -v           Verbose output
+  --session <id>          Session ID for conversation continuity
+
+Environment Variables:
+  OPENAI_API_KEY          OpenAI API key
+  ANTHROPIC_API_KEY       Anthropic API key
+  GOOGLE_API_KEY          Google API key
+  PRAISONAI_MODEL         Default model
+
+Examples:
+  praisonai-ts chat "Hello, how are you?"
+  praisonai-ts chat "Write a poem" --stream
+  praisonai-ts chat "Explain AI" -m anthropic/claude-sonnet-4-20250514
+  praisonai-ts providers
+`);
+}
+function parseArgs(args) {
+    const options = {};
+    let command = 'help';
+    let prompt = '';
+    let i = 0;
+    while (i < args.length) {
+        const arg = args[i];
+        if (arg === '--model' || arg === '-m') {
+            options.model = args[++i];
+        }
+        else if (arg === '--stream' || arg === '-s') {
+            options.stream = true;
+        }
+        else if (arg === '--verbose' || arg === '-v') {
+            options.verbose = true;
+        }
+        else if (arg === '--session') {
+            options.sessionId = args[++i];
+        }
+        else if (!arg.startsWith('-')) {
+            if (!command || command === 'help') {
+                command = arg;
+            }
+            else {
+                prompt = arg;
+            }
+        }
+        i++;
+    }
+    return { command, prompt, options };
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const { command, prompt, options } = parseArgs(args);
+    try {
+        switch (command) {
+            case 'chat':
+                if (!prompt) {
+                    console.error('Error: Please provide a prompt');
+                    process.exit(1);
+                }
+                await chat(prompt, options);
+                break;
+            case 'providers':
+                await listProviders();
+                break;
+            case 'version':
+                await version();
+                break;
+            case 'help':
+            default:
+                await help();
+                break;
+        }
+    }
+    catch (error) {
+        console.error('Error:', error.message);
+        if (options.verbose) {
+            console.error(error.stack);
+        }
+        process.exit(1);
+    }
+}
+// Run CLI if executed directly
+if (require.main === module) {
+    main();
+}

package/dist/db/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Database Module - Exports for persistence layer
+ */
+export * from './types';
+export { MemoryDbAdapter } from './memory-adapter';
+import type { DbAdapter, DbConfig } from './types';
+/**
+ * Create a database adapter based on configuration
+ */
+export declare function createDbAdapter(config: DbConfig): DbAdapter;
+/**
+ * Get or create the default database adapter
+ */
+export declare function getDefaultDbAdapter(): DbAdapter;
+/**
+ * Set the default database adapter
+ */
+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' })
+ */
+export declare function db(config?: DbConfig): DbAdapter;

package/dist/db/index.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Database Module - Exports for persistence layer
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryDbAdapter = void 0;
+exports.createDbAdapter = createDbAdapter;
+exports.getDefaultDbAdapter = getDefaultDbAdapter;
+exports.setDefaultDbAdapter = setDefaultDbAdapter;
+exports.db = db;
+__exportStar(require("./types"), exports);
+var memory_adapter_1 = require("./memory-adapter");
+Object.defineProperty(exports, "MemoryDbAdapter", { enumerable: true, get: function () { return memory_adapter_1.MemoryDbAdapter; } });
+const memory_adapter_2 = require("./memory-adapter");
+// Default adapter instance
+let defaultAdapter = null;
+/**
+ * Create a database adapter based on configuration
+ */
+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.');
+        default:
+            throw new Error(`Unknown database type: ${config.type}`);
+    }
+}
+/**
+ * Get or create the default database adapter
+ */
+function getDefaultDbAdapter() {
+    if (!defaultAdapter) {
+        defaultAdapter = new memory_adapter_2.MemoryDbAdapter();
+    }
+    return defaultAdapter;
+}
+/**
+ * Set the default database adapter
+ */
+function setDefaultDbAdapter(adapter) {
+    defaultAdapter = adapter;
+}
+/**
+ * Shortcut function for creating a database adapter
+ * Usage: db({ type: 'memory' }) or db({ type: 'sqlite', path: './data.db' })
+ */
+function db(config = { type: 'memory' }) {
+    return createDbAdapter(config);
+}