@codebolt/agent 2.2.2 → 2.2.3

package/dist/unified/examples/documentationPatternExample.js

@@ -0,0 +1,385 @@
+"use strict";
+/**
+ * Documentation Pattern Example
+ *
+ * This example implements the exact pattern described in the Orchestrator.md documentation
+ * showing how agents, workflows, and tools can be used as tools within an orchestrator.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.documentationPatternExample = documentationPatternExample;
+exports.nestedOrchestrationExample = nestedOrchestrationExample;
+exports.agentWorkflowToolAsToolsExample = agentWorkflowToolAsToolsExample;
+exports.runDocumentationPatternExamples = runDocumentationPatternExamples;
+const zod_1 = require("zod");
+const index_1 = require("../index");
+// ================================
+// Documentation Pattern Implementation
+// ================================
+async function documentationPatternExample() {
+    console.log('=== Documentation Pattern Example ===');
+    console.log('Implementing the exact pattern from Orchestrator.md\n');
+    // Create Agent 1 - Research and Text Synthesis
+    const agent1 = (0, index_1.createAgent)({
+        name: 'Research Agent',
+        instructions: 'You are a research specialist focused on gathering information and synthesizing text.',
+        description: 'Specializes in research and text synthesis',
+        tools: [
+            (0, index_1.createTool)({
+                id: 'research-city-info',
+                name: 'Research City Information',
+                description: 'Research comprehensive information about a city',
+                inputSchema: zod_1.z.object({
+                    city: zod_1.z.string(),
+                    aspects: zod_1.z.array(zod_1.z.string()).optional().default(['demographics', 'economy', 'culture'])
+                }),
+                execute: async ({ input }) => {
+                    // Simulate city research
+                    return {
+                        city: input.city,
+                        demographics: `${input.city} has a diverse population with various age groups and backgrounds.`,
+                        economy: `${input.city}'s economy is driven by multiple sectors including technology and services.`,
+                        culture: `${input.city} has a rich cultural heritage with numerous attractions and events.`,
+                        summary: `Comprehensive research completed for ${input.city} covering ${input.aspects.join(', ')}.`
+                    };
+                }
+            })
+        ]
+    });
+    // Create Agent 2 - Text Processing and Enhancement
+    const agent2 = (0, index_1.createAgent)({
+        name: 'Text Processing Agent',
+        instructions: 'You are a text processing specialist focused on enhancing and refining content.',
+        description: 'Specializes in text processing and content enhancement',
+        tools: [
+            (0, index_1.createTool)({
+                id: 'enhance-text',
+                name: 'Text Enhancement Tool',
+                description: 'Enhance and refine text content',
+                inputSchema: zod_1.z.object({
+                    text: zod_1.z.string(),
+                    style: zod_1.z.enum(['formal', 'casual', 'academic']).optional().default('formal'),
+                    length: zod_1.z.enum(['short', 'medium', 'long']).optional().default('medium')
+                }),
+                execute: async ({ input }) => {
+                    // Simulate text enhancement
+                    return {
+                        originalText: input.text,
+                        enhancedText: `Enhanced ${input.style} version: ${input.text}`,
+                        improvements: ['Improved clarity', 'Better structure', 'Enhanced readability'],
+                        wordCount: input.length === 'short' ? 150 : input.length === 'medium' ? 300 : 500
+                    };
+                }
+            })
+        ]
+    });
+    // Create Agent Step 1 - as shown in documentation
+    const agentStep1 = (0, index_1.createAgentStep)({
+        id: 'agent-step',
+        name: 'Research and Text Synthesis Step',
+        description: 'This step is used to do research and text synthesis.',
+        agent: agent1,
+        message: 'Research comprehensive information about {{city}} and synthesize the findings.',
+        inputMapping: {
+            city: 'city'
+        },
+        outputMapping: {
+            researchResults: 'agentResult.response',
+            cityData: 'agentResult.toolResults'
+        }
+    });
+    // Create Agent Step 2 - as shown in documentation  
+    const agentStep2 = (0, index_1.createAgentStep)({
+        id: 'agent-step-two',
+        name: 'Text Processing Step',
+        description: 'This step is used to process and enhance text.',
+        agent: agent2,
+        message: 'Process and enhance this text: {{text}}. Make it {{style}} and {{length}}.',
+        inputMapping: {
+            text: 'researchResults',
+            style: 'textStyle',
+            length: 'textLength'
+        },
+        outputMapping: {
+            finalText: 'agentResult.response',
+            enhancements: 'agentResult.toolResults'
+        }
+    });
+    // Create Workflow 1 - as shown in documentation
+    const workflow1Config = {
+        name: 'Research and Processing Workflow',
+        description: 'Sequential workflow for research and text processing',
+        steps: [agentStep1, agentStep2],
+        initialData: {
+            city: 'San Francisco',
+            textStyle: 'formal',
+            textLength: 'medium'
+        }
+    };
+    const workflow1 = (0, index_1.createWorkflow)(workflow1Config);
+    // Add agents to workflow context
+    workflow1.addAgent('agent1', agent1);
+    workflow1.addAgent('agent2', agent2);
+    // Create Orchestrator - as shown in documentation
+    const orchestratorConfig = {
+        name: 'Test Network',
+        description: 'Test orchestrator network demonstrating the documentation pattern',
+        instructions: `You are a test orchestrator that coordinates agents and workflows.
+
+Available Resources:
+- agent1: Research and text synthesis specialist
+- agent2: Text processing and enhancement specialist  
+- workflow1: Complete research and processing pipeline
+
+Decision Logic:
+1. For research tasks → use agent1 or workflow1
+2. For text processing → use agent2 or workflow1
+3. For complete research + processing → use workflow1
+4. Always consider the most efficient resource for the task`,
+        agents: {
+            agent1,
+            agent2
+        },
+        workflows: {
+            workflow1
+        },
+        limits: {
+            maxSteps: 10,
+            maxExecutionTime: 300000 // 5 minutes
+        },
+        decisionConfig: {
+            explainDecisions: true,
+            confidenceThreshold: 0.7
+        }
+    };
+    const orchestrator = (0, index_1.createOrchestrator)(orchestratorConfig);
+    // Create Runtime Context - as shown in documentation
+    const runtimeContext = (0, index_1.createRuntimeContext)({
+        userId: 'test-user',
+        customData: {
+            preferences: {
+                city: 'New York',
+                outputStyle: 'formal',
+                outputLength: 'long'
+            }
+        }
+    });
+    // Execute orchestrator loop - as shown in documentation
+    console.log('Executing orchestrator loop...');
+    const result = await orchestrator.loop('I need comprehensive research about New York City and then process that information into a formal, detailed report.', { runtimeContext });
+    console.log('\nOrchestrator execution completed:');
+    console.log('Success:', result.success);
+    console.log('Total Steps:', result.executionSteps.length);
+    console.log('Execution Time:', result.totalExecutionTime, 'ms');
+    console.log('Resources Used:');
+    console.log('  - Agents:', result.metrics.agentsExecuted);
+    console.log('  - Workflows:', result.metrics.workflowsExecuted);
+    console.log('  - Tools:', result.metrics.toolsExecuted);
+    console.log('\nFinal Response:');
+    console.log(result.response.substring(0, 300) + '...');
+    // Demonstrate step-by-step execution details
+    console.log('\n--- Execution Steps ---');
+    result.executionSteps.forEach((step, index) => {
+        console.log(`${index + 1}. ${step.stepType.toUpperCase()}: ${step.resourceName}`);
+        console.log(`   Success: ${step.success}`);
+        console.log(`   Time: ${step.executionTime}ms`);
+        if (step.metadata.reasoning) {
+            console.log(`   Reasoning: ${step.metadata.reasoning}`);
+        }
+        console.log('');
+    });
+    return result;
+}
+// ================================
+// Advanced Pattern: Nested Orchestration
+// ================================
+async function nestedOrchestrationExample() {
+    console.log('\n=== Nested Orchestration Example ===');
+    console.log('Demonstrating orchestrators using other orchestrators as tools\n');
+    // Create a specialized sub-orchestrator for content creation
+    const contentOrchestrator = (0, index_1.createOrchestrator)({
+        name: 'Content Creation Orchestrator',
+        instructions: 'You specialize in content creation workflows.',
+        agents: {
+            writer: (0, index_1.createAgent)({
+                name: 'Content Writer',
+                instructions: 'You are a skilled content writer.'
+            }),
+            editor: (0, index_1.createAgent)({
+                name: 'Content Editor',
+                instructions: 'You are a meticulous content editor.'
+            })
+        },
+        workflows: {}
+    });
+    // Create a tool that wraps the content orchestrator
+    const contentOrchestrationTool = (0, index_1.createTool)({
+        id: 'content-orchestrator-tool',
+        name: 'Content Creation Orchestrator',
+        description: 'Execute content creation using specialized orchestrator',
+        inputSchema: zod_1.z.object({
+            task: zod_1.z.string(),
+            requirements: zod_1.z.array(zod_1.z.string()).optional()
+        }),
+        execute: async ({ input }) => {
+            const result = await contentOrchestrator.loop(input.task);
+            return {
+                content: result.response,
+                success: result.success,
+                stepsExecuted: result.executionSteps.length,
+                executionTime: result.totalExecutionTime
+            };
+        }
+    });
+    // Create main orchestrator that can use the content orchestrator as a tool
+    const mainOrchestrator = (0, index_1.createOrchestrator)({
+        name: 'Main Orchestrator',
+        instructions: 'You coordinate high-level tasks and can delegate to specialized orchestrators.',
+        agents: {
+            coordinator: (0, index_1.createAgent)({
+                name: 'Task Coordinator',
+                instructions: 'You coordinate complex tasks across multiple systems.',
+                tools: [contentOrchestrationTool]
+            })
+        },
+        workflows: {},
+        tools: {
+            'content-orchestrator': contentOrchestrationTool.toOpenAITool()
+        }
+    });
+    // Test nested orchestration
+    const result = await mainOrchestrator.loop('Create a comprehensive blog post about artificial intelligence trends, including research, writing, and editing phases.');
+    console.log('Nested orchestration result:');
+    console.log('Success:', result.success);
+    console.log('Total Steps:', result.executionSteps.length);
+    console.log('Response:', result.response.substring(0, 200) + '...');
+    return result;
+}
+// ================================
+// Pattern: Agents, Workflows, and Tools as Tools
+// ================================
+async function agentWorkflowToolAsToolsExample() {
+    console.log('\n=== Agents, Workflows, and Tools as Tools Example ===');
+    console.log('Demonstrating how each resource type can be used as a tool\n');
+    // 1. Agent as a Tool
+    const researchAgent = (0, index_1.createAgent)({
+        name: 'Research Specialist',
+        instructions: 'You conduct thorough research on any topic.'
+    });
+    const agentAsTool = researchAgent.toTool();
+    console.log('✓ Created agent as tool:', agentAsTool.name);
+    // 2. Workflow as a Tool  
+    const analysisWorkflow = (0, index_1.createWorkflow)({
+        name: 'Analysis Pipeline',
+        description: 'Complete analysis workflow',
+        steps: [
+            (0, index_1.createAgentStep)({
+                id: 'analyze',
+                name: 'Analysis Step',
+                agent: researchAgent,
+                message: 'Analyze: {{topic}}'
+            })
+        ]
+    });
+    const workflowAsTool = (0, index_1.createTool)({
+        id: 'analysis-workflow-tool',
+        name: 'Analysis Workflow',
+        description: 'Execute complete analysis workflow',
+        inputSchema: zod_1.z.object({
+            topic: zod_1.z.string(),
+            depth: zod_1.z.enum(['basic', 'detailed']).optional().default('detailed')
+        }),
+        execute: async ({ input }) => {
+            analysisWorkflow.updateContext({ topic: input.topic, depth: input.depth });
+            const result = await analysisWorkflow.execute();
+            return {
+                analysisResult: result.data,
+                success: result.success,
+                executionTime: result.executionTime
+            };
+        }
+    });
+    console.log('✓ Created workflow as tool:', workflowAsTool.name);
+    // 3. Regular Tool
+    const calculatorTool = (0, index_1.createTool)({
+        id: 'calculator',
+        name: 'Calculator',
+        description: 'Perform mathematical calculations',
+        inputSchema: zod_1.z.object({
+            expression: zod_1.z.string()
+        }),
+        execute: async ({ input }) => {
+            // Simple calculation simulation
+            return {
+                expression: input.expression,
+                result: `Calculated result for: ${input.expression}`,
+                timestamp: new Date().toISOString()
+            };
+        }
+    });
+    console.log('✓ Created regular tool:', calculatorTool.name);
+    // Create orchestrator that can use all three types as tools
+    const multiToolOrchestrator = (0, index_1.createOrchestrator)({
+        name: 'Multi-Tool Orchestrator',
+        instructions: `You can use various types of tools:
+        
+1. Agent tools - for complex reasoning and conversation
+2. Workflow tools - for structured multi-step processes  
+3. Regular tools - for specific functions
+
+Choose the appropriate tool type based on the task complexity and requirements.`,
+        agents: {
+            coordinator: (0, index_1.createAgent)({
+                name: 'Tool Coordinator',
+                instructions: 'You coordinate the use of different tool types.',
+                tools: [agentAsTool, workflowAsTool, calculatorTool]
+            })
+        },
+        workflows: {},
+        tools: {
+            'agent-tool': researchAgent.toOpenAITool(),
+            'workflow-tool': workflowAsTool.toOpenAITool(),
+            'calculator-tool': calculatorTool.toOpenAITool()
+        }
+    });
+    // Test using different tool types
+    const testCases = [
+        'Research the latest developments in quantum computing', // Should use agent tool
+        'Perform a complete analysis of market trends in renewable energy', // Should use workflow tool
+        'Calculate the compound interest for $10,000 at 5% for 10 years' // Should use calculator tool
+    ];
+    const results = [];
+    for (const [index, testCase] of testCases.entries()) {
+        console.log(`\n--- Test Case ${index + 1}: ${testCase.substring(0, 40)}... ---`);
+        const result = await multiToolOrchestrator.loop(testCase);
+        console.log('Result:', {
+            success: result.success,
+            toolsUsed: result.metrics.toolsExecuted,
+            agentsUsed: result.metrics.agentsExecuted,
+            workflowsUsed: result.metrics.workflowsExecuted
+        });
+        results.push(result);
+    }
+    return results;
+}
+// ================================
+// Run All Documentation Pattern Examples
+// ================================
+async function runDocumentationPatternExamples() {
+    try {
+        console.log('🚀 Starting Documentation Pattern Examples...\n');
+        await documentationPatternExample();
+        await nestedOrchestrationExample();
+        await agentWorkflowToolAsToolsExample();
+        console.log('\n✅ All documentation pattern examples completed successfully!');
+        console.log('\nKey Patterns Demonstrated:');
+        console.log('1. ✓ Agent as a tool');
+        console.log('2. ✓ Tool as a tool');
+        console.log('3. ✓ Workflow as a tool');
+        console.log('4. ✓ Orchestrator coordination');
+        console.log('5. ✓ Dynamic resource selection');
+        console.log('6. ✓ Nested orchestration');
+    }
+    catch (error) {
+        console.error('❌ Documentation pattern example failed:', error);
+    }
+}

package/dist/unified/examples/followUpProcessorsExample.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Example demonstrating how to use follow-up conversation processors
+ * with the Unified Agent Framework
+ */
+import { ConversationCompactorProcessor } from '../processors';
+import type { CodeboltAPI, OpenAITool } from '../types/libTypes';
+/**
+ * Example 1: Basic Follow-Up Processor Usage
+ */
+export declare function basicFollowUpProcessorExample(codebolt: CodeboltAPI, tools: OpenAITool[]): Promise<any>;
+/**
+ * Example 2: Advanced Processor Configuration
+ */
+export declare function advancedFollowUpProcessorExample(codebolt: CodeboltAPI, tools: OpenAITool[]): Promise<any>;
+/**
+ * Example 3: Dynamic Processor Management
+ */
+export declare function dynamicProcessorManagementExample(codebolt: CodeboltAPI, tools: OpenAITool[]): Promise<any>;
+/**
+ * Example 4: Processor Event Monitoring
+ */
+export declare function processorEventMonitoringExample(codebolt: CodeboltAPI, tools: OpenAITool[]): Promise<any>;
+/**
+ * Example 5: Custom Processor Creation
+ */
+export declare class CustomMetricsProcessor extends ConversationCompactorProcessor {
+    private metricsCollected;
+    processInput(input: any): Promise<any[]>;
+    private getAverageProcessingTime;
+    getMetrics(): {
+        timestamp: string;
+        messageCount: number;
+        toolCount: number;
+        processingTime: number;
+    }[];
+}
+export declare function customProcessorExample(codebolt: CodeboltAPI, tools: OpenAITool[]): Promise<{
+    result: any;
+    metrics: {
+        timestamp: string;
+        messageCount: number;
+        toolCount: number;
+        processingTime: number;
+    }[];
+}>;