@codebolt/agent 2.2.2 → 2.2.3

package/dist/unified/examples/orchestratorExample.js

@@ -0,0 +1,415 @@
+"use strict";
+/**
+ * Orchestrator Pattern Example for Unified Agent Framework
+ *
+ * This example demonstrates how to create and use an orchestrator that can
+ * dynamically coordinate agents, workflows, and tools based on the pattern
+ * described in the documentation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runOrchestratorExamples = runOrchestratorExamples;
+exports.orchestratorPatternExample = orchestratorPatternExample;
+exports.dynamicResourceSelectionExample = dynamicResourceSelectionExample;
+exports.orchestratorAsToolExample = orchestratorAsToolExample;
+const zod_1 = require("zod");
+const index_1 = require("../index");
+// ================================
+// Example: Multi-Resource Orchestration
+// ================================
+async function orchestratorPatternExample() {
+    console.log('=== Orchestrator Pattern Example ===');
+    // Create Agent 1: Research Agent
+    const agent1 = (0, index_1.createAgent)({
+        name: 'Research Agent',
+        instructions: 'You are a research specialist. Gather and synthesize information on given topics.',
+        description: 'Specializes in research and information synthesis',
+        tools: [
+            (0, index_1.createTool)({
+                id: 'research-tool',
+                name: 'Research Tool',
+                description: 'Conduct research on a given topic',
+                inputSchema: zod_1.z.object({
+                    topic: zod_1.z.string(),
+                    depth: zod_1.z.enum(['basic', 'detailed', 'comprehensive']).optional().default('detailed')
+                }),
+                execute: async ({ input }) => {
+                    // Simulate research
+                    return {
+                        findings: `Comprehensive research on ${input.topic}`,
+                        sources: ['Source 1', 'Source 2', 'Source 3'],
+                        confidence: 0.85,
+                        summary: `Key insights about ${input.topic} based on current research.`
+                    };
+                }
+            })
+        ]
+    });
+    // Create Agent 2: Analysis Agent
+    const agent2 = (0, index_1.createAgent)({
+        name: 'Analysis Agent',
+        instructions: 'You are an analytical expert. Analyze data and provide insights.',
+        description: 'Specializes in data analysis and insight generation',
+        tools: [
+            (0, index_1.createTool)({
+                id: 'analysis-tool',
+                name: 'Analysis Tool',
+                description: 'Analyze data and generate insights',
+                inputSchema: zod_1.z.object({
+                    data: zod_1.z.string(),
+                    analysisType: zod_1.z.enum(['trend', 'pattern', 'correlation']).optional().default('trend')
+                }),
+                execute: async ({ input }) => {
+                    // Simulate analysis
+                    return {
+                        insights: `Analysis reveals key trends in: ${input.data}`,
+                        metrics: { accuracy: 0.92, relevance: 0.88 },
+                        recommendations: ['Recommendation 1', 'Recommendation 2']
+                    };
+                }
+            })
+        ]
+    });
+    // Create Workflow 1: Research and Analysis Pipeline
+    const workflow1Config = {
+        name: 'Research and Analysis Pipeline',
+        description: 'Comprehensive research followed by detailed analysis',
+        steps: [
+            (0, index_1.createAgentStep)({
+                id: 'research-step',
+                name: 'Research Phase',
+                description: 'Conduct initial research',
+                agent: 'research-agent', // Reference by ID
+                message: 'Research the topic: {{topic}} with {{depth}} level of detail',
+                outputMapping: {
+                    researchFindings: 'agentResult.response',
+                    researchData: 'agentResult.toolResults'
+                }
+            }),
+            (0, index_1.createTransformStep)({
+                id: 'prepare-analysis',
+                name: 'Prepare Analysis Data',
+                description: 'Transform research data for analysis',
+                transform: (data) => ({
+                    analysisInput: `Research findings: ${data.researchFindings}`,
+                    analysisType: 'trend'
+                })
+            }),
+            (0, index_1.createAgentStep)({
+                id: 'analysis-step',
+                name: 'Analysis Phase',
+                description: 'Analyze research findings',
+                agent: 'analysis-agent', // Reference by ID
+                message: 'Analyze this data: {{analysisInput}} using {{analysisType}} analysis',
+                outputMapping: {
+                    finalInsights: 'agentResult.response',
+                    analysisMetrics: 'agentResult.toolResults'
+                }
+            })
+        ],
+        initialData: {
+            topic: 'Artificial Intelligence Trends',
+            depth: 'comprehensive'
+        }
+    };
+    const workflow1 = (0, index_1.createWorkflow)(workflow1Config);
+    // Add agents to workflow context
+    workflow1.addAgent('research-agent', agent1);
+    workflow1.addAgent('analysis-agent', agent2);
+    // Create standalone tools
+    const summaryTool = (0, index_1.createTool)({
+        id: 'summary-tool',
+        name: 'Summary Generator',
+        description: 'Generate executive summaries',
+        inputSchema: zod_1.z.object({
+            content: zod_1.z.string(),
+            length: zod_1.z.enum(['short', 'medium', 'long']).optional().default('medium')
+        }),
+        execute: async ({ input }) => {
+            return {
+                summary: `Executive summary of: ${input.content.substring(0, 100)}...`,
+                keyPoints: ['Point 1', 'Point 2', 'Point 3'],
+                wordCount: input.length === 'short' ? 150 : input.length === 'medium' ? 300 : 500
+            };
+        }
+    });
+    const reportTool = (0, index_1.createTool)({
+        id: 'report-generator',
+        name: 'Report Generator',
+        description: 'Generate formatted reports',
+        inputSchema: zod_1.z.object({
+            data: zod_1.z.record(zod_1.z.unknown()),
+            format: zod_1.z.enum(['pdf', 'html', 'markdown']).optional().default('markdown')
+        }),
+        execute: async ({ input }) => {
+            return {
+                report: `# Generated Report\n\nData: ${JSON.stringify(input.data, null, 2)}`,
+                format: input.format,
+                generatedAt: new Date().toISOString()
+            };
+        }
+    });
+    // Create Orchestrator Configuration
+    const orchestratorConfig = {
+        name: 'Multi-Resource Orchestrator',
+        description: 'Orchestrates agents, workflows, and tools dynamically',
+        instructions: `You are an intelligent orchestrator that can coordinate multiple resources:
+
+AVAILABLE RESOURCES:
+- Agents: agent1 (research), agent2 (analysis)
+- Workflows: workflow1 (research and analysis pipeline)
+- Tools: summary-tool, report-generator
+
+DECISION MAKING:
+1. For research tasks → use agent1 or workflow1
+2. For analysis tasks → use agent2 or workflow1
+3. For summarization → use summary-tool
+4. For report generation → use report-generator
+5. For complex multi-step processes → use workflow1
+
+Always consider:
+- What the user is asking for
+- What resources are best suited
+- Whether a workflow or individual agents/tools are more appropriate
+- The current context and previous executions
+
+Make intelligent decisions about resource selection and execution order.`,
+        agents: {
+            agent1,
+            agent2
+        },
+        workflows: {
+            workflow1
+        },
+        tools: {
+            'summary-tool': summaryTool,
+            'report-generator': reportTool
+        },
+        limits: {
+            maxSteps: 10,
+            maxExecutionTime: 300000 // 5 minutes
+        },
+        decisionConfig: {
+            explainDecisions: true,
+            confidenceThreshold: 0.7,
+            askConfirmation: false
+        }
+    };
+    // Create the orchestrator
+    const orchestrator = (0, index_1.createOrchestrator)(orchestratorConfig);
+    // Create runtime context
+    const runtimeContext = (0, index_1.createRuntimeContext)({
+        userId: 'user123',
+        customData: {
+            userPreferences: {
+                reportFormat: 'markdown',
+                summaryLength: 'medium'
+            }
+        }
+    });
+    console.log('Starting orchestration...');
+    // Test Case 1: Simple research request
+    console.log('\n--- Test Case 1: Research Request ---');
+    const result1 = await orchestrator.loop('I need comprehensive research on emerging AI technologies in healthcare', { runtimeContext });
+    console.log('Research orchestration result:', {
+        success: result1.success,
+        steps: result1.executionSteps.length,
+        response: result1.response.substring(0, 200) + '...',
+        metrics: result1.metrics
+    });
+    // Test Case 2: Complex multi-step request
+    console.log('\n--- Test Case 2: Complex Multi-Step Request ---');
+    const result2 = await orchestrator.loop('Research AI in finance, analyze the trends, and generate a comprehensive report with executive summary', { runtimeContext: (0, index_1.createRuntimeContext)() });
+    console.log('Complex orchestration result:', {
+        success: result2.success,
+        steps: result2.executionSteps.length,
+        response: result2.response.substring(0, 200) + '...',
+        resourcesUsed: {
+            agents: result2.metrics.agentsExecuted,
+            workflows: result2.metrics.workflowsExecuted,
+            tools: result2.metrics.toolsExecuted
+        }
+    });
+    // Test Case 3: Workflow-specific request
+    console.log('\n--- Test Case 3: Workflow Request ---');
+    const result3 = await orchestrator.loop('Run the research and analysis workflow for blockchain technology', { runtimeContext: (0, index_1.createRuntimeContext)() });
+    console.log('Workflow orchestration result:', {
+        success: result3.success,
+        steps: result3.executionSteps.length,
+        workflowsExecuted: result3.metrics.workflowsExecuted,
+        averageConfidence: result3.metrics.averageConfidence
+    });
+    return { result1, result2, result3 };
+}
+// ================================
+// Example: Dynamic Resource Selection
+// ================================
+async function dynamicResourceSelectionExample() {
+    console.log('\n=== Dynamic Resource Selection Example ===');
+    // Create specialized agents for different domains
+    const techAgent = (0, index_1.createAgent)({
+        name: 'Technology Expert',
+        instructions: 'You are a technology expert specializing in software, hardware, and emerging tech.',
+        tools: []
+    });
+    const businessAgent = (0, index_1.createAgent)({
+        name: 'Business Strategist',
+        instructions: 'You are a business strategist focusing on market analysis and strategic planning.',
+        tools: []
+    });
+    const creativeAgent = (0, index_1.createAgent)({
+        name: 'Creative Director',
+        instructions: 'You are a creative director specializing in content creation and design.',
+        tools: []
+    });
+    // Create domain-specific workflows
+    const techWorkflow = (0, index_1.createWorkflow)({
+        name: 'Technology Assessment',
+        description: 'Comprehensive technology evaluation workflow',
+        steps: [
+            (0, index_1.createAgentStep)({
+                id: 'tech-analysis',
+                name: 'Technology Analysis',
+                agent: techAgent,
+                message: 'Analyze the technology: {{topic}} from technical feasibility perspective'
+            })
+        ]
+    });
+    const businessWorkflow = (0, index_1.createWorkflow)({
+        name: 'Business Analysis',
+        description: 'Business impact and market analysis workflow',
+        steps: [
+            (0, index_1.createAgentStep)({
+                id: 'business-analysis',
+                name: 'Business Analysis',
+                agent: businessAgent,
+                message: 'Analyze the business implications of: {{topic}}'
+            })
+        ]
+    });
+    // Smart orchestrator that selects resources based on context
+    const smartOrchestrator = (0, index_1.createOrchestrator)({
+        name: 'Smart Domain Orchestrator',
+        instructions: `You are a smart orchestrator that selects the most appropriate resources based on the domain and context of the user's request.
+
+DOMAIN DETECTION:
+- Technology-related queries → use techAgent or techWorkflow
+- Business-related queries → use businessAgent or businessWorkflow  
+- Creative-related queries → use creativeAgent
+- Multi-domain queries → use multiple agents/workflows
+
+RESOURCE SELECTION LOGIC:
+1. Analyze the user's request to identify the primary domain(s)
+2. Select the most appropriate agent(s) or workflow(s)
+3. For complex requests, coordinate multiple resources
+4. Always explain your resource selection reasoning`,
+        agents: {
+            techAgent,
+            businessAgent,
+            creativeAgent
+        },
+        workflows: {
+            techWorkflow,
+            businessWorkflow
+        },
+        decisionConfig: {
+            explainDecisions: true,
+            confidenceThreshold: 0.6
+        }
+    });
+    // Test different types of requests
+    const testCases = [
+        'Evaluate the technical feasibility of implementing blockchain in our supply chain',
+        'What are the market opportunities for AI-powered customer service tools?',
+        'Create a creative campaign concept for our new mobile app launch',
+        'Analyze both the technical and business aspects of adopting cloud-native architecture'
+    ];
+    const results = [];
+    for (const [index, testCase] of testCases.entries()) {
+        console.log(`\n--- Test Case ${index + 1}: ${testCase.substring(0, 50)}... ---`);
+        const result = await smartOrchestrator.loop(testCase, {
+            runtimeContext: (0, index_1.createRuntimeContext)()
+        });
+        console.log('Result:', {
+            success: result.success,
+            resourcesUsed: {
+                agents: result.metrics.agentsExecuted,
+                workflows: result.metrics.workflowsExecuted
+            },
+            confidence: result.metrics.averageConfidence,
+            executionTime: result.totalExecutionTime
+        });
+        results.push(result);
+    }
+    return results;
+}
+// ================================
+// Example: Orchestrator as a Tool
+// ================================
+async function orchestratorAsToolExample() {
+    var _a;
+    console.log('\n=== Orchestrator as Tool Example ===');
+    // Create a simple orchestrator
+    const subOrchestrator = (0, index_1.createOrchestrator)({
+        name: 'Sub-Orchestrator',
+        instructions: 'You coordinate research and analysis tasks.',
+        agents: {
+            researcher: (0, index_1.createAgent)({
+                name: 'Researcher',
+                instructions: 'Conduct research on given topics.'
+            }),
+            analyzer: (0, index_1.createAgent)({
+                name: 'Analyzer',
+                instructions: 'Analyze research data and provide insights.'
+            })
+        },
+        workflows: {}
+    });
+    // Create a tool that wraps the orchestrator
+    const orchestratorTool = (0, index_1.createTool)({
+        id: 'research-orchestrator',
+        name: 'Research Orchestrator',
+        description: 'Orchestrate research and analysis using multiple agents',
+        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 subOrchestrator.loop(input.task);
+            return {
+                orchestrationResult: result.response,
+                stepsExecuted: result.executionSteps.length,
+                success: result.success,
+                metrics: result.metrics
+            };
+        }
+    });
+    // Create a main agent that can use the orchestrator as a tool
+    const mainAgent = (0, index_1.createAgent)({
+        name: 'Main Coordinator',
+        instructions: 'You are a main coordinator that can delegate complex tasks to specialized orchestrators.',
+        tools: [orchestratorTool]
+    });
+    // Test using orchestrator as a tool
+    const result = await mainAgent.execute('I need a comprehensive analysis of renewable energy trends. Use the research orchestrator to coordinate this task.');
+    console.log('Orchestrator as tool result:', {
+        success: result.success,
+        response: result.response.substring(0, 300) + '...',
+        toolsUsed: ((_a = result.toolResults) === null || _a === void 0 ? void 0 : _a.length) || 0
+    });
+    return result;
+}
+// ================================
+// Run All Examples
+// ================================
+async function runOrchestratorExamples() {
+    try {
+        console.log('🚀 Starting Orchestrator Examples...\n');
+        await orchestratorPatternExample();
+        await dynamicResourceSelectionExample();
+        await orchestratorAsToolExample();
+        console.log('\n✅ All orchestrator examples completed successfully!');
+    }
+    catch (error) {
+        console.error('❌ Orchestrator example failed:', error);
+    }
+}

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

@@ -0,0 +1,36 @@
+/**
+ * Example demonstrating how to use pre-tool call processors
+ * with the Unified Agent Framework
+ */
+import { LocalToolInterceptorProcessor } from '../processors';
+import type { CodeboltAPI, OpenAITool } from '../types/libTypes';
+/**
+ * Example 1: Basic Local Tool Interception
+ */
+export declare function basicLocalToolInterceptionExample(codebolt: CodeboltAPI, tools: OpenAITool[]): Promise<any>;
+/**
+ * Example 2: Tool Validation and Parameter Modification
+ */
+export declare function toolValidationAndModificationExample(codebolt: CodeboltAPI, tools: OpenAITool[]): Promise<any>;
+/**
+ * Example 3: Advanced Local Tool Handling with Custom Business Logic
+ */
+export declare function advancedLocalToolHandlingExample(codebolt: CodeboltAPI, tools: OpenAITool[]): Promise<any>;
+/**
+ * Example 4: Dynamic Processor Management
+ */
+export declare function dynamicProcessorManagementExample(codebolt: CodeboltAPI, tools: OpenAITool[]): Promise<any>;
+/**
+ * Example 5: Custom Processor with Monitoring
+ */
+export declare class CustomToolMonitoringProcessor extends LocalToolInterceptorProcessor {
+    private toolExecutionMetrics;
+    processInput(input: any): Promise<any[]>;
+    private updateMetrics;
+    private getToolMetrics;
+    getAllMetrics(): Record<string, any>;
+}
+export declare function customMonitoringProcessorExample(codebolt: CodeboltAPI, tools: OpenAITool[]): Promise<{
+    result: any;
+    metrics: Record<string, any>;
+}>;