overai 1.4.0

package/dist/agent/simple.js

@@ -0,0 +1,696 @@
+"use strict";
+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.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.messages = [];
+        this.dbInitialized = false;
+        this.responseCache = new Map();
+        // AI SDK backend support
+        this._backend = null;
+        this._backendPromise = null;
+        this._backendSource = 'legacy';
+        this._useAISDKBackend = false;
+        // 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 || 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 || this.generateSessionId();
+        this.runId = config.runId || (0, crypto_1.randomUUID)();
+        this.historyLimit = config.historyLimit ?? 100;
+        this.autoRestore = config.autoRestore ?? true;
+        this.autoPersist = config.autoPersist ?? true;
+        this.cache = config.cache ?? false;
+        this.cacheTTL = config.cacheTTL ?? 3600;
+        this.telemetryEnabled = config.telemetry ?? false;
+        // Parse model string to extract provider and model ID
+        // Format: "provider/model" or just "model"
+        const providerId = this.llm.includes('/') ? this.llm.split('/')[0] : 'openai';
+        const modelId = this.llm.includes('/') ? this.llm.split('/').slice(1).join('/') : this.llm;
+        // For OpenAI, use OpenAIService directly for backward compatibility
+        // For other providers, we'll use the AI SDK backend via getBackend()
+        this._useAISDKBackend = providerId !== 'openai';
+        this.llmService = new openai_1.OpenAIService(modelId);
+        // 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)) {
+                this.registerToolFunction(name, func);
+                // Auto-generate tool definition if not already provided
+                if (!this.hasToolDefinition(name)) {
+                    this.addAutoGeneratedToolDefinition(name, func);
+                }
+            }
+        }
+    }
+    /**
+     * Generate a unique session ID based on current hour, agent name, and random suffix
+     */
+    generateSessionId() {
+        const now = new Date();
+        const hourStr = now.toISOString().slice(0, 13).replace(/[-T:]/g, '');
+        const hash = this.name ? this.name.slice(0, 6) : 'agent';
+        const randomSuffix = (0, crypto_1.randomUUID)().slice(0, 8);
+        return `${hourStr}-${hash}-${randomSuffix}`;
+    }
+    /**
+     * Initialize DB session - restore history on first chat (lazy)
+     */
+    async initDbSession() {
+        if (this.dbInitialized || !this.dbAdapter || !this.autoRestore)
+            return;
+        try {
+            // Restore previous messages from DB
+            const history = await this.dbAdapter.getMessages(this.sessionId, this.historyLimit);
+            if (history.length > 0) {
+                this.messages = history.map(m => ({
+                    role: m.role,
+                    content: m.content
+                }));
+                logger_1.Logger.debug(`Restored ${history.length} messages from session ${this.sessionId}`);
+            }
+        }
+        catch (error) {
+            logger_1.Logger.warn('Failed to initialize DB session:', error);
+        }
+        this.dbInitialized = true;
+    }
+    /**
+     * Get cached response if available and not expired
+     */
+    getCachedResponse(prompt) {
+        if (!this.cache)
+            return null;
+        const cacheKey = `${this.sessionId}:${prompt}`;
+        const cached = this.responseCache.get(cacheKey);
+        if (cached) {
+            const age = (Date.now() - cached.timestamp) / 1000;
+            if (age < this.cacheTTL) {
+                logger_1.Logger.debug('Cache hit for prompt');
+                return cached.response;
+            }
+            // Expired, remove it
+            this.responseCache.delete(cacheKey);
+        }
+        return null;
+    }
+    /**
+     * Cache a response
+     */
+    cacheResponse(prompt, response) {
+        if (!this.cache)
+            return;
+        const cacheKey = `${this.sessionId}:${prompt}`;
+        this.responseCache.set(cacheKey, { response, timestamp: Date.now() });
+    }
+    createSystemPrompt() {
+        let prompt = this.instructions;
+        if (this.markdown) {
+            prompt += '\nPlease format your response in markdown.';
+        }
+        return prompt;
+    }
+    /**
+     * Register a tool function that can be called by the model
+     * @param name Function name
+     * @param fn Function implementation
+     */
+    registerToolFunction(name, fn) {
+        this.toolFunctions[name] = fn;
+        logger_1.Logger.debug(`Registered tool function: ${name}`);
+    }
+    /**
+     * Check if a tool definition exists for the given function name
+     * @param name Function name
+     * @returns True if a tool definition exists
+     */
+    hasToolDefinition(name) {
+        if (!this.tools)
+            return false;
+        return this.tools.some(tool => {
+            if (tool.type === 'function' && tool.function) {
+                return tool.function.name === name;
+            }
+            return false;
+        });
+    }
+    /**
+     * Auto-generate a tool definition based on the function
+     * @param name Function name
+     * @param func Function implementation
+     */
+    addAutoGeneratedToolDefinition(name, func) {
+        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(/\(([^)]*)\)/);
+        const params = paramMatch ? paramMatch[1].split(',').map(p => p.trim()).filter(p => p) : [];
+        // Create a basic tool definition
+        const toolDef = {
+            type: "function",
+            function: {
+                name: functionName,
+                description: `Auto-generated function for ${functionName}`,
+                parameters: {
+                    type: "object",
+                    properties: {},
+                    required: []
+                }
+            }
+        };
+        // Add parameters to the definition
+        if (params.length > 0) {
+            const properties = {};
+            const required = [];
+            params.forEach(param => {
+                // Remove type annotations if present
+                const paramName = param.split(':')[0].trim();
+                if (paramName) {
+                    properties[paramName] = {
+                        type: "string",
+                        description: `Parameter ${paramName} for function ${name}`
+                    };
+                    required.push(paramName);
+                }
+            });
+            toolDef.function.parameters.properties = properties;
+            toolDef.function.parameters.required = required;
+        }
+        this.tools.push(toolDef);
+        logger_1.Logger.debug(`Auto-generated tool definition for ${functionName}`);
+    }
+    /**
+     * Process tool calls from the model
+     * @param toolCalls Tool calls from the model
+     * @returns Array of tool results
+     */
+    async processToolCalls(toolCalls) {
+        const results = [];
+        for (const toolCall of toolCalls) {
+            const { id, function: { name, arguments: argsString } } = toolCall;
+            await logger_1.Logger.debug(`Processing tool call: ${name}`, { arguments: argsString });
+            try {
+                // Parse arguments
+                const args = JSON.parse(argsString);
+                // Check if function exists
+                if (!this.toolFunctions[name]) {
+                    throw new Error(`Function ${name} not registered`);
+                }
+                // Call the function
+                const result = await this.toolFunctions[name](...Object.values(args));
+                // Add result to messages
+                results.push({
+                    role: 'tool',
+                    tool_call_id: id,
+                    content: result.toString()
+                });
+                await logger_1.Logger.debug(`Tool call result for ${name}:`, { result });
+            }
+            catch (error) {
+                await logger_1.Logger.error(`Error executing tool ${name}:`, error);
+                results.push({
+                    role: 'tool',
+                    tool_call_id: id,
+                    content: `Error: ${error.message || 'Unknown error'}`
+                });
+            }
+        }
+        return results;
+    }
+    async start(prompt, previousResult) {
+        await logger_1.Logger.debug(`Agent ${this.name} starting with prompt: ${prompt}`);
+        try {
+            // Replace placeholder with previous result if available
+            if (previousResult) {
+                prompt = prompt.replace('{{previous}}', previousResult);
+            }
+            // Initialize messages array with system prompt and conversation history
+            const messages = [
+                { role: 'system', content: this.createSystemPrompt() }
+            ];
+            // Add conversation history (excluding the current prompt which will be added below)
+            for (const msg of this.messages) {
+                if (msg.role && msg.content) {
+                    messages.push({ role: msg.role, content: msg.content });
+                }
+            }
+            // Add current user prompt
+            messages.push({ role: 'user', content: prompt });
+            let finalResponse = '';
+            // Use AI SDK backend for non-OpenAI providers
+            if (this._useAISDKBackend) {
+                const backend = await this.getBackend();
+                if (this.stream && !this.tools) {
+                    // Streaming with AI SDK backend
+                    const stream = await backend.streamText({
+                        messages,
+                        temperature: 0.7
+                    });
+                    let accumulated = '';
+                    for await (const chunk of stream) {
+                        if (chunk.text) {
+                            process.stdout.write(chunk.text);
+                            accumulated += chunk.text;
+                        }
+                    }
+                    finalResponse = accumulated;
+                }
+                else {
+                    // Non-streaming with AI SDK backend
+                    const result = await backend.generateText({
+                        messages,
+                        temperature: 0.7
+                    });
+                    finalResponse = result.text;
+                }
+            }
+            else if (this.stream && !this.tools) {
+                // Use streaming with full conversation history (OpenAI)
+                finalResponse = await this.llmService.streamChat(messages, 0.7, (token) => {
+                    process.stdout.write(token);
+                });
+            }
+            else if (this.tools) {
+                // Use tools (non-streaming for now to simplify implementation)
+                let continueConversation = true;
+                let iterations = 0;
+                const maxIterations = 5; // Prevent infinite loops
+                while (continueConversation && iterations < maxIterations) {
+                    iterations++;
+                    // Get response from LLM
+                    const response = await this.llmService.generateChat(messages, 0.7, this.tools);
+                    // Add assistant response to messages
+                    messages.push({
+                        role: 'assistant',
+                        content: response.content || '',
+                        tool_calls: response.tool_calls
+                    });
+                    // Check if there are tool calls to process
+                    if (response.tool_calls && response.tool_calls.length > 0) {
+                        // Process tool calls
+                        const toolResults = await this.processToolCalls(response.tool_calls);
+                        // Add tool results to messages
+                        messages.push(...toolResults);
+                        // Continue conversation to get final response
+                        continueConversation = true;
+                    }
+                    else {
+                        // No tool calls, we have our final response
+                        finalResponse = response.content || '';
+                        continueConversation = false;
+                    }
+                }
+                if (iterations >= maxIterations) {
+                    await logger_1.Logger.warn(`Reached maximum iterations (${maxIterations}) for tool calls`);
+                }
+            }
+            else {
+                // Use regular text generation without streaming
+                const response = await this.llmService.generateText(prompt, this.createSystemPrompt());
+                finalResponse = response;
+            }
+            return finalResponse;
+        }
+        catch (error) {
+            await logger_1.Logger.error('Error in agent execution', error);
+            throw error;
+        }
+    }
+    async chat(prompt, previousResult) {
+        // Lazy init: restore history on first chat (like Python SDK)
+        await this.initDbSession();
+        // Check cache first
+        const cached = this.getCachedResponse(prompt);
+        if (cached) {
+            return cached;
+        }
+        // Add user message to conversation history
+        this.messages.push({ role: 'user', content: prompt });
+        // Persist user message if db is configured and autoPersist is enabled
+        if (this.dbAdapter && this.autoPersist) {
+            await this.persistMessage('user', prompt);
+        }
+        const response = await this.start(prompt, previousResult);
+        // Add assistant response to history
+        this.messages.push({ role: 'assistant', content: response });
+        // Persist assistant response if db is configured and autoPersist is enabled
+        if (this.dbAdapter && this.autoPersist) {
+            await this.persistMessage('assistant', response);
+        }
+        // Cache the response
+        this.cacheResponse(prompt, 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;
+    }
+    getInstructions() {
+        return this.instructions;
+    }
+    /**
+     * Get conversation history
+     */
+    getHistory() {
+        return [...this.messages];
+    }
+    /**
+     * Clear conversation history (in memory and optionally in DB)
+     */
+    async clearHistory(clearDb = true) {
+        this.messages = [];
+        if (clearDb && this.dbAdapter) {
+            try {
+                await this.dbAdapter.deleteMessages(this.sessionId);
+                logger_1.Logger.debug(`Cleared history for session ${this.sessionId}`);
+            }
+            catch (error) {
+                logger_1.Logger.warn('Failed to clear DB history:', error);
+            }
+        }
+    }
+    /**
+     * Clear response cache
+     */
+    clearCache() {
+        this.responseCache.clear();
+    }
+    /**
+     * Get the resolved backend (AI SDK preferred, native fallback)
+     * Lazy initialization - backend is only resolved on first use
+     */
+    async getBackend() {
+        if (this._backend) {
+            return this._backend;
+        }
+        if (!this._backendPromise) {
+            this._backendPromise = (async () => {
+                const { resolveBackend } = await Promise.resolve().then(() => __importStar(require('../llm/backend-resolver')));
+                const result = await resolveBackend(this.llm, {
+                    attribution: {
+                        agentId: this.name,
+                        runId: this.runId,
+                        sessionId: this.sessionId,
+                    },
+                });
+                this._backend = result.provider;
+                this._backendSource = result.source;
+                logger_1.Logger.debug(`Agent ${this.name} using ${result.source} backend for ${this.llm}`);
+                return result;
+            })();
+        }
+        const result = await this._backendPromise;
+        return result.provider;
+    }
+    /**
+     * Get the backend source (ai-sdk, native, custom, or legacy)
+     */
+    getBackendSource() {
+        return this._backendSource;
+    }
+    /**
+     * Embed text using AI SDK (preferred) or native provider
+     *
+     * @param text - Text to embed (string or array of strings)
+     * @param options - Embedding options
+     * @returns Embedding vector(s)
+     *
+     * @example Single text
+     * ```typescript
+     * const embedding = await agent.embed("Hello world");
+     * ```
+     *
+     * @example Multiple texts
+     * ```typescript
+     * const embeddings = await agent.embed(["Hello", "World"]);
+     * ```
+     */
+    async embed(text, options) {
+        const { embed, embedMany } = await Promise.resolve().then(() => __importStar(require('../llm/embeddings')));
+        if (Array.isArray(text)) {
+            const result = await embedMany(text, { model: options?.model });
+            return result.embeddings;
+        }
+        else {
+            const result = await embed(text, { model: options?.model });
+            return result.embedding;
+        }
+    }
+    /**
+     * Get the model string for this agent
+     */
+    getModel() {
+        return this.llm;
+    }
+}
+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 {
+    /**
+     * 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';
+        this.process = config.process || 'sequential';
+        // Auto-generate tasks if not provided
+        this.tasks = config.tasks || this.generateTasks();
+        // Configure logging
+        logger_1.Logger.setVerbose(this.verbose);
+        logger_1.Logger.setPretty(this.pretty);
+    }
+    generateTasks() {
+        return this.agents.map(agent => {
+            const instructions = agent.getInstructions();
+            // Extract task from instructions - get first sentence or whole instruction if no period
+            const task = instructions.split('.')[0].trim();
+            return task;
+        });
+    }
+    async executeSequential() {
+        const results = [];
+        let previousResult;
+        for (let i = 0; i < this.agents.length; i++) {
+            const agent = this.agents[i];
+            const task = this.tasks[i];
+            await logger_1.Logger.debug(`Running agent ${i + 1}: ${agent.name}`);
+            await logger_1.Logger.debug(`Task: ${task}`);
+            // For first agent, use task directly
+            // For subsequent agents, append previous result to their instructions
+            const prompt = i === 0 ? task : `${task}\n\nHere is the input: ${previousResult}`;
+            const result = await agent.start(prompt, previousResult);
+            results.push(result);
+            previousResult = result;
+        }
+        return results;
+    }
+    async start() {
+        await logger_1.Logger.debug('Starting PraisonAI Agents execution...');
+        await logger_1.Logger.debug('Process mode:', this.process);
+        await logger_1.Logger.debug('Tasks:', this.tasks);
+        let results;
+        if (this.process === 'parallel') {
+            // Run all agents in parallel
+            const promises = this.agents.map((agent, i) => {
+                const task = this.tasks[i];
+                return agent.start(task);
+            });
+            results = await Promise.all(promises);
+        }
+        else {
+            // Run agents sequentially (default)
+            results = await this.executeSequential();
+        }
+        if (this.verbose) {
+            await logger_1.Logger.info('PraisonAI Agents execution completed.');
+            for (let i = 0; i < results.length; i++) {
+                await logger_1.Logger.section(`Result from Agent ${i + 1}`, results[i]);
+            }
+        }
+        return results;
+    }
+    async chat() {
+        return this.start();
+    }
+}
+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;