praisonai 1.0.18 → 1.1.0

package/dist/agent/handoff.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * Agent Handoff - Transfer conversations between agents
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handoffFilters = exports.Handoff = void 0;
+exports.handoff = handoff;
+/**
+ * Handoff class - Represents a handoff target
+ */
+class Handoff {
+    constructor(config) {
+        this.targetAgent = config.agent;
+        this.name = config.name || `handoff_to_${config.agent.name}`;
+        this.description = config.description || `Transfer conversation to ${config.agent.name}`;
+        this.condition = config.condition;
+        this.transformContext = config.transformContext;
+    }
+    /**
+     * Check if handoff should be triggered
+     */
+    shouldTrigger(context) {
+        if (this.condition) {
+            return this.condition(context);
+        }
+        return true;
+    }
+    /**
+     * Execute the handoff
+     */
+    async execute(context) {
+        let messages = context.messages;
+        if (this.transformContext) {
+            messages = this.transformContext(messages);
+        }
+        // Transfer context to target agent
+        const response = await this.targetAgent.chat(context.lastMessage);
+        return {
+            handedOffTo: this.targetAgent.name,
+            response: response.text,
+            context: {
+                ...context,
+                messages,
+            },
+        };
+    }
+    /**
+     * Get tool definition for LLM
+     */
+    getToolDefinition() {
+        return {
+            name: this.name,
+            description: this.description,
+            parameters: {
+                type: 'object',
+                properties: {
+                    reason: {
+                        type: 'string',
+                        description: 'Reason for the handoff',
+                    },
+                },
+                required: [],
+            },
+        };
+    }
+}
+exports.Handoff = Handoff;
+/**
+ * Create a handoff configuration
+ */
+function handoff(config) {
+    return new Handoff(config);
+}
+/**
+ * Handoff filters - Common condition functions
+ */
+exports.handoffFilters = {
+    /**
+     * Trigger handoff based on topic keywords
+     */
+    topic: (keywords) => {
+        const keywordList = Array.isArray(keywords) ? keywords : [keywords];
+        return (context) => {
+            const lastMessage = context.lastMessage.toLowerCase();
+            return keywordList.some(kw => lastMessage.includes(kw.toLowerCase()));
+        };
+    },
+    /**
+     * Trigger handoff based on metadata
+     */
+    metadata: (key, value) => {
+        return (context) => {
+            return context.metadata?.[key] === value;
+        };
+    },
+    /**
+     * Always trigger
+     */
+    always: () => {
+        return () => true;
+    },
+    /**
+     * Never trigger (manual only)
+     */
+    never: () => {
+        return () => false;
+    },
+    /**
+     * Combine multiple conditions with AND
+     */
+    and: (...conditions) => {
+        return (context) => {
+            return conditions.every(cond => cond(context));
+        };
+    },
+    /**
+     * Combine multiple conditions with OR
+     */
+    or: (...conditions) => {
+        return (context) => {
+            return conditions.some(cond => cond(context));
+        };
+    },
+};

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.d.ts

@@ -6,7 +6,7 @@ export interface SimpleAgentConfig {
     llm?: string;
     markdown?: boolean;
     stream?: boolean;
-    tools?: any[];
+    tools?: any[] | Function[];
     toolFunctions?: Record<string, Function>;
 }
 export declare class Agent {

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;
@@ -18,6 +18,40 @@ class Agent {
         // Configure logging
         logger_1.Logger.setVerbose(this.verbose);
         logger_1.Logger.setPretty(this.pretty);
+        // Process tools array - handle both tool definitions and functions
+        if (config.tools && Array.isArray(config.tools)) {
+            // Convert tools array to proper format if it contains functions
+            const processedTools = [];
+            for (let i = 0; i < config.tools.length; i++) {
+                const tool = config.tools[i];
+                if (typeof tool === 'function') {
+                    // If it's a function, extract its name and register it
+                    const funcName = tool.name || `function_${i}`;
+                    // Skip functions with empty names
+                    if (funcName && funcName.trim() !== '') {
+                        this.registerToolFunction(funcName, tool);
+                        // Auto-generate tool definition
+                        this.addAutoGeneratedToolDefinition(funcName, tool);
+                    }
+                    else {
+                        // Generate a random name for functions without names
+                        const randomName = `function_${Math.random().toString(36).substring(2, 9)}`;
+                        this.registerToolFunction(randomName, tool);
+                        // Auto-generate tool definition
+                        this.addAutoGeneratedToolDefinition(randomName, tool);
+                    }
+                }
+                else {
+                    // If it's already a tool definition, add it as is
+                    processedTools.push(tool);
+                }
+            }
+            // Add any pre-defined tool definitions
+            if (processedTools.length > 0) {
+                this.tools = this.tools || [];
+                this.tools.push(...processedTools);
+            }
+        }
         // Register directly provided tool functions if any
         if (config.toolFunctions) {
             for (const [name, func] of Object.entries(config.toolFunctions)) {
@@ -69,6 +103,8 @@ class Agent {
         if (!this.tools) {
             this.tools = [];
         }
+        // Ensure we have a valid function name
+        const functionName = name || func.name || `function_${Math.random().toString(36).substring(2, 9)}`;
         // Extract parameter names from function
         const funcStr = func.toString();
         const paramMatch = funcStr.match(/\(([^)]*)\)/);
@@ -77,8 +113,8 @@ class Agent {
         const toolDef = {
             type: "function",
             function: {
-                name,
-                description: `Auto-generated function for ${name}`,
+                name: functionName,
+                description: `Auto-generated function for ${functionName}`,
                 parameters: {
                     type: "object",
                     properties: {},
@@ -105,7 +141,7 @@ class Agent {
             toolDef.function.parameters.required = required;
         }
         this.tools.push(toolDef);
-        logger_1.Logger.debug(`Auto-generated tool definition for ${name}`);
+        logger_1.Logger.debug(`Auto-generated tool definition for ${functionName}`);
     }
     /**
      * Process tool calls from the model

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/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);
+}