praisonai 1.1.0 → 1.2.0

package/dist/agent/image.d.ts

@@ -0,0 +1,51 @@
+/**
+ * ImageAgent - Agent for image generation and analysis
+ */
+export interface ImageGenerationConfig {
+    prompt: string;
+    size?: '256x256' | '512x512' | '1024x1024' | '1792x1024' | '1024x1792';
+    quality?: 'standard' | 'hd';
+    style?: 'vivid' | 'natural';
+    n?: number;
+}
+export interface ImageAnalysisConfig {
+    imageUrl: string;
+    prompt?: string;
+    detail?: 'low' | 'high' | 'auto';
+}
+export interface ImageAgentConfig {
+    name?: string;
+    llm?: string;
+    imageModel?: string;
+    verbose?: boolean;
+}
+/**
+ * ImageAgent - Agent for image generation and analysis
+ */
+export declare class ImageAgent {
+    readonly name: string;
+    private provider;
+    private imageModel;
+    private verbose;
+    constructor(config?: ImageAgentConfig);
+    /**
+     * Analyze an image
+     */
+    analyze(config: ImageAnalysisConfig): Promise<string>;
+    /**
+     * Generate an image (requires OpenAI DALL-E)
+     */
+    generate(config: ImageGenerationConfig): Promise<string[]>;
+    /**
+     * Chat with image context
+     */
+    chat(prompt: string, imageUrl?: string): Promise<string>;
+    /**
+     * Compare two images
+     */
+    compare(imageUrl1: string, imageUrl2: string, prompt?: string): Promise<string>;
+}
+/**
+ * Create an ImageAgent
+ */
+export declare function createImageAgent(config?: ImageAgentConfig): ImageAgent;

package/dist/agent/image.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * ImageAgent - Agent for image generation and analysis
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageAgent = void 0;
+exports.createImageAgent = createImageAgent;
+const providers_1 = require("../llm/providers");
+/**
+ * ImageAgent - Agent for image generation and analysis
+ */
+class ImageAgent {
+    constructor(config = {}) {
+        this.name = config.name || `ImageAgent_${Math.random().toString(36).substr(2, 9)}`;
+        this.provider = (0, providers_1.createProvider)(config.llm || 'openai/gpt-4o-mini');
+        this.imageModel = config.imageModel || 'dall-e-3';
+        this.verbose = config.verbose ?? false;
+    }
+    /**
+     * Analyze an image
+     */
+    async analyze(config) {
+        const prompt = config.prompt || 'Describe this image in detail.';
+        const messages = [
+            {
+                role: 'user',
+                content: [
+                    { type: 'text', text: prompt },
+                    {
+                        type: 'image_url',
+                        image_url: {
+                            url: config.imageUrl,
+                            detail: config.detail || 'auto'
+                        }
+                    }
+                ]
+            }
+        ];
+        const result = await this.provider.generateText({ messages });
+        if (this.verbose) {
+            console.log(`[ImageAgent] Analysis: ${result.text.substring(0, 100)}...`);
+        }
+        return result.text;
+    }
+    /**
+     * Generate an image (requires OpenAI DALL-E)
+     */
+    async generate(config) {
+        // This would require direct OpenAI API call for image generation
+        // For now, return a placeholder
+        if (this.verbose) {
+            console.log(`[ImageAgent] Generating image: ${config.prompt}`);
+        }
+        throw new Error('Image generation requires direct OpenAI API integration. Use the OpenAI SDK directly for DALL-E.');
+    }
+    /**
+     * Chat with image context
+     */
+    async chat(prompt, imageUrl) {
+        if (imageUrl) {
+            return this.analyze({ imageUrl, prompt });
+        }
+        const result = await this.provider.generateText({
+            messages: [{ role: 'user', content: prompt }]
+        });
+        return result.text;
+    }
+    /**
+     * Compare two images
+     */
+    async compare(imageUrl1, imageUrl2, prompt) {
+        const comparePrompt = prompt || 'Compare these two images and describe the differences and similarities.';
+        const messages = [
+            {
+                role: 'user',
+                content: [
+                    { type: 'text', text: comparePrompt },
+                    { type: 'image_url', image_url: { url: imageUrl1 } },
+                    { type: 'image_url', image_url: { url: imageUrl2 } }
+                ]
+            }
+        ];
+        const result = await this.provider.generateText({ messages });
+        return result.text;
+    }
+}
+exports.ImageAgent = ImageAgent;
+/**
+ * Create an ImageAgent
+ */
+function createImageAgent(config) {
+    return new ImageAgent(config);
+}

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

@@ -0,0 +1,40 @@
+/**
+ * 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 defaultStrategy;
+    private verbose;
+    constructor(config?: PromptExpanderConfig);
+    /**
+     * 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,84 @@
+"use strict";
+/**
+ * PromptExpanderAgent - Expand and enhance prompts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptExpanderAgent = void 0;
+exports.createPromptExpanderAgent = createPromptExpanderAgent;
+const providers_1 = require("../llm/providers");
+/**
+ * PromptExpanderAgent - Expand prompts with more detail and context
+ */
+class PromptExpanderAgent {
+    constructor(config = {}) {
+        this.name = config.name || `PromptExpander_${Math.random().toString(36).substr(2, 9)}`;
+        this.provider = (0, providers_1.createProvider)(config.llm || 'openai/gpt-4o-mini');
+        this.defaultStrategy = config.defaultStrategy || 'auto';
+        this.verbose = config.verbose ?? false;
+    }
+    /**
+     * 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 result = await this.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/query-rewriter.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 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 defaultStrategy;
+    private verbose;
+    constructor(config?: QueryRewriterConfig);
+    /**
+     * 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,79 @@
+"use strict";
+/**
+ * QueryRewriterAgent - Rewrite and optimize queries
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryRewriterAgent = void 0;
+exports.createQueryRewriterAgent = createQueryRewriterAgent;
+const providers_1 = require("../llm/providers");
+/**
+ * QueryRewriterAgent - Optimize and rewrite queries
+ */
+class QueryRewriterAgent {
+    constructor(config = {}) {
+        this.name = config.name || `QueryRewriter_${Math.random().toString(36).substr(2, 9)}`;
+        this.provider = (0, providers_1.createProvider)(config.llm || 'openai/gpt-4o-mini');
+        this.defaultStrategy = config.defaultStrategy || 'auto';
+        this.verbose = config.verbose ?? false;
+    }
+    /**
+     * 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 result = await this.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,52 @@
+/**
+ * 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 maxIterations;
+    private searchTool?;
+    private verbose;
+    constructor(config?: DeepResearchConfig);
+    /**
+     * 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;

package/dist/agent/research.js

@@ -0,0 +1,118 @@
+"use strict";
+/**
+ * DeepResearchAgent - Agent for comprehensive research tasks
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeepResearchAgent = void 0;
+exports.createDeepResearchAgent = createDeepResearchAgent;
+const providers_1 = require("../llm/providers");
+/**
+ * DeepResearchAgent - Comprehensive research with citations
+ */
+class DeepResearchAgent {
+    constructor(config = {}) {
+        this.name = config.name || `ResearchAgent_${Math.random().toString(36).substr(2, 9)}`;
+        this.provider = (0, providers_1.createProvider)(config.llm || 'openai/gpt-4o-mini');
+        this.maxIterations = config.maxIterations ?? 5;
+        this.searchTool = config.searchTool;
+        this.verbose = config.verbose ?? false;
+    }
+    /**
+     * Conduct deep research on a topic
+     */
+    async research(query) {
+        const reasoning = [];
+        const citations = [];
+        let iteration = 0;
+        // Step 1: Analyze the query
+        reasoning.push({
+            step: ++iteration,
+            thought: `Analyzing research query: "${query}"`,
+            action: 'query_analysis'
+        });
+        // Step 2: Generate search queries
+        const searchQueries = await this.generateSearchQueries(query);
+        reasoning.push({
+            step: ++iteration,
+            thought: `Generated ${searchQueries.length} search queries`,
+            action: 'generate_queries',
+            result: searchQueries.join(', ')
+        });
+        // Step 3: Execute searches if tool available
+        if (this.searchTool) {
+            for (const sq of searchQueries.slice(0, 3)) {
+                try {
+                    const results = await this.searchTool(sq);
+                    citations.push(...results);
+                    reasoning.push({
+                        step: ++iteration,
+                        thought: `Searched for: "${sq}"`,
+                        action: 'web_search',
+                        result: `Found ${results.length} results`
+                    });
+                }
+                catch (error) {
+                    if (this.verbose) {
+                        console.log(`[Research] Search failed for: ${sq}`);
+                    }
+                }
+            }
+        }
+        // Step 4: Synthesize answer
+        const answer = await this.synthesizeAnswer(query, citations);
+        reasoning.push({
+            step: ++iteration,
+            thought: 'Synthesizing final answer from gathered information',
+            action: 'synthesize',
+            result: 'Answer generated'
+        });
+        // Calculate confidence based on citations
+        const confidence = Math.min(0.5 + (citations.length * 0.1), 0.95);
+        return {
+            answer,
+            citations,
+            reasoning,
+            confidence
+        };
+    }
+    async generateSearchQueries(query) {
+        const result = await this.provider.generateText({
+            messages: [
+                {
+                    role: 'system',
+                    content: 'Generate 3 search queries to research this topic. Output only the queries, one per line.'
+                },
+                { role: 'user', content: query }
+            ]
+        });
+        return result.text.split('\n').filter(q => q.trim().length > 0).slice(0, 3);
+    }
+    async synthesizeAnswer(query, citations) {
+        const context = citations.length > 0
+            ? `\n\nRelevant sources:\n${citations.map(c => `- ${c.title}: ${c.snippet || ''}`).join('\n')}`
+            : '';
+        const result = await this.provider.generateText({
+            messages: [
+                {
+                    role: 'system',
+                    content: 'You are a research assistant. Provide a comprehensive, well-structured answer based on the available information. Cite sources when available.'
+                },
+                { role: 'user', content: `${query}${context}` }
+            ]
+        });
+        return result.text;
+    }
+    /**
+     * Set search tool
+     */
+    setSearchTool(tool) {
+        this.searchTool = tool;
+    }
+}
+exports.DeepResearchAgent = DeepResearchAgent;
+/**
+ * Create a DeepResearchAgent
+ */
+function createDeepResearchAgent(config) {
+    return new DeepResearchAgent(config);
+}

package/dist/auto/index.d.ts

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