praisonai 1.0.19 → 1.2.0

package/dist/agent/context.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Context Agent - Agent with enhanced context management
+ */
+import { KnowledgeBase, type SearchResult } from '../knowledge/rag';
+export interface ContextAgentConfig {
+    name?: string;
+    instructions: string;
+    llm?: string;
+    knowledgeBase?: KnowledgeBase;
+    contextWindow?: number;
+    maxContextTokens?: number;
+    verbose?: boolean;
+}
+export interface ContextMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+    timestamp: number;
+    metadata?: Record<string, any>;
+}
+/**
+ * Context Agent - Agent with RAG and context management
+ */
+export declare class ContextAgent {
+    readonly name: string;
+    readonly instructions: string;
+    private provider;
+    private knowledgeBase?;
+    private contextWindow;
+    private maxContextTokens;
+    private messages;
+    private verbose;
+    constructor(config: ContextAgentConfig);
+    /**
+     * Chat with context awareness
+     */
+    chat(prompt: string): Promise<{
+        text: string;
+        context?: SearchResult[];
+    }>;
+    /**
+     * Get recent messages within context window
+     */
+    private getRecentMessages;
+    /**
+     * Add document to knowledge base
+     */
+    addDocument(id: string, content: string, metadata?: Record<string, any>): Promise<void>;
+    /**
+     * Search knowledge base
+     */
+    searchKnowledge(query: string, limit?: number): Promise<SearchResult[]>;
+    /**
+     * Clear conversation history
+     */
+    clearHistory(): void;
+    /**
+     * Get conversation history
+     */
+    getHistory(): ContextMessage[];
+    /**
+     * Set knowledge base
+     */
+    setKnowledgeBase(kb: KnowledgeBase): void;
+}
+/**
+ * Create a context agent
+ */
+export declare function createContextAgent(config: ContextAgentConfig): ContextAgent;

package/dist/agent/context.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * Context Agent - Agent with enhanced context management
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextAgent = void 0;
+exports.createContextAgent = createContextAgent;
+const providers_1 = require("../llm/providers");
+/**
+ * Context Agent - Agent with RAG and context management
+ */
+class ContextAgent {
+    constructor(config) {
+        this.messages = [];
+        this.name = config.name || `ContextAgent_${Math.random().toString(36).substr(2, 9)}`;
+        this.instructions = config.instructions;
+        this.provider = (0, providers_1.createProvider)(config.llm || 'gpt-4o-mini');
+        this.knowledgeBase = config.knowledgeBase;
+        this.contextWindow = config.contextWindow ?? 10;
+        this.maxContextTokens = config.maxContextTokens ?? 4000;
+        this.verbose = config.verbose ?? false;
+    }
+    /**
+     * Chat with context awareness
+     */
+    async chat(prompt) {
+        // Add user message
+        this.messages.push({
+            role: 'user',
+            content: prompt,
+            timestamp: Date.now()
+        });
+        // Build context from knowledge base
+        let ragContext = [];
+        let contextString = '';
+        if (this.knowledgeBase) {
+            ragContext = await this.knowledgeBase.search(prompt);
+            if (ragContext.length > 0) {
+                contextString = this.knowledgeBase.buildContext(ragContext);
+                if (this.verbose) {
+                    console.log(`[ContextAgent] Found ${ragContext.length} relevant documents`);
+                }
+            }
+        }
+        // Build messages array with context
+        const systemPrompt = contextString
+            ? `${this.instructions}\n\nRelevant context:\n${contextString}`
+            : this.instructions;
+        const messages = [
+            { role: 'system', content: systemPrompt },
+            ...this.getRecentMessages()
+        ];
+        // Generate response
+        const result = await this.provider.generateText({ messages });
+        // Add assistant message
+        this.messages.push({
+            role: 'assistant',
+            content: result.text,
+            timestamp: Date.now()
+        });
+        return {
+            text: result.text,
+            context: ragContext.length > 0 ? ragContext : undefined
+        };
+    }
+    /**
+     * Get recent messages within context window
+     */
+    getRecentMessages() {
+        const recent = this.messages.slice(-this.contextWindow);
+        return recent.map(m => ({
+            role: m.role,
+            content: m.content
+        }));
+    }
+    /**
+     * Add document to knowledge base
+     */
+    async addDocument(id, content, metadata) {
+        if (!this.knowledgeBase) {
+            throw new Error('No knowledge base configured');
+        }
+        await this.knowledgeBase.add({ id, content, metadata });
+    }
+    /**
+     * Search knowledge base
+     */
+    async searchKnowledge(query, limit) {
+        if (!this.knowledgeBase) {
+            return [];
+        }
+        return this.knowledgeBase.search(query, limit);
+    }
+    /**
+     * Clear conversation history
+     */
+    clearHistory() {
+        this.messages = [];
+    }
+    /**
+     * Get conversation history
+     */
+    getHistory() {
+        return [...this.messages];
+    }
+    /**
+     * Set knowledge base
+     */
+    setKnowledgeBase(kb) {
+        this.knowledgeBase = kb;
+    }
+}
+exports.ContextAgent = ContextAgent;
+/**
+ * Create a context agent
+ */
+function createContextAgent(config) {
+    return new ContextAgent(config);
+}

package/dist/agent/enhanced.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Enhanced Agent - Agent with session management, provider abstraction, and tool support
+ */
+import { type ToolCall } from '../llm/providers';
+import { Session } from '../session';
+import { FunctionTool } from '../tools/decorator';
+export interface EnhancedAgentConfig {
+    name?: string;
+    instructions: string;
+    llm?: string;
+    tools?: Array<FunctionTool | Function | {
+        name: string;
+        description?: string;
+        parameters?: any;
+        execute: Function;
+    }>;
+    session?: Session;
+    sessionId?: string;
+    verbose?: boolean;
+    stream?: boolean;
+    maxToolCalls?: number;
+    temperature?: number;
+    maxTokens?: number;
+    outputSchema?: any;
+}
+export interface ChatOptions {
+    stream?: boolean;
+    temperature?: number;
+    maxTokens?: number;
+    outputSchema?: any;
+    onToken?: (token: string) => void;
+}
+export interface ChatResult {
+    text: string;
+    structured?: any;
+    toolCalls?: ToolCall[];
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    runId: string;
+    sessionId: string;
+}
+/**
+ * Enhanced Agent with full feature support
+ */
+export declare class EnhancedAgent {
+    readonly name: string;
+    readonly instructions: string;
+    readonly sessionId: string;
+    private provider;
+    private session;
+    private toolRegistry;
+    private verbose;
+    private stream;
+    private maxToolCalls;
+    private temperature;
+    private maxTokens?;
+    private outputSchema?;
+    constructor(config: EnhancedAgentConfig);
+    private registerTools;
+    /**
+     * Add a tool to the agent
+     */
+    addTool(t: FunctionTool | {
+        name: string;
+        description?: string;
+        parameters?: any;
+        execute: Function;
+    }): this;
+    /**
+     * Get all registered tools
+     */
+    getTools(): FunctionTool[];
+    /**
+     * Chat with the agent
+     */
+    chat(prompt: string, options?: ChatOptions): Promise<ChatResult>;
+    /**
+     * Start method for compatibility
+     */
+    start(prompt: string, options?: ChatOptions): Promise<string>;
+    /**
+     * Get the session
+     */
+    getSession(): Session;
+    /**
+     * Clear conversation history
+     */
+    clearHistory(): void;
+}

package/dist/agent/enhanced.js

@@ -0,0 +1,267 @@
+"use strict";
+/**
+ * Enhanced Agent - Agent with session management, provider abstraction, and tool support
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnhancedAgent = void 0;
+const providers_1 = require("../llm/providers");
+const session_1 = require("../session");
+const decorator_1 = require("../tools/decorator");
+const logger_1 = require("../utils/logger");
+/**
+ * Enhanced Agent with full feature support
+ */
+class EnhancedAgent {
+    constructor(config) {
+        this.name = config.name || `Agent_${Math.random().toString(36).substr(2, 9)}`;
+        this.instructions = config.instructions;
+        this.verbose = config.verbose ?? true;
+        this.stream = config.stream ?? true;
+        this.maxToolCalls = config.maxToolCalls ?? 10;
+        this.temperature = config.temperature ?? 0.7;
+        this.maxTokens = config.maxTokens;
+        this.outputSchema = config.outputSchema;
+        // Initialize provider
+        this.provider = (0, providers_1.createProvider)(config.llm || 'gpt-4o-mini');
+        // Initialize session
+        if (config.session) {
+            this.session = config.session;
+        }
+        else if (config.sessionId) {
+            this.session = (0, session_1.getSessionManager)().getOrCreate(config.sessionId);
+        }
+        else {
+            this.session = (0, session_1.getSessionManager)().create();
+        }
+        this.sessionId = this.session.id;
+        // Initialize tool registry
+        this.toolRegistry = new decorator_1.ToolRegistry();
+        if (config.tools) {
+            this.registerTools(config.tools);
+        }
+        logger_1.Logger.setVerbose(this.verbose);
+    }
+    registerTools(tools) {
+        if (!tools)
+            return;
+        for (const t of tools) {
+            if (t instanceof decorator_1.FunctionTool) {
+                this.toolRegistry.register(t);
+            }
+            else if (typeof t === 'function') {
+                // Convert function to tool
+                const funcName = t.name || `function_${Math.random().toString(36).substr(2, 9)}`;
+                this.toolRegistry.register((0, decorator_1.tool)({
+                    name: funcName,
+                    description: `Function ${funcName}`,
+                    execute: t,
+                }));
+            }
+            else if (typeof t === 'object' && 'execute' in t) {
+                // Tool config object
+                this.toolRegistry.register((0, decorator_1.tool)({
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.parameters,
+                    execute: t.execute,
+                }));
+            }
+        }
+    }
+    /**
+     * Add a tool to the agent
+     */
+    addTool(t) {
+        if (t instanceof decorator_1.FunctionTool) {
+            this.toolRegistry.register(t);
+        }
+        else {
+            this.toolRegistry.register((0, decorator_1.tool)({
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters,
+                execute: t.execute,
+            }));
+        }
+        return this;
+    }
+    /**
+     * Get all registered tools
+     */
+    getTools() {
+        return this.toolRegistry.list();
+    }
+    /**
+     * Chat with the agent
+     */
+    async chat(prompt, options = {}) {
+        const run = this.session.createRun().start();
+        const trace = run.createTrace({ name: 'chat' }).start();
+        try {
+            // Add user message to session
+            this.session.addMessage({ role: 'user', content: prompt });
+            // Build messages array
+            const messages = [
+                { role: 'system', content: this.instructions },
+                ...this.session.getMessagesForLLM(),
+            ];
+            // Get tool definitions
+            const tools = this.toolRegistry.list().length > 0
+                ? this.toolRegistry.getDefinitions()
+                : undefined;
+            let result;
+            let fullText = '';
+            let allToolCalls = [];
+            let iterations = 0;
+            // Tool calling loop
+            while (iterations < this.maxToolCalls) {
+                iterations++;
+                if (options.stream && !tools && options.onToken) {
+                    // Streaming without tools
+                    const stream = await this.provider.streamText({
+                        messages,
+                        temperature: options.temperature ?? this.temperature,
+                        maxTokens: options.maxTokens ?? this.maxTokens,
+                        onToken: options.onToken,
+                    });
+                    let usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+                    for await (const chunk of stream) {
+                        if (chunk.text)
+                            fullText += chunk.text;
+                        if (chunk.usage)
+                            usage = { ...usage, ...chunk.usage };
+                    }
+                    result = {
+                        text: fullText,
+                        usage,
+                        finishReason: 'stop',
+                    };
+                    break;
+                }
+                else if (options.outputSchema) {
+                    // Structured output
+                    const objResult = await this.provider.generateObject({
+                        messages,
+                        schema: options.outputSchema ?? this.outputSchema,
+                        temperature: options.temperature ?? this.temperature,
+                        maxTokens: options.maxTokens ?? this.maxTokens,
+                    });
+                    result = {
+                        text: JSON.stringify(objResult.object),
+                        usage: objResult.usage,
+                        finishReason: 'stop',
+                    };
+                    fullText = result.text;
+                    break;
+                }
+                else {
+                    // Regular generation with potential tool calls
+                    result = await this.provider.generateText({
+                        messages,
+                        temperature: options.temperature ?? this.temperature,
+                        maxTokens: options.maxTokens ?? this.maxTokens,
+                        tools,
+                    });
+                    if (result.toolCalls && result.toolCalls.length > 0) {
+                        allToolCalls.push(...result.toolCalls);
+                        // Add assistant message with tool calls
+                        messages.push({
+                            role: 'assistant',
+                            content: result.text || null,
+                            tool_calls: result.toolCalls,
+                        });
+                        // Execute tool calls
+                        for (const tc of result.toolCalls) {
+                            const toolTrace = trace.createChild({ name: `tool:${tc.function.name}` }).start();
+                            try {
+                                const toolFn = this.toolRegistry.get(tc.function.name);
+                                if (!toolFn) {
+                                    throw new Error(`Tool '${tc.function.name}' not found`);
+                                }
+                                const args = JSON.parse(tc.function.arguments);
+                                const toolResult = await toolFn.execute(args, {
+                                    agentName: this.name,
+                                    sessionId: this.sessionId,
+                                    runId: run.id,
+                                });
+                                const resultStr = typeof toolResult === 'string'
+                                    ? toolResult
+                                    : JSON.stringify(toolResult);
+                                messages.push({
+                                    role: 'tool',
+                                    content: resultStr,
+                                    tool_call_id: tc.id,
+                                });
+                                toolTrace.complete({ result: resultStr });
+                            }
+                            catch (error) {
+                                messages.push({
+                                    role: 'tool',
+                                    content: `Error: ${error.message}`,
+                                    tool_call_id: tc.id,
+                                });
+                                toolTrace.fail(error);
+                            }
+                        }
+                        // Continue loop to get final response
+                        continue;
+                    }
+                    // No tool calls, we have our final response
+                    fullText = result.text;
+                    break;
+                }
+            }
+            // Add assistant message to session
+            this.session.addMessage({
+                role: 'assistant',
+                content: fullText,
+                tool_calls: allToolCalls.length > 0 ? allToolCalls : undefined,
+            });
+            trace.complete({ responseLength: fullText.length });
+            run.complete();
+            // Parse structured output if schema was provided
+            let structured;
+            if (options.outputSchema) {
+                try {
+                    structured = JSON.parse(fullText);
+                }
+                catch {
+                    // Not valid JSON
+                }
+            }
+            return {
+                text: fullText,
+                structured,
+                toolCalls: allToolCalls.length > 0 ? allToolCalls : undefined,
+                usage: result.usage,
+                runId: run.id,
+                sessionId: this.sessionId,
+            };
+        }
+        catch (error) {
+            trace.fail(error);
+            run.fail(error);
+            throw error;
+        }
+    }
+    /**
+     * Start method for compatibility
+     */
+    async start(prompt, options) {
+        const result = await this.chat(prompt, options);
+        return result.text;
+    }
+    /**
+     * Get the session
+     */
+    getSession() {
+        return this.session;
+    }
+    /**
+     * Clear conversation history
+     */
+    clearHistory() {
+        this.session.clearMessages();
+    }
+}
+exports.EnhancedAgent = EnhancedAgent;

package/dist/agent/handoff.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Agent Handoff - Transfer conversations between agents
+ */
+import type { EnhancedAgent } from './enhanced';
+export interface HandoffConfig {
+    agent: EnhancedAgent;
+    name?: string;
+    description?: string;
+    condition?: (context: HandoffContext) => boolean;
+    transformContext?: (messages: any[]) => any[];
+}
+export interface HandoffContext {
+    messages: any[];
+    lastMessage: string;
+    topic?: string;
+    metadata?: Record<string, any>;
+}
+export interface HandoffResult {
+    handedOffTo: string;
+    response: string;
+    context: HandoffContext;
+}
+/**
+ * Handoff class - Represents a handoff target
+ */
+export declare class Handoff {
+    readonly targetAgent: EnhancedAgent;
+    readonly name: string;
+    readonly description: string;
+    readonly condition?: (context: HandoffContext) => boolean;
+    readonly transformContext?: (messages: any[]) => any[];
+    constructor(config: HandoffConfig);
+    /**
+     * Check if handoff should be triggered
+     */
+    shouldTrigger(context: HandoffContext): boolean;
+    /**
+     * Execute the handoff
+     */
+    execute(context: HandoffContext): Promise<HandoffResult>;
+    /**
+     * Get tool definition for LLM
+     */
+    getToolDefinition(): {
+        name: string;
+        description: string;
+        parameters: any;
+    };
+}
+/**
+ * Create a handoff configuration
+ */
+export declare function handoff(config: HandoffConfig): Handoff;
+/**
+ * Handoff filters - Common condition functions
+ */
+export declare const handoffFilters: {
+    /**
+     * Trigger handoff based on topic keywords
+     */
+    topic: (keywords: string | string[]) => (context: HandoffContext) => boolean;
+    /**
+     * Trigger handoff based on metadata
+     */
+    metadata: (key: string, value: any) => (context: HandoffContext) => boolean;
+    /**
+     * Always trigger
+     */
+    always: () => () => boolean;
+    /**
+     * Never trigger (manual only)
+     */
+    never: () => () => boolean;
+    /**
+     * Combine multiple conditions with AND
+     */
+    and: (...conditions: Array<(context: HandoffContext) => boolean>) => (context: HandoffContext) => boolean;
+    /**
+     * Combine multiple conditions with OR
+     */
+    or: (...conditions: Array<(context: HandoffContext) => boolean>) => (context: HandoffContext) => boolean;
+};