overai 1.4.0

package/dist/agent/research.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * DeepResearchAgent - Agent for comprehensive research tasks
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeepResearchAgent = void 0;
+exports.createDeepResearchAgent = createDeepResearchAgent;
+const backend_resolver_1 = require("../llm/backend-resolver");
+/**
+ * DeepResearchAgent - Comprehensive research with citations
+ */
+class DeepResearchAgent {
+    constructor(config = {}) {
+        this.provider = null;
+        this.providerPromise = null;
+        this.name = config.name || `ResearchAgent_${Math.random().toString(36).substr(2, 9)}`;
+        this.llmModel = config.llm || 'openai/gpt-4o-mini';
+        this.maxIterations = config.maxIterations ?? 5;
+        this.searchTool = config.searchTool;
+        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;
+    }
+    /**
+     * 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 provider = await this.getProvider();
+        const result = await 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 provider = await this.getProvider();
+        const result = await 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/agent/router.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Router Agent - Route requests to specialized agents
+ *
+ * @example Simple usage (5 lines)
+ * ```typescript
+ * import { Agent, Router } from 'praisonai';
+ *
+ * const router = new Router({
+ *   math: { agent: new Agent({ instructions: 'Math expert' }), keywords: ['calculate', 'math'] },
+ *   code: { agent: new Agent({ instructions: 'Code expert' }), keywords: ['code', 'program'] }
+ * });
+ * await router.chat('Calculate 2+2');  // Routes to math agent
+ * ```
+ */
+import type { EnhancedAgent } from './enhanced';
+import { Agent } from './simple';
+type AnyAgent = Agent | EnhancedAgent;
+export interface RouteConfig {
+    agent: AnyAgent;
+    condition: (input: string, context?: RouteContext) => boolean | Promise<boolean>;
+    priority?: number;
+}
+/** Simplified route definition */
+export interface SimpleRouteConfig {
+    agent: AnyAgent;
+    keywords?: string[];
+    pattern?: RegExp;
+    priority?: number;
+}
+export interface RouteContext {
+    history?: string[];
+    metadata?: Record<string, any>;
+}
+export interface RouterConfig {
+    name?: string;
+    routes: RouteConfig[];
+    defaultAgent?: AnyAgent;
+    verbose?: boolean;
+}
+/** Simplified router config - just a map of route name to config */
+export type SimpleRouterConfig = Record<string, SimpleRouteConfig>;
+/**
+ * Router Agent - Routes requests to the most appropriate agent
+ */
+export declare class RouterAgent {
+    readonly name: string;
+    private routes;
+    private defaultAgent?;
+    private verbose;
+    constructor(config: RouterConfig);
+    /**
+     * Route a request to the appropriate agent
+     */
+    route(input: string, context?: RouteContext): Promise<{
+        agent: AnyAgent;
+        response: string;
+    } | null>;
+    /**
+     * Simplified chat method - routes and returns just the response
+     */
+    chat(input: string, context?: RouteContext): Promise<string>;
+    /**
+     * Add a route
+     */
+    addRoute(config: RouteConfig): this;
+    /**
+     * Get all routes
+     */
+    getRoutes(): RouteConfig[];
+}
+/**
+ * Route condition helpers
+ */
+export declare const routeConditions: {
+    /**
+     * Match by keywords
+     */
+    keywords: (keywords: string | string[]) => (input: string) => boolean;
+    /**
+     * Match by regex
+     */
+    pattern: (regex: RegExp) => (input: string) => boolean;
+    /**
+     * Match by metadata
+     */
+    metadata: (key: string, value: any) => (_input: string, context?: RouteContext) => boolean;
+    /**
+     * Always match (for default routes)
+     */
+    always: () => () => boolean;
+    /**
+     * Combine conditions with AND
+     */
+    and: (...conditions: Array<(input: string, context?: RouteContext) => boolean>) => (input: string, context?: RouteContext) => boolean;
+    /**
+     * Combine conditions with OR
+     */
+    or: (...conditions: Array<(input: string, context?: RouteContext) => boolean>) => (input: string, context?: RouteContext) => boolean;
+};
+/**
+ * Create a router agent (legacy API)
+ */
+export declare function createRouter(config: RouterConfig): RouterAgent;
+/**
+ * Simplified Router class - uses keyword/pattern-based routing
+ *
+ * @example Simple usage (5 lines)
+ * ```typescript
+ * import { Agent, Router } from 'praisonai';
+ *
+ * const router = new Router({
+ *   math: { agent: new Agent({ instructions: 'Math expert' }), keywords: ['calculate', 'math'] },
+ *   code: { agent: new Agent({ instructions: 'Code expert' }), keywords: ['code', 'program'] }
+ * });
+ * await router.chat('Calculate 2+2');  // Routes to math agent
+ * ```
+ */
+export declare class Router {
+    private routerAgent;
+    private agentMap;
+    constructor(config: SimpleRouterConfig, options?: {
+        default?: string;
+        verbose?: boolean;
+    });
+    /**
+     * Route and get response
+     */
+    chat(input: string): Promise<string>;
+    /**
+     * Route and get full result with agent info
+     */
+    route(input: string): Promise<{
+        agent: AnyAgent;
+        response: string;
+    } | null>;
+    /**
+     * Get agent by name
+     */
+    getAgent(name: string): AnyAgent | undefined;
+}
+export {};

package/dist/agent/router.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * Router Agent - Route requests to specialized agents
+ *
+ * @example Simple usage (5 lines)
+ * ```typescript
+ * import { Agent, Router } from 'praisonai';
+ *
+ * const router = new Router({
+ *   math: { agent: new Agent({ instructions: 'Math expert' }), keywords: ['calculate', 'math'] },
+ *   code: { agent: new Agent({ instructions: 'Code expert' }), keywords: ['code', 'program'] }
+ * });
+ * await router.chat('Calculate 2+2');  // Routes to math agent
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Router = exports.routeConditions = exports.RouterAgent = void 0;
+exports.createRouter = createRouter;
+/**
+ * Router Agent - Routes requests to the most appropriate agent
+ */
+class RouterAgent {
+    constructor(config) {
+        this.name = config.name || 'Router';
+        this.routes = config.routes.sort((a, b) => (b.priority || 0) - (a.priority || 0));
+        this.defaultAgent = config.defaultAgent;
+        this.verbose = config.verbose ?? false;
+    }
+    /**
+     * Route a request to the appropriate agent
+     */
+    async route(input, context) {
+        for (const route of this.routes) {
+            const matches = await route.condition(input, context);
+            if (matches) {
+                if (this.verbose) {
+                    console.log(`[Router] Routing to: ${route.agent.name}`);
+                }
+                const response = await route.agent.chat(input);
+                // Handle both Agent (returns string) and EnhancedAgent (returns ChatResult)
+                const responseText = typeof response === 'string' ? response : response.text;
+                return { agent: route.agent, response: responseText };
+            }
+        }
+        if (this.defaultAgent) {
+            if (this.verbose) {
+                console.log(`[Router] Using default agent: ${this.defaultAgent.name}`);
+            }
+            const response = await this.defaultAgent.chat(input);
+            const responseText = typeof response === 'string' ? response : response.text;
+            return { agent: this.defaultAgent, response: responseText };
+        }
+        return null;
+    }
+    /**
+     * Simplified chat method - routes and returns just the response
+     */
+    async chat(input, context) {
+        const result = await this.route(input, context);
+        if (!result) {
+            throw new Error('No matching route found and no default agent configured');
+        }
+        return result.response;
+    }
+    /**
+     * Add a route
+     */
+    addRoute(config) {
+        this.routes.push(config);
+        this.routes.sort((a, b) => (b.priority || 0) - (a.priority || 0));
+        return this;
+    }
+    /**
+     * Get all routes
+     */
+    getRoutes() {
+        return [...this.routes];
+    }
+}
+exports.RouterAgent = RouterAgent;
+/**
+ * Route condition helpers
+ */
+exports.routeConditions = {
+    /**
+     * Match by keywords
+     */
+    keywords: (keywords) => {
+        const keywordList = Array.isArray(keywords) ? keywords : [keywords];
+        return (input) => {
+            const lower = input.toLowerCase();
+            return keywordList.some(kw => lower.includes(kw.toLowerCase()));
+        };
+    },
+    /**
+     * Match by regex
+     */
+    pattern: (regex) => {
+        return (input) => regex.test(input);
+    },
+    /**
+     * Match by metadata
+     */
+    metadata: (key, value) => {
+        return (_input, context) => {
+            return context?.metadata?.[key] === value;
+        };
+    },
+    /**
+     * Always match (for default routes)
+     */
+    always: () => {
+        return () => true;
+    },
+    /**
+     * Combine conditions with AND
+     */
+    and: (...conditions) => {
+        return (input, context) => {
+            return conditions.every(c => c(input, context));
+        };
+    },
+    /**
+     * Combine conditions with OR
+     */
+    or: (...conditions) => {
+        return (input, context) => {
+            return conditions.some(c => c(input, context));
+        };
+    }
+};
+/**
+ * Create a router agent (legacy API)
+ */
+function createRouter(config) {
+    return new RouterAgent(config);
+}
+/**
+ * Simplified Router class - uses keyword/pattern-based routing
+ *
+ * @example Simple usage (5 lines)
+ * ```typescript
+ * import { Agent, Router } from 'praisonai';
+ *
+ * const router = new Router({
+ *   math: { agent: new Agent({ instructions: 'Math expert' }), keywords: ['calculate', 'math'] },
+ *   code: { agent: new Agent({ instructions: 'Code expert' }), keywords: ['code', 'program'] }
+ * });
+ * await router.chat('Calculate 2+2');  // Routes to math agent
+ * ```
+ */
+class Router {
+    constructor(config, options) {
+        this.agentMap = new Map();
+        const routes = [];
+        let defaultAgent;
+        for (const [name, routeConfig] of Object.entries(config)) {
+            this.agentMap.set(name, routeConfig.agent);
+            // Build condition from keywords or pattern
+            let condition;
+            if (routeConfig.keywords) {
+                condition = exports.routeConditions.keywords(routeConfig.keywords);
+            }
+            else if (routeConfig.pattern) {
+                condition = exports.routeConditions.pattern(routeConfig.pattern);
+            }
+            else {
+                condition = exports.routeConditions.always();
+            }
+            routes.push({
+                agent: routeConfig.agent,
+                condition,
+                priority: routeConfig.priority
+            });
+            // Set default agent
+            if (options?.default === name) {
+                defaultAgent = routeConfig.agent;
+            }
+        }
+        // If no default specified, use first agent
+        if (!defaultAgent && routes.length > 0) {
+            defaultAgent = routes[0].agent;
+        }
+        this.routerAgent = new RouterAgent({
+            routes,
+            defaultAgent,
+            verbose: options?.verbose
+        });
+    }
+    /**
+     * Route and get response
+     */
+    async chat(input) {
+        return this.routerAgent.chat(input);
+    }
+    /**
+     * Route and get full result with agent info
+     */
+    async route(input) {
+        return this.routerAgent.route(input);
+    }
+    /**
+     * Get agent by name
+     */
+    getAgent(name) {
+        return this.agentMap.get(name);
+    }
+}
+exports.Router = Router;