praisonai 1.5.4 → 1.6.0

package/dist/llm/providers/registry.js

@@ -168,20 +168,33 @@ class ProviderRegistry {
      * Constructors have a prototype with constructor
      */
     isLoaderFunction(value) {
-        // If it has a prototype with more than just constructor, it's likely a class
+        // Check if it's a class by looking at the string representation
+        const str = value.toString();
+        // Classes start with 'class ' in their toString
+        if (str.startsWith('class ')) {
+            return false;
+        }
+        // If it has a prototype with methods (more than just constructor), it's a class
         if (value.prototype && Object.getOwnPropertyNames(value.prototype).length > 1) {
             return false;
         }
-        // Check if it looks like a class (has 'prototype' that is an object with constructor)
-        if (value.prototype && value.prototype.constructor === value) {
-            // Additional check: classes typically have a name and their toString starts with 'class'
-            const str = value.toString();
-            if (str.startsWith('class ') || str.includes('function ')) {
-                return false;
+        // Jest mock functions and arrow functions are loaders
+        // They don't have a meaningful prototype or their prototype doesn't match class pattern
+        if (typeof value === 'function') {
+            // Arrow functions have no prototype or an empty prototype
+            if (!value.prototype) {
+                return true;
+            }
+            // Jest mocks have _isMockFunction property
+            if (value._isMockFunction) {
+                return true;
+            }
+            // Regular functions that aren't classes are loaders
+            if (!str.startsWith('class ') && !str.startsWith('function ')) {
+                return true;
             }
         }
-        // Arrow functions and simple functions are loaders
-        return typeof value === 'function' && !value.prototype?.constructor;
+        return false;
     }
 }
 exports.ProviderRegistry = ProviderRegistry;

package/dist/os/agentos.d.ts

@@ -0,0 +1,145 @@
+/**
+ * AgentOS Implementation
+ *
+ * Production platform for deploying AI agents as web services.
+ * Implements the AgentOSProtocol for serving agents via HTTP.
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import { AgentOS, Agent } from 'praisonai';
+ *
+ * const assistant = new Agent({
+ *   name: 'assistant',
+ *   instructions: 'Be helpful'
+ * });
+ *
+ * const app = new AgentOS({
+ *   name: 'My AI App',
+ *   agents: [assistant]
+ * });
+ *
+ * await app.serve({ port: 8000 });
+ * ```
+ *
+ * @example With Teams and Flows
+ * ```typescript
+ * const app = new AgentOS({
+ *   name: 'My AI App',
+ *   agents: [assistant],
+ *   teams: [myTeam],
+ *   flows: [myFlow],
+ *   config: { port: 9000, debug: true }
+ * });
+ * ```
+ */
+import type { AgentOSProtocol } from './protocols';
+import type { AgentOSConfig } from './config';
+type Agent = {
+    name?: string;
+    role?: string;
+    instructions?: string;
+    chat: (message: string) => Promise<string>;
+};
+type AgentTeam = {
+    agents?: Agent[];
+    start: () => Promise<string[]>;
+};
+type AgentFlow = {
+    name?: string;
+    run: (input: any) => Promise<any>;
+};
+/**
+ * AgentOS constructor options
+ */
+export interface AgentOSOptions {
+    /** Name of the application */
+    name?: string;
+    /** List of Agent instances to serve */
+    agents?: any[];
+    /** List of AgentTeam instances to serve */
+    teams?: any[];
+    /** List of AgentFlow instances to serve */
+    flows?: any[];
+    /** Server configuration */
+    config?: AgentOSConfig;
+    /** @deprecated Use `teams` instead */
+    managers?: any[];
+    /** @deprecated Use `flows` instead */
+    workflows?: any[];
+}
+/**
+ * Production platform for deploying AI agents as web services.
+ *
+ * AgentOS wraps agents, teams, and flows into a unified HTTP
+ * application with REST endpoints.
+ */
+export declare class AgentOS implements AgentOSProtocol {
+    /** Application name */
+    readonly name: string;
+    /** List of Agent instances */
+    readonly agents: Agent[];
+    /** List of AgentTeam instances */
+    readonly teams: AgentTeam[];
+    /** List of AgentFlow instances */
+    readonly flows: AgentFlow[];
+    /** Merged configuration */
+    readonly config: Required<Omit<AgentOSConfig, 'metadata'>> & {
+        metadata: Record<string, any>;
+    };
+    /** HTTP server instance (lazy initialized) */
+    private _server;
+    /** Express app instance (lazy initialized) */
+    private _app;
+    /**
+     * Create a new AgentOS instance.
+     *
+     * @param options - AgentOS options
+     */
+    constructor(options?: AgentOSOptions);
+    /**
+     * Create the Express application.
+     *
+     * @returns Express app instance
+     */
+    private _createApp;
+    /**
+     * Register API routes.
+     *
+     * @param app - Express app instance
+     */
+    private _registerRoutes;
+    /**
+     * Get the Express application instance.
+     *
+     * @returns The Express application instance for custom mounting or configuration
+     */
+    getApp(): any;
+    /**
+     * Start the AgentOS server.
+     *
+     * @param options - Server options
+     * @returns Promise that resolves when server is listening
+     */
+    serve(options?: {
+        host?: string;
+        port?: number;
+        reload?: boolean;
+    }): Promise<void>;
+    /**
+     * Stop the AgentOS server.
+     *
+     * @returns Promise that resolves when server is stopped
+     */
+    stop(): Promise<void>;
+}
+/**
+ * AgentApp - Silent alias for AgentOS (backward compatibility)
+ * @deprecated Use AgentOS instead
+ */
+export declare const AgentApp: typeof AgentOS;
+/**
+ * AgentAppOptions - Silent alias for AgentOSOptions (backward compatibility)
+ * @deprecated Use AgentOSOptions instead
+ */
+export type AgentAppOptions = AgentOSOptions;
+export {};

package/dist/os/agentos.js

@@ -0,0 +1,268 @@
+"use strict";
+/**
+ * AgentOS Implementation
+ *
+ * Production platform for deploying AI agents as web services.
+ * Implements the AgentOSProtocol for serving agents via HTTP.
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import { AgentOS, Agent } from 'praisonai';
+ *
+ * const assistant = new Agent({
+ *   name: 'assistant',
+ *   instructions: 'Be helpful'
+ * });
+ *
+ * const app = new AgentOS({
+ *   name: 'My AI App',
+ *   agents: [assistant]
+ * });
+ *
+ * await app.serve({ port: 8000 });
+ * ```
+ *
+ * @example With Teams and Flows
+ * ```typescript
+ * const app = new AgentOS({
+ *   name: 'My AI App',
+ *   agents: [assistant],
+ *   teams: [myTeam],
+ *   flows: [myFlow],
+ *   config: { port: 9000, debug: true }
+ * });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentApp = exports.AgentOS = void 0;
+const config_1 = require("./config");
+/**
+ * Production platform for deploying AI agents as web services.
+ *
+ * AgentOS wraps agents, teams, and flows into a unified HTTP
+ * application with REST endpoints.
+ */
+class AgentOS {
+    /**
+     * Create a new AgentOS instance.
+     *
+     * @param options - AgentOS options
+     */
+    constructor(options = {}) {
+        /** HTTP server instance (lazy initialized) */
+        this._server = null;
+        /** Express app instance (lazy initialized) */
+        this._app = null;
+        this.name = options.name || config_1.DEFAULT_AGENTOS_CONFIG.name;
+        this.agents = options.agents || [];
+        // Support both new names and legacy aliases
+        this.teams = options.teams || options.managers || [];
+        this.flows = options.flows || options.workflows || [];
+        // Merge config with defaults
+        this.config = (0, config_1.mergeConfig)({
+            name: this.name,
+            ...options.config,
+        });
+    }
+    /**
+     * Create the Express application.
+     *
+     * @returns Express app instance
+     */
+    _createApp() {
+        // Lazy import express
+        let express;
+        let cors;
+        try {
+            express = require('express');
+        }
+        catch {
+            throw new Error('Express is required for AgentOS. ' +
+                'Install with: npm install express');
+        }
+        try {
+            cors = require('cors');
+        }
+        catch {
+            // cors is optional, we'll handle manually if not available
+            cors = null;
+        }
+        const app = express();
+        // Parse JSON bodies
+        app.use(express.json());
+        // Add CORS middleware
+        if (cors) {
+            app.use(cors({
+                origin: this.config.corsOrigins,
+                credentials: true,
+                methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+                allowedHeaders: ['Content-Type', 'Authorization'],
+            }));
+        }
+        else {
+            // Manual CORS handling
+            app.use((req, res, next) => {
+                res.header('Access-Control-Allow-Origin', this.config.corsOrigins[0] || '*');
+                res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+                res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+                res.header('Access-Control-Allow-Credentials', 'true');
+                if (req.method === 'OPTIONS') {
+                    return res.sendStatus(200);
+                }
+                next();
+            });
+        }
+        // Register routes
+        this._registerRoutes(app);
+        return app;
+    }
+    /**
+     * Register API routes.
+     *
+     * @param app - Express app instance
+     */
+    _registerRoutes(app) {
+        const { apiPrefix } = this.config;
+        // GET / - Root info
+        app.get('/', (req, res) => {
+            res.json({
+                name: this.name,
+                status: 'running',
+                agents: this.agents.map(a => a.name || 'unnamed'),
+                teams: this.teams.length,
+                flows: this.flows.length,
+            });
+        });
+        // GET /health - Health check
+        app.get('/health', (req, res) => {
+            res.json({ status: 'healthy' });
+        });
+        // GET /api/agents - List agents
+        app.get(`${apiPrefix}/agents`, (req, res) => {
+            res.json({
+                agents: this.agents.map((agent, i) => ({
+                    name: agent.name || `agent_${i}`,
+                    role: agent.role || null,
+                    instructions: agent.instructions
+                        ? (agent.instructions.length > 100
+                            ? agent.instructions.substring(0, 100) + '...'
+                            : agent.instructions)
+                        : null,
+                })),
+            });
+        });
+        // POST /api/chat - Chat with an agent
+        app.post(`${apiPrefix}/chat`, async (req, res) => {
+            try {
+                const { message, agent_name, session_id } = req.body;
+                if (!message) {
+                    return res.status(400).json({ error: 'Message is required' });
+                }
+                // Find the agent
+                let agent;
+                if (agent_name) {
+                    agent = this.agents.find(a => a.name === agent_name);
+                    if (!agent) {
+                        return res.status(404).json({ error: `Agent '${agent_name}' not found` });
+                    }
+                }
+                else if (this.agents.length > 0) {
+                    agent = this.agents[0];
+                }
+                else {
+                    return res.status(400).json({ error: 'No agents available' });
+                }
+                // Call the agent
+                const response = await agent.chat(message);
+                const result = {
+                    response: String(response),
+                    agent_name: agent.name || 'unknown',
+                    session_id,
+                };
+                res.json(result);
+            }
+            catch (error) {
+                console.error('Chat error:', error);
+                res.status(500).json({ error: error.message || 'Internal server error' });
+            }
+        });
+        // GET /api/teams - List teams
+        app.get(`${apiPrefix}/teams`, (req, res) => {
+            res.json({
+                teams: this.teams.map((team, i) => ({
+                    name: `team_${i}`,
+                    agents: team.agents?.length || 0,
+                })),
+            });
+        });
+        // GET /api/flows - List flows
+        app.get(`${apiPrefix}/flows`, (req, res) => {
+            res.json({
+                flows: this.flows.map((flow, i) => ({
+                    name: flow.name || `flow_${i}`,
+                })),
+            });
+        });
+    }
+    /**
+     * Get the Express application instance.
+     *
+     * @returns The Express application instance for custom mounting or configuration
+     */
+    getApp() {
+        if (!this._app) {
+            this._app = this._createApp();
+        }
+        return this._app;
+    }
+    /**
+     * Start the AgentOS server.
+     *
+     * @param options - Server options
+     * @returns Promise that resolves when server is listening
+     */
+    async serve(options = {}) {
+        const host = options.host || this.config.host;
+        const port = options.port || this.config.port;
+        const app = this.getApp();
+        return new Promise((resolve, reject) => {
+            try {
+                this._server = app.listen(port, host, () => {
+                    console.log(`🚀 AgentOS "${this.name}" running at http://${host}:${port}`);
+                    console.log(`   Agents: ${this.agents.length}`);
+                    console.log(`   Teams: ${this.teams.length}`);
+                    console.log(`   Flows: ${this.flows.length}`);
+                    console.log(`   API: http://${host}:${port}${this.config.apiPrefix}`);
+                    resolve();
+                });
+                this._server.on('error', (error) => {
+                    reject(error);
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Stop the AgentOS server.
+     *
+     * @returns Promise that resolves when server is stopped
+     */
+    async stop() {
+        if (this._server) {
+            return new Promise((resolve) => {
+                this._server.close(() => {
+                    this._server = null;
+                    resolve();
+                });
+            });
+        }
+    }
+}
+exports.AgentOS = AgentOS;
+/**
+ * AgentApp - Silent alias for AgentOS (backward compatibility)
+ * @deprecated Use AgentOS instead
+ */
+exports.AgentApp = AgentOS;

package/dist/os/config.d.ts

@@ -0,0 +1,65 @@
+/**
+ * AgentOS Configuration
+ *
+ * This module defines the configuration interface for AgentOS.
+ * It follows PraisonAI's principle of sensible defaults with explicit overrides.
+ *
+ * @example
+ * ```typescript
+ * const config: AgentOSConfig = {
+ *   name: 'My AI App',
+ *   port: 9000,
+ *   debug: true
+ * };
+ * ```
+ */
+/**
+ * Configuration for AgentOS.
+ *
+ * All properties are optional with sensible defaults.
+ */
+export interface AgentOSConfig {
+    /** Name of the application (default: "PraisonAI App") */
+    name?: string;
+    /** Host address to bind to (default: "0.0.0.0") */
+    host?: string;
+    /** Port number to listen on (default: 8000) */
+    port?: number;
+    /** Enable auto-reload for development (default: false) */
+    reload?: boolean;
+    /** List of allowed CORS origins (default: ["*"]) */
+    corsOrigins?: string[];
+    /** API route prefix (default: "/api") */
+    apiPrefix?: string;
+    /** URL for API documentation (default: "/docs") */
+    docsUrl?: string;
+    /** URL for OpenAPI schema (default: "/openapi.json") */
+    openapiUrl?: string;
+    /** Enable debug mode (default: false) */
+    debug?: boolean;
+    /** Logging level (default: "info") */
+    logLevel?: 'debug' | 'info' | 'warn' | 'error';
+    /** Number of worker processes (default: 1) */
+    workers?: number;
+    /** Request timeout in seconds (default: 60) */
+    timeout?: number;
+    /** Additional metadata for the app */
+    metadata?: Record<string, any>;
+}
+/**
+ * Default configuration values for AgentOS.
+ */
+export declare const DEFAULT_AGENTOS_CONFIG: Required<Omit<AgentOSConfig, 'metadata'>> & {
+    metadata: Record<string, any>;
+};
+/**
+ * Merge user config with defaults.
+ */
+export declare function mergeConfig(userConfig?: AgentOSConfig): Required<Omit<AgentOSConfig, 'metadata'>> & {
+    metadata: Record<string, any>;
+};
+/**
+ * AgentAppConfig - Silent alias for AgentOSConfig (backward compatibility)
+ * @deprecated Use AgentOSConfig instead
+ */
+export type AgentAppConfig = AgentOSConfig;

package/dist/os/config.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * AgentOS Configuration
+ *
+ * This module defines the configuration interface for AgentOS.
+ * It follows PraisonAI's principle of sensible defaults with explicit overrides.
+ *
+ * @example
+ * ```typescript
+ * const config: AgentOSConfig = {
+ *   name: 'My AI App',
+ *   port: 9000,
+ *   debug: true
+ * };
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_AGENTOS_CONFIG = void 0;
+exports.mergeConfig = mergeConfig;
+/**
+ * Default configuration values for AgentOS.
+ */
+exports.DEFAULT_AGENTOS_CONFIG = {
+    name: 'PraisonAI App',
+    host: '0.0.0.0',
+    port: 8000,
+    reload: false,
+    corsOrigins: ['*'],
+    apiPrefix: '/api',
+    docsUrl: '/docs',
+    openapiUrl: '/openapi.json',
+    debug: false,
+    logLevel: 'info',
+    workers: 1,
+    timeout: 60,
+    metadata: {},
+};
+/**
+ * Merge user config with defaults.
+ */
+function mergeConfig(userConfig) {
+    return {
+        ...exports.DEFAULT_AGENTOS_CONFIG,
+        ...userConfig,
+        metadata: {
+            ...exports.DEFAULT_AGENTOS_CONFIG.metadata,
+            ...userConfig?.metadata,
+        },
+    };
+}

package/dist/os/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * App Module for Production Deployment of AI Agents
+ *
+ * This module provides AgentOS, a production platform for deploying
+ * agents as web services with REST endpoints.
+ *
+ * AgentOS, AgentOSConfig, AgentOSProtocol are the primary names (v1.0+).
+ * AgentApp, AgentAppConfig, AgentAppProtocol are silent aliases for backward compatibility.
+ *
+ * @example
+ * ```typescript
+ * import { AgentOS, Agent } from 'praisonai';
+ *
+ * const assistant = new Agent({
+ *   name: 'assistant',
+ *   instructions: 'Be helpful'
+ * });
+ *
+ * const app = new AgentOS({
+ *   name: 'My AI App',
+ *   agents: [assistant],
+ * });
+ *
+ * await app.serve({ port: 8000 });
+ * ```
+ */
+export { AgentOSConfig, AgentAppConfig, // Silent alias
+DEFAULT_AGENTOS_CONFIG, mergeConfig, } from './config';
+export { AgentOSProtocol, AgentAppProtocol, } from './protocols';
+export { AgentOS, AgentApp, // Silent alias
+AgentOSOptions, AgentAppOptions, } from './agentos';

package/dist/os/index.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * App Module for Production Deployment of AI Agents
+ *
+ * This module provides AgentOS, a production platform for deploying
+ * agents as web services with REST endpoints.
+ *
+ * AgentOS, AgentOSConfig, AgentOSProtocol are the primary names (v1.0+).
+ * AgentApp, AgentAppConfig, AgentAppProtocol are silent aliases for backward compatibility.
+ *
+ * @example
+ * ```typescript
+ * import { AgentOS, Agent } from 'praisonai';
+ *
+ * const assistant = new Agent({
+ *   name: 'assistant',
+ *   instructions: 'Be helpful'
+ * });
+ *
+ * const app = new AgentOS({
+ *   name: 'My AI App',
+ *   agents: [assistant],
+ * });
+ *
+ * await app.serve({ port: 8000 });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentApp = exports.AgentOS = exports.mergeConfig = exports.DEFAULT_AGENTOS_CONFIG = void 0;
+// Config
+var config_1 = require("./config");
+Object.defineProperty(exports, "DEFAULT_AGENTOS_CONFIG", { enumerable: true, get: function () { return config_1.DEFAULT_AGENTOS_CONFIG; } });
+Object.defineProperty(exports, "mergeConfig", { enumerable: true, get: function () { return config_1.mergeConfig; } });
+// Implementation
+var agentos_1 = require("./agentos");
+Object.defineProperty(exports, "AgentOS", { enumerable: true, get: function () { return agentos_1.AgentOS; } });
+Object.defineProperty(exports, "AgentApp", { enumerable: true, get: function () { return agentos_1.AgentApp; } });

package/dist/os/protocols.d.ts

@@ -0,0 +1,55 @@
+/**
+ * AgentOS Protocol Definitions
+ *
+ * This module defines the protocol (interface) for AgentOS implementations.
+ * The protocol is lightweight and lives in the core SDK.
+ *
+ * AgentOSProtocol is the primary name (v1.0+).
+ * AgentAppProtocol is a silent alias for backward compatibility.
+ *
+ * @example
+ * ```typescript
+ * import { AgentOSProtocol, AgentOSConfig } from 'praisonai';
+ *
+ * class CustomAgentOS implements AgentOSProtocol {
+ *   serve(options?: AgentOSConfig): Promise<void> { ... }
+ *   getApp(): any { ... }
+ * }
+ * ```
+ */
+/**
+ * Protocol for AgentOS implementations.
+ *
+ * AgentOS is a production platform for deploying agents as web services.
+ * It wraps agents, teams, and flows into a unified API server.
+ *
+ * Implementations should:
+ * - Provide HTTP endpoints for agent interaction
+ * - Support health checks and monitoring endpoints
+ * - Handle agent lifecycle management
+ * - Provide CORS support for web clients
+ */
+export interface AgentOSProtocol {
+    /**
+     * Start the AgentOS server.
+     *
+     * @param options - Server configuration options
+     * @returns Promise that resolves when server is ready
+     */
+    serve(options?: {
+        host?: string;
+        port?: number;
+        reload?: boolean;
+    }): Promise<void>;
+    /**
+     * Get the underlying web application instance.
+     *
+     * @returns The Express/HTTP application instance for custom mounting or configuration
+     */
+    getApp(): any;
+}
+/**
+ * AgentAppProtocol - Silent alias for AgentOSProtocol (backward compatibility)
+ * @deprecated Use AgentOSProtocol instead
+ */
+export type AgentAppProtocol = AgentOSProtocol;