overai 1.4.0

package/dist/agent/index.js

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

package/dist/agent/prompt-expander.d.ts

@@ -0,0 +1,43 @@
+/**
+ * PromptExpanderAgent - Expand and enhance prompts
+ */
+export type ExpandStrategy = 'detail' | 'context' | 'examples' | 'constraints' | 'auto';
+export interface ExpandResult {
+    original: string;
+    expanded: string;
+    strategy: ExpandStrategy;
+    additions: string[];
+}
+export interface PromptExpanderConfig {
+    name?: string;
+    llm?: string;
+    defaultStrategy?: ExpandStrategy;
+    verbose?: boolean;
+}
+/**
+ * PromptExpanderAgent - Expand prompts with more detail and context
+ */
+export declare class PromptExpanderAgent {
+    readonly name: string;
+    private provider;
+    private providerPromise;
+    private llmModel;
+    private defaultStrategy;
+    private verbose;
+    constructor(config?: PromptExpanderConfig);
+    private getProvider;
+    /**
+     * Expand a prompt
+     */
+    expand(prompt: string, strategy?: ExpandStrategy): Promise<ExpandResult>;
+    /**
+     * Detect the best expansion strategy
+     */
+    detectStrategy(prompt: string): ExpandStrategy;
+    private getSystemPrompt;
+    private extractAdditions;
+}
+/**
+ * Create a PromptExpanderAgent
+ */
+export declare function createPromptExpanderAgent(config?: PromptExpanderConfig): PromptExpanderAgent;

package/dist/agent/prompt-expander.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * PromptExpanderAgent - Expand and enhance prompts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptExpanderAgent = void 0;
+exports.createPromptExpanderAgent = createPromptExpanderAgent;
+const backend_resolver_1 = require("../llm/backend-resolver");
+/**
+ * PromptExpanderAgent - Expand prompts with more detail and context
+ */
+class PromptExpanderAgent {
+    constructor(config = {}) {
+        this.provider = null;
+        this.providerPromise = null;
+        this.name = config.name || `PromptExpander_${Math.random().toString(36).substr(2, 9)}`;
+        this.llmModel = config.llm || 'openai/gpt-4o-mini';
+        this.defaultStrategy = config.defaultStrategy || 'auto';
+        this.verbose = config.verbose ?? false;
+    }
+    async getProvider() {
+        if (this.provider)
+            return this.provider;
+        if (!this.providerPromise) {
+            this.providerPromise = (async () => {
+                const result = await (0, backend_resolver_1.resolveBackend)(this.llmModel, { attribution: { agentId: this.name } });
+                this.provider = result.provider;
+                return result.provider;
+            })();
+        }
+        return this.providerPromise;
+    }
+    /**
+     * Expand a prompt
+     */
+    async expand(prompt, strategy) {
+        const useStrategy = strategy || this.defaultStrategy;
+        const actualStrategy = useStrategy === 'auto' ? this.detectStrategy(prompt) : useStrategy;
+        const systemPrompt = this.getSystemPrompt(actualStrategy);
+        const provider = await this.getProvider();
+        const result = await provider.generateText({
+            messages: [
+                { role: 'system', content: systemPrompt },
+                { role: 'user', content: `Expand this prompt: ${prompt}` }
+            ]
+        });
+        const expanded = result.text;
+        const additions = this.extractAdditions(prompt, expanded);
+        if (this.verbose) {
+            console.log(`[PromptExpander] Strategy: ${actualStrategy}, Added ${additions.length} elements`);
+        }
+        return {
+            original: prompt,
+            expanded,
+            strategy: actualStrategy,
+            additions
+        };
+    }
+    /**
+     * Detect the best expansion strategy
+     */
+    detectStrategy(prompt) {
+        const words = prompt.split(/\s+/).length;
+        const lower = prompt.toLowerCase();
+        if (words < 5)
+            return 'detail';
+        if (lower.includes('why') || lower.includes('explain') || lower.includes('context'))
+            return 'context';
+        if (lower.includes('example') || lower.includes('show') || lower.includes('demonstrate'))
+            return 'examples';
+        if (lower.includes('must') || lower.includes('should') || lower.includes('require'))
+            return 'constraints';
+        return 'detail';
+    }
+    getSystemPrompt(strategy) {
+        const prompts = {
+            detail: 'Expand this prompt by adding specific details, requirements, and clarifications. Make it more precise and actionable.',
+            context: 'Expand this prompt by adding relevant background context, explaining the purpose, and providing necessary information.',
+            examples: 'Expand this prompt by adding concrete examples, sample inputs/outputs, and demonstrations of expected behavior.',
+            constraints: 'Expand this prompt by adding explicit constraints, requirements, limitations, and success criteria.',
+            auto: 'Expand this prompt to make it clearer, more specific, and more actionable. Add relevant details and context.'
+        };
+        return prompts[strategy];
+    }
+    extractAdditions(original, expanded) {
+        const originalWords = new Set(original.toLowerCase().split(/\s+/));
+        const expandedWords = expanded.toLowerCase().split(/\s+/);
+        const newWords = expandedWords.filter(w => !originalWords.has(w) && w.length > 3);
+        const uniqueNew = [...new Set(newWords)];
+        return uniqueNew.slice(0, 10);
+    }
+}
+exports.PromptExpanderAgent = PromptExpanderAgent;
+/**
+ * Create a PromptExpanderAgent
+ */
+function createPromptExpanderAgent(config) {
+    return new PromptExpanderAgent(config);
+}

package/dist/agent/proxy.d.ts

@@ -0,0 +1,26 @@
+import { SimpleAgentConfig } from './simple';
+import { TaskAgentConfig } from './types';
+import { Task } from './types';
+export interface ProxyAgentConfig extends Partial<SimpleAgentConfig>, Partial<TaskAgentConfig> {
+    task?: Task;
+    tools?: any[];
+    toolFunctions?: Record<string, Function>;
+}
+export declare class Agent {
+    private simpleAgent;
+    private taskAgent;
+    private instructions;
+    constructor(config: ProxyAgentConfig);
+    getInstructions(): string;
+    execute(input: Task | string): Promise<any>;
+    start(prompt: string, previousResult?: string): Promise<string>;
+    chat(prompt: string, previousResult?: string): Promise<string>;
+}
+export declare class PraisonAIAgents {
+    private simpleImpl;
+    private taskImpl;
+    constructor(config: any);
+    start(): Promise<string[]>;
+    chat(): Promise<string[]>;
+}
+export { Task } from './types';

package/dist/agent/proxy.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Task = exports.PraisonAIAgents = exports.Agent = void 0;
+const simple_1 = require("./simple");
+const types_1 = require("./types");
+const types_2 = require("./types");
+class Agent {
+    constructor(config) {
+        this.simpleAgent = null;
+        this.taskAgent = null;
+        this.instructions = config.instructions || '';
+        // Auto-detect mode based on task presence
+        if (config.task) {
+            const taskConfig = {
+                name: config.name || 'TaskAgent',
+                role: config.role || 'Assistant',
+                goal: config.goal || 'Help complete the task',
+                backstory: config.backstory || 'You are an AI assistant',
+                verbose: config.verbose,
+                llm: config.llm,
+                markdown: config.markdown
+            };
+            this.taskAgent = new types_1.Agent(taskConfig);
+        }
+        else {
+            const simpleConfig = {
+                instructions: this.instructions,
+                name: config.name,
+                verbose: config.verbose,
+                llm: config.llm,
+                markdown: config.markdown,
+                tools: config.tools,
+                toolFunctions: config.toolFunctions
+            };
+            this.simpleAgent = new simple_1.Agent(simpleConfig);
+        }
+        // Register tool functions if provided
+        if (config.tools && this.simpleAgent) {
+            // Look for tool functions in the global scope
+            for (const tool of config.tools) {
+                if (tool.type === 'function' && tool.function && tool.function.name) {
+                    const funcName = tool.function.name;
+                    // Check if function exists in global scope using a safer approach
+                    const globalAny = global;
+                    if (typeof globalAny[funcName] === 'function') {
+                        this.simpleAgent.registerToolFunction(funcName, globalAny[funcName]);
+                    }
+                    else if (typeof globalAny['get_' + funcName] === 'function') {
+                        // Try with 'get_' prefix (common convention)
+                        this.simpleAgent.registerToolFunction(funcName, globalAny['get_' + funcName]);
+                    }
+                    else {
+                        // Try to find the function in the global scope by iterating through all properties
+                        for (const key in globalAny) {
+                            if (key.toLowerCase() === funcName.toLowerCase() ||
+                                key.toLowerCase() === 'get_' + funcName.toLowerCase()) {
+                                if (typeof globalAny[key] === 'function') {
+                                    this.simpleAgent.registerToolFunction(funcName, globalAny[key]);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    getInstructions() {
+        return this.instructions;
+    }
+    async execute(input) {
+        if (this.taskAgent) {
+            const task = input;
+            const depResults = task.dependencies.map(dep => dep.result);
+            return this.taskAgent.execute(task, depResults);
+        }
+        else if (this.simpleAgent) {
+            return this.simpleAgent.execute(input);
+        }
+        throw new Error('No agent implementation available');
+    }
+    async start(prompt, previousResult) {
+        if (this.simpleAgent) {
+            return this.simpleAgent.start(prompt, previousResult);
+        }
+        else if (this.taskAgent) {
+            // For task agents, we'll use execute but wrap the prompt in a simple task
+            const task = new types_2.Task({
+                name: 'Start Task',
+                description: prompt,
+                expected_output: 'A response to the prompt',
+                dependencies: []
+            });
+            return this.taskAgent.execute(task, [previousResult]);
+        }
+        throw new Error('No agent implementation available');
+    }
+    async chat(prompt, previousResult) {
+        if (this.simpleAgent) {
+            return this.simpleAgent.chat(prompt, previousResult);
+        }
+        else if (this.taskAgent) {
+            // For task agents, we'll use execute but wrap the prompt in a simple task
+            const task = new types_2.Task({
+                name: 'Chat Task',
+                description: prompt,
+                expected_output: 'A response to the chat prompt',
+                dependencies: []
+            });
+            return this.taskAgent.execute(task, [previousResult]);
+        }
+        throw new Error('No agent implementation available');
+    }
+}
+exports.Agent = Agent;
+class PraisonAIAgents {
+    constructor(config) {
+        this.simpleImpl = null;
+        this.taskImpl = null;
+        // Auto-detect mode based on tasks type
+        if (Array.isArray(config.tasks)) {
+            // If tasks are provided and are strings, use simple mode
+            if (config.tasks.length > 0 && typeof config.tasks[0] === 'string') {
+                this.simpleImpl = new simple_1.PraisonAIAgents({
+                    agents: config.agents,
+                    tasks: config.tasks,
+                    verbose: config.verbose,
+                    process: config.process
+                });
+            }
+            else if (config.tasks.length > 0) {
+                // If tasks are provided but not strings, use task mode
+                this.taskImpl = new types_1.PraisonAIAgents({
+                    agents: config.agents,
+                    tasks: config.tasks,
+                    verbose: config.verbose,
+                    process: config.process,
+                    manager_llm: config.manager_llm
+                });
+            }
+        }
+        // If no tasks provided, create simple implementation with auto-generated tasks
+        if (!this.simpleImpl && !this.taskImpl) {
+            this.simpleImpl = new simple_1.PraisonAIAgents({
+                agents: config.agents,
+                verbose: config.verbose,
+                process: config.process
+            });
+        }
+    }
+    async start() {
+        if (this.simpleImpl) {
+            return this.simpleImpl.start();
+        }
+        else if (this.taskImpl) {
+            return this.taskImpl.start();
+        }
+        throw new Error('No implementation available');
+    }
+    async chat() {
+        if (this.simpleImpl) {
+            return this.simpleImpl.chat();
+        }
+        else if (this.taskImpl) {
+            // For task-based implementation, start() is equivalent to chat()
+            return this.taskImpl.start();
+        }
+        throw new Error('No implementation available');
+    }
+}
+exports.PraisonAIAgents = PraisonAIAgents;
+var types_3 = require("./types");
+Object.defineProperty(exports, "Task", { enumerable: true, get: function () { return types_3.Task; } });

package/dist/agent/query-rewriter.d.ts

@@ -0,0 +1,41 @@
+/**
+ * QueryRewriterAgent - Rewrite and optimize queries
+ */
+export type RewriteStrategy = 'expand' | 'simplify' | 'decompose' | 'rephrase' | 'auto';
+export interface RewriteResult {
+    original: string;
+    rewritten: string[];
+    strategy: RewriteStrategy;
+    confidence: number;
+}
+export interface QueryRewriterConfig {
+    name?: string;
+    llm?: string;
+    defaultStrategy?: RewriteStrategy;
+    verbose?: boolean;
+}
+/**
+ * QueryRewriterAgent - Optimize and rewrite queries
+ */
+export declare class QueryRewriterAgent {
+    readonly name: string;
+    private provider;
+    private providerPromise;
+    private llmModel;
+    private defaultStrategy;
+    private verbose;
+    constructor(config?: QueryRewriterConfig);
+    private getProvider;
+    /**
+     * Rewrite a query
+     */
+    rewrite(query: string, strategy?: RewriteStrategy): Promise<RewriteResult>;
+    private detectStrategy;
+    private getSystemPrompt;
+    private buildPrompt;
+    private parseRewrittenQueries;
+}
+/**
+ * Create a QueryRewriterAgent
+ */
+export declare function createQueryRewriterAgent(config?: QueryRewriterConfig): QueryRewriterAgent;

package/dist/agent/query-rewriter.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * QueryRewriterAgent - Rewrite and optimize queries
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryRewriterAgent = void 0;
+exports.createQueryRewriterAgent = createQueryRewriterAgent;
+const backend_resolver_1 = require("../llm/backend-resolver");
+/**
+ * QueryRewriterAgent - Optimize and rewrite queries
+ */
+class QueryRewriterAgent {
+    constructor(config = {}) {
+        this.provider = null;
+        this.providerPromise = null;
+        this.name = config.name || `QueryRewriter_${Math.random().toString(36).substr(2, 9)}`;
+        this.llmModel = config.llm || 'openai/gpt-4o-mini';
+        this.defaultStrategy = config.defaultStrategy || 'auto';
+        this.verbose = config.verbose ?? false;
+    }
+    async getProvider() {
+        if (this.provider)
+            return this.provider;
+        if (!this.providerPromise) {
+            this.providerPromise = (async () => {
+                const result = await (0, backend_resolver_1.resolveBackend)(this.llmModel, { attribution: { agentId: this.name } });
+                this.provider = result.provider;
+                return result.provider;
+            })();
+        }
+        return this.providerPromise;
+    }
+    /**
+     * Rewrite a query
+     */
+    async rewrite(query, strategy) {
+        const useStrategy = strategy || this.defaultStrategy;
+        const actualStrategy = useStrategy === 'auto' ? this.detectStrategy(query) : useStrategy;
+        const prompt = this.buildPrompt(query, actualStrategy);
+        const provider = await this.getProvider();
+        const result = await provider.generateText({
+            messages: [
+                { role: 'system', content: this.getSystemPrompt(actualStrategy) },
+                { role: 'user', content: prompt }
+            ]
+        });
+        const rewritten = this.parseRewrittenQueries(result.text);
+        if (this.verbose) {
+            console.log(`[QueryRewriter] Strategy: ${actualStrategy}, Rewrites: ${rewritten.length}`);
+        }
+        return {
+            original: query,
+            rewritten,
+            strategy: actualStrategy,
+            confidence: rewritten.length > 0 ? 0.85 : 0.5
+        };
+    }
+    detectStrategy(query) {
+        const words = query.split(/\s+/).length;
+        if (words < 3)
+            return 'expand';
+        if (words > 20)
+            return 'simplify';
+        if (query.includes(' and ') || query.includes(' or '))
+            return 'decompose';
+        return 'rephrase';
+    }
+    getSystemPrompt(strategy) {
+        const prompts = {
+            expand: 'Expand this query with more context and detail. Generate 3 expanded versions.',
+            simplify: 'Simplify this query to its core intent. Generate 3 simpler versions.',
+            decompose: 'Break this query into smaller, focused sub-queries. Generate 3-5 sub-queries.',
+            rephrase: 'Rephrase this query in different ways while keeping the same meaning. Generate 3 versions.',
+            auto: 'Optimize this query for better search results. Generate 3 improved versions.'
+        };
+        return prompts[strategy] + ' Output one query per line.';
+    }
+    buildPrompt(query, strategy) {
+        return `Query: ${query}\n\nRewrite using ${strategy} strategy:`;
+    }
+    parseRewrittenQueries(response) {
+        return response
+            .split('\n')
+            .map(line => line.replace(/^\d+[\.\)]\s*/, '').trim())
+            .filter(line => line.length > 0 && line.length < 500);
+    }
+}
+exports.QueryRewriterAgent = QueryRewriterAgent;
+/**
+ * Create a QueryRewriterAgent
+ */
+function createQueryRewriterAgent(config) {
+    return new QueryRewriterAgent(config);
+}

package/dist/agent/research.d.ts

@@ -0,0 +1,55 @@
+/**
+ * DeepResearchAgent - Agent for comprehensive research tasks
+ */
+export interface Citation {
+    title: string;
+    url: string;
+    snippet?: string;
+}
+export interface ReasoningStep {
+    step: number;
+    thought: string;
+    action?: string;
+    result?: string;
+}
+export interface ResearchResponse {
+    answer: string;
+    citations: Citation[];
+    reasoning: ReasoningStep[];
+    confidence: number;
+}
+export interface DeepResearchConfig {
+    name?: string;
+    llm?: string;
+    maxIterations?: number;
+    searchTool?: (query: string) => Promise<Citation[]>;
+    verbose?: boolean;
+}
+/**
+ * DeepResearchAgent - Comprehensive research with citations
+ */
+export declare class DeepResearchAgent {
+    readonly name: string;
+    private provider;
+    private providerPromise;
+    private llmModel;
+    private maxIterations;
+    private searchTool?;
+    private verbose;
+    constructor(config?: DeepResearchConfig);
+    private getProvider;
+    /**
+     * Conduct deep research on a topic
+     */
+    research(query: string): Promise<ResearchResponse>;
+    private generateSearchQueries;
+    private synthesizeAnswer;
+    /**
+     * Set search tool
+     */
+    setSearchTool(tool: (query: string) => Promise<Citation[]>): void;
+}
+/**
+ * Create a DeepResearchAgent
+ */
+export declare function createDeepResearchAgent(config?: DeepResearchConfig): DeepResearchAgent;