@codebolt/agent 2.2.2 → 2.2.5

package/dist/unified/examples/preToolCallProcessorsExample.js

@@ -0,0 +1,458 @@
+"use strict";
+/**
+ * Example demonstrating how to use pre-tool call processors
+ * with the Unified Agent Framework
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomToolMonitoringProcessor = void 0;
+exports.basicLocalToolInterceptionExample = basicLocalToolInterceptionExample;
+exports.toolValidationAndModificationExample = toolValidationAndModificationExample;
+exports.advancedLocalToolHandlingExample = advancedLocalToolHandlingExample;
+exports.dynamicProcessorManagementExample = dynamicProcessorManagementExample;
+exports.customMonitoringProcessorExample = customMonitoringProcessorExample;
+const index_1 = require("../index");
+const processors_1 = require("../processors");
+/**
+ * Example 1: Basic Local Tool Interception
+ */
+async function basicLocalToolInterceptionExample(codebolt, tools) {
+    // Define custom local tools
+    const customCalculator = {
+        name: 'local--calculator',
+        description: 'Performs basic mathematical calculations locally',
+        execute: async (params) => {
+            const { expression } = params;
+            try {
+                // Simple expression evaluator (for demo purposes)
+                const result = eval(expression.replace(/[^0-9+\-*/().\s]/g, ''));
+                return `Calculation result: ${expression} = ${result}`;
+            }
+            catch (error) {
+                return `Calculation error: ${error}`;
+            }
+        },
+        validate: (params) => params && typeof params.expression === 'string',
+        timeout: 5000
+    };
+    const dataFormatter = {
+        name: 'local--format_data',
+        description: 'Formats data in various formats locally',
+        execute: async (params) => {
+            const { data, format } = params;
+            switch (format.toLowerCase()) {
+                case 'json':
+                    return JSON.stringify(data, null, 2);
+                case 'csv':
+                    if (Array.isArray(data)) {
+                        const headers = Object.keys(data[0] || {});
+                        const csvData = [
+                            headers.join(','),
+                            ...data.map(row => headers.map(h => row[h] || '').join(','))
+                        ];
+                        return csvData.join('\n');
+                    }
+                    return JSON.stringify(data);
+                default:
+                    return String(data);
+            }
+        }
+    };
+    // Create local tool interceptor
+    const localToolInterceptor = new processors_1.LocalToolInterceptorProcessor({
+        localTools: new Map([
+            [customCalculator.name, customCalculator],
+            [dataFormatter.name, dataFormatter]
+        ]),
+        enableCustomToolHandling: true,
+        enableLogging: true
+    });
+    // Create response executor with pre-tool processors
+    const responseExecutor = (0, index_1.createUnifiedResponseExecutor)({
+        codebolt,
+        preToolCallProcessors: [localToolInterceptor]
+    });
+    // Create unified agent
+    const agent = (0, index_1.createUnifiedAgent)({
+        codebolt,
+        maxIterations: 5,
+        enableLogging: true
+    });
+    agent.setResponseExecutor(responseExecutor);
+    // Execute agent with local tool calls
+    const result = await agent.execute({
+        userMessage: "Calculate 15 * 8 + 32 and format the result as JSON",
+        tools: [...tools, {
+                type: 'function',
+                function: {
+                    name: 'local--calculator',
+                    description: 'Performs mathematical calculations',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            expression: { type: 'string', description: 'Mathematical expression to evaluate' }
+                        },
+                        required: ['expression']
+                    }
+                }
+            }]
+    });
+    console.log('Local tool interception result:', result.response);
+    return result;
+}
+/**
+ * Example 2: Tool Validation and Parameter Modification
+ */
+async function toolValidationAndModificationExample(codebolt, tools) {
+    // Create tool validation processor
+    const toolValidator = new processors_1.ToolValidationProcessor({
+        enableParameterValidation: true,
+        enableSecurityValidation: true,
+        enableTypeValidation: true,
+        strictMode: false,
+        allowedTools: ['file_read', 'file_write', 'http_request', 'local--calculator'],
+        blockedTools: ['rm', 'delete', 'format'],
+        maxParameterSize: 1024 * 100, // 100KB
+        enableLogging: true
+    });
+    // Create custom parameter transformations
+    const customTransformations = [
+        {
+            name: 'add-project-context',
+            condition: (toolName) => toolName.includes('file'),
+            transform: (params, context) => {
+                const result = { ...params };
+                if (result.filePath && !result.filePath.startsWith('/')) {
+                    result.filePath = `./project/${result.filePath}`;
+                }
+                result.projectContext = {
+                    sessionId: (context === null || context === void 0 ? void 0 : context.sessionId) || 'unknown',
+                    timestamp: new Date().toISOString()
+                };
+                return result;
+            },
+            description: 'Add project context to file operations'
+        },
+        {
+            name: 'enhance-http-requests',
+            condition: (toolName) => toolName.includes('http'),
+            transform: (params) => {
+                const result = { ...params };
+                if (!result.headers) {
+                    result.headers = {};
+                }
+                result.headers['X-Agent-Version'] = '1.0';
+                result.headers['X-Request-ID'] = Math.random().toString(36).substr(2, 9);
+                if (!result.timeout) {
+                    result.timeout = 30000;
+                }
+                return result;
+            },
+            description: 'Enhance HTTP requests with additional headers and timeout'
+        }
+    ];
+    // Create parameter modifier processor
+    const parameterModifier = new processors_1.ToolParameterModifierProcessor({
+        enableParameterTransformation: true,
+        enableParameterEnrichment: true,
+        enableParameterSanitization: true,
+        transformations: customTransformations,
+        defaultTransformations: true,
+        enableLogging: true
+    });
+    // Create response executor with multiple pre-tool processors
+    const responseExecutor = (0, index_1.createUnifiedResponseExecutor)({
+        codebolt,
+        preToolCallProcessors: [
+            toolValidator, // Validate first
+            parameterModifier // Then modify parameters
+        ],
+        enableLogging: true
+    });
+    const agent = (0, index_1.createUnifiedAgent)({ codebolt });
+    agent.setResponseExecutor(responseExecutor);
+    // Execute with validation and modification
+    const result = await agent.execute({
+        userMessage: "Read the config.json file and make an HTTP request to the API endpoint specified in it",
+        tools
+    });
+    return result;
+}
+/**
+ * Example 3: Advanced Local Tool Handling with Custom Business Logic
+ */
+async function advancedLocalToolHandlingExample(codebolt, tools) {
+    // Create business logic tools
+    const businessLogicTools = new Map([
+        ['custom--validate_user', {
+                name: 'custom--validate_user',
+                description: 'Validates user data according to business rules',
+                execute: async (params) => {
+                    const { userData } = params;
+                    const errors = [];
+                    if (!userData.email || !userData.email.includes('@')) {
+                        errors.push('Invalid email format');
+                    }
+                    if (!userData.age || userData.age < 18) {
+                        errors.push('User must be at least 18 years old');
+                    }
+                    if (!userData.name || userData.name.length < 2) {
+                        errors.push('Name must be at least 2 characters long');
+                    }
+                    return errors.length === 0
+                        ? 'User validation passed'
+                        : `User validation failed: ${errors.join(', ')}`;
+                }
+            }],
+        ['custom--process_order', {
+                name: 'custom--process_order',
+                description: 'Processes order with business logic',
+                execute: async (params) => {
+                    var _a;
+                    const { order } = params;
+                    // Simulate order processing
+                    const total = ((_a = order.items) === null || _a === void 0 ? void 0 : _a.reduce((sum, item) => sum + (item.price * item.quantity), 0)) || 0;
+                    const tax = total * 0.08; // 8% tax
+                    const finalTotal = total + tax;
+                    return `Order processed successfully:
+                Subtotal: $${total.toFixed(2)}
+                Tax: $${tax.toFixed(2)}
+                Total: $${finalTotal.toFixed(2)}
+                Order ID: ORD-${Date.now()}`;
+                }
+            }],
+        ['internal--get_system_info', {
+                name: 'internal--get_system_info',
+                description: 'Gets internal system information',
+                execute: async () => {
+                    return `System Information:
+                Node Version: ${process.version}
+                Platform: ${process.platform}
+                Architecture: ${process.arch}
+                Memory Usage: ${JSON.stringify(process.memoryUsage(), null, 2)}
+                Uptime: ${process.uptime()} seconds`;
+                }
+            }]
+    ]);
+    // Create advanced local tool interceptor
+    const advancedInterceptor = new processors_1.LocalToolInterceptorProcessor({
+        localTools: businessLogicTools,
+        enableCustomToolHandling: true,
+        enableToolDelegation: true,
+        defaultExecutionTimeout: 10000,
+        enableLogging: true
+    });
+    // Create comprehensive validation
+    const comprehensiveValidator = new processors_1.ToolValidationProcessor({
+        enableParameterValidation: true,
+        enableSecurityValidation: true,
+        strictMode: true,
+        allowedTools: Array.from(businessLogicTools.keys()).concat(['file_read', 'http_request']),
+        enableLogging: true
+    });
+    // Create response executor
+    const responseExecutor = (0, index_1.createUnifiedResponseExecutor)({
+        codebolt,
+        preToolCallProcessors: [
+            comprehensiveValidator,
+            advancedInterceptor
+        ]
+    });
+    const agent = (0, index_1.createUnifiedAgent)({
+        codebolt,
+        maxIterations: 8,
+        enableLogging: true
+    });
+    agent.setResponseExecutor(responseExecutor);
+    // Execute complex business logic
+    const result = await agent.execute({
+        userMessage: "Validate this user data: {email: 'john@example.com', age: 25, name: 'John Doe'} and then process an order with items: [{name: 'Widget', price: 10.99, quantity: 2}, {name: 'Gadget', price: 15.50, quantity: 1}]",
+        tools: [...tools, ...Array.from(businessLogicTools.keys()).map(toolName => {
+                var _a;
+                return ({
+                    type: 'function',
+                    function: {
+                        name: toolName,
+                        description: ((_a = businessLogicTools.get(toolName)) === null || _a === void 0 ? void 0 : _a.description) || '',
+                        parameters: {
+                            type: 'object',
+                            properties: {},
+                            required: []
+                        }
+                    }
+                });
+            })]
+    });
+    return result;
+}
+/**
+ * Example 4: Dynamic Processor Management
+ */
+async function dynamicProcessorManagementExample(codebolt, tools) {
+    // Create response executor without initial processors
+    const responseExecutor = (0, index_1.createUnifiedResponseExecutor)({
+        codebolt,
+        enableLogging: true
+    });
+    const agent = (0, index_1.createUnifiedAgent)({ codebolt });
+    agent.setResponseExecutor(responseExecutor);
+    console.log('Starting without pre-tool processors...');
+    // Execute without processors
+    let result = await agent.step({
+        userMessage: "Calculate 10 + 5",
+        tools
+    });
+    // Add local tool interceptor dynamically
+    console.log('Adding local tool interceptor...');
+    const localInterceptor = new processors_1.LocalToolInterceptorProcessor({
+        enableCustomToolHandling: true,
+        enableLogging: true
+    });
+    // Add a simple calculator tool
+    localInterceptor.addLocalTool({
+        name: 'local--simple_calc',
+        execute: (params) => {
+            const { a, b, operation } = params;
+            switch (operation) {
+                case 'add': return `${a} + ${b} = ${a + b}`;
+                case 'subtract': return `${a} - ${b} = ${a - b}`;
+                case 'multiply': return `${a} * ${b} = ${a * b}`;
+                case 'divide': return `${a} / ${b} = ${a / b}`;
+                default: return 'Unknown operation';
+            }
+        }
+    });
+    responseExecutor.addPreToolCallProcessor(localInterceptor);
+    result = await agent.step({
+        userMessage: "Use the local calculator to add 15 and 25",
+        tools: [...tools, {
+                type: 'function',
+                function: {
+                    name: 'local--simple_calc',
+                    description: 'Simple calculator',
+                    parameters: {
+                        type: 'object',
+                        properties: {
+                            a: { type: 'number' },
+                            b: { type: 'number' },
+                            operation: { type: 'string', enum: ['add', 'subtract', 'multiply', 'divide'] }
+                        },
+                        required: ['a', 'b', 'operation']
+                    }
+                }
+            }],
+        conversationHistory: result.conversationHistory
+    });
+    // Add validation processor
+    console.log('Adding validation processor...');
+    const validator = new processors_1.ToolValidationProcessor({
+        strictMode: true,
+        allowedTools: ['local--simple_calc'],
+        enableLogging: true
+    });
+    responseExecutor.addPreToolCallProcessor(validator);
+    // Check active processors
+    const activeProcessors = responseExecutor.getPreToolCallProcessors();
+    console.log(`Active pre-tool processors: ${activeProcessors.length}`);
+    // Remove interceptor
+    console.log('Removing local interceptor...');
+    responseExecutor.removePreToolCallProcessor(localInterceptor);
+    const remainingProcessors = responseExecutor.getPreToolCallProcessors();
+    console.log(`Remaining processors: ${remainingProcessors.length}`);
+    return result;
+}
+/**
+ * Example 5: Custom Processor with Monitoring
+ */
+class CustomToolMonitoringProcessor extends processors_1.LocalToolInterceptorProcessor {
+    constructor() {
+        super(...arguments);
+        this.toolExecutionMetrics = new Map();
+    }
+    async processInput(input) {
+        var _a;
+        const toolName = (_a = input.context) === null || _a === void 0 ? void 0 : _a.toolName;
+        const startTime = Date.now();
+        try {
+            const results = await super.processInput(input);
+            // Update metrics on success
+            this.updateMetrics(toolName, Date.now() - startTime, false);
+            // Add monitoring event
+            results.push(this.createEvent('ToolExecutionMonitored', {
+                toolName,
+                executionTime: Date.now() - startTime,
+                status: 'success',
+                metrics: this.getToolMetrics(toolName)
+            }));
+            return results;
+        }
+        catch (error) {
+            // Update metrics on error
+            this.updateMetrics(toolName, Date.now() - startTime, true);
+            return [this.createEvent('ToolExecutionMonitoringError', {
+                    toolName,
+                    error: String(error),
+                    metrics: this.getToolMetrics(toolName)
+                })];
+        }
+    }
+    updateMetrics(toolName, executionTime, isError) {
+        if (!this.toolExecutionMetrics.has(toolName)) {
+            this.toolExecutionMetrics.set(toolName, {
+                count: 0,
+                totalTime: 0,
+                errors: 0,
+                lastExecution: new Date().toISOString()
+            });
+        }
+        const metrics = this.toolExecutionMetrics.get(toolName);
+        metrics.count++;
+        metrics.totalTime += executionTime;
+        metrics.lastExecution = new Date().toISOString();
+        if (isError) {
+            metrics.errors++;
+        }
+    }
+    getToolMetrics(toolName) {
+        const metrics = this.toolExecutionMetrics.get(toolName);
+        if (!metrics)
+            return null;
+        return {
+            ...metrics,
+            averageTime: metrics.totalTime / metrics.count,
+            errorRate: metrics.errors / metrics.count
+        };
+    }
+    getAllMetrics() {
+        const result = {};
+        for (const [toolName, metrics] of this.toolExecutionMetrics) {
+            result[toolName] = {
+                ...metrics,
+                averageTime: metrics.totalTime / metrics.count,
+                errorRate: metrics.errors / metrics.count
+            };
+        }
+        return result;
+    }
+}
+exports.CustomToolMonitoringProcessor = CustomToolMonitoringProcessor;
+async function customMonitoringProcessorExample(codebolt, tools) {
+    const monitoringProcessor = new CustomToolMonitoringProcessor({
+        enableCustomToolHandling: true,
+        enableLogging: true
+    });
+    const responseExecutor = (0, index_1.createUnifiedResponseExecutor)({
+        codebolt,
+        preToolCallProcessors: [monitoringProcessor]
+    });
+    const agent = (0, index_1.createUnifiedAgent)({ codebolt });
+    agent.setResponseExecutor(responseExecutor);
+    const result = await agent.loop({
+        userMessage: "Perform several file operations and calculations to test monitoring",
+        tools,
+        maxIterations: 10
+    });
+    // Get monitoring metrics
+    const metrics = monitoringProcessor.getAllMetrics();
+    console.log('Tool execution metrics:', metrics);
+    return { result, metrics };
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Comprehensive Workflow Example for Unified Agent Framework
+ *
+ * This example demonstrates how to create and execute complex workflows
+ * that integrate agents, tools, and control flow steps.
+ */
+declare function contentCreationWorkflowExample(): Promise<import("../index").WorkflowResult>;
+declare function multiAgentCollaborationExample(): Promise<import("../index").WorkflowResult>;
+declare function iterativeImprovementExample(): Promise<import("../index").WorkflowResult>;
+declare function agentWithWorkflowExample(): Promise<any>;
+export declare function runWorkflowExamples(): Promise<void>;
+export { contentCreationWorkflowExample, multiAgentCollaborationExample, iterativeImprovementExample, agentWithWorkflowExample };