@codebolt/agent 5.0.2 → 5.0.7

package/dist/processor-pieces/preToolCall/localToolInterceptorProcessor.js

@@ -1,444 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LocalToolInterceptorProcessor = void 0;
-const processor_1 = require("../../processor");
-/**
- * Processor that intercepts specific tool calls and handles them locally
- * instead of sending them to external tool execution services.
- */
-class LocalToolInterceptorProcessor extends processor_1.BaseProcessor {
-    constructor(options = {}) {
-        super(options);
-        this.localTools = options.localTools || new Map();
-        this.enableCustomToolHandling = options.enableCustomToolHandling !== false;
-        this.enableToolDelegation = options.enableToolDelegation !== false;
-        this.defaultExecutionTimeout = options.defaultExecutionTimeout || 30000; // 30 seconds
-        this.enableLogging = options.enableLogging !== false;
-    }
-    async processInput(input) {
-        var _a;
-        try {
-            const { message, context } = input;
-            // Check if this is a pre-tool call processing
-            if (!(context === null || context === void 0 ? void 0 : context.preToolCallProcessing)) {
-                return [this.createEvent('LocalToolInterceptionSkipped', {
-                        reason: 'Not a pre-tool call processing context'
-                    })];
-            }
-            const toolName = context.toolName;
-            const toolInput = context.toolInput;
-            const toolUseId = context.toolUseId;
-            // Check if we should intercept this tool
-            const shouldIntercept = this.shouldInterceptTool(toolName, toolInput, context);
-            if (!shouldIntercept) {
-                return [this.createEvent('LocalToolInterceptionSkipped', {
-                        toolName,
-                        reason: 'Tool not configured for local interception'
-                    })];
-            }
-            // Execute the tool locally
-            const startTime = Date.now();
-            const result = await this.executeLocalTool(toolName, toolInput, context);
-            const executionTime = Date.now() - startTime;
-            const interceptorInfo = {
-                toolName,
-                intercepted: true,
-                executionMethod: this.getExecutionMethod(toolName),
-                executionTime,
-                result
-            };
-            return [
-                this.createEvent('LocalToolIntercepted', interceptorInfo),
-                this.createEvent('ToolIntercepted', {
-                    result,
-                    toolName,
-                    executionTime,
-                    userRejected: false
-                })
-            ];
-        }
-        catch (error) {
-            console.error('Error in LocalToolInterceptorProcessor:', error);
-            return [this.createEvent('LocalToolInterceptionError', {
-                    error: error instanceof Error ? error.message : String(error),
-                    toolName: (_a = input.context) === null || _a === void 0 ? void 0 : _a.toolName
-                })];
-        }
-    }
-    shouldInterceptTool(toolName, toolInput, context) {
-        // Check if tool is in local tools registry
-        if (this.localTools.has(toolName)) {
-            return true;
-        }
-        // Check for custom tool patterns
-        if (this.enableCustomToolHandling) {
-            // Intercept tools with specific prefixes
-            const customPrefixes = ['local--', 'custom--', 'internal--'];
-            if (customPrefixes.some(prefix => toolName.startsWith(prefix))) {
-                return true;
-            }
-            // Intercept specific tool types
-            const localToolTypes = [
-                'file_read_local',
-                'file_write_local',
-                'execute_script_local',
-                'validate_data',
-                'transform_data',
-                'calculate',
-                'format_output'
-            ];
-            if (localToolTypes.includes(toolName)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    async executeLocalTool(toolName, toolInput, context) {
-        // Check if tool is in local registry
-        if (this.localTools.has(toolName)) {
-            const handler = this.localTools.get(toolName);
-            return await this.executeToolHandler(handler, toolInput, context);
-        }
-        // Handle custom tool patterns
-        if (toolName.startsWith('local--')) {
-            return await this.handleLocalPrefixTool(toolName, toolInput, context);
-        }
-        if (toolName.startsWith('custom--')) {
-            return await this.handleCustomPrefixTool(toolName, toolInput, context);
-        }
-        if (toolName.startsWith('internal--')) {
-            return await this.handleInternalPrefixTool(toolName, toolInput, context);
-        }
-        // Handle specific local tool types
-        switch (toolName) {
-            case 'file_read_local':
-                return await this.handleLocalFileRead(toolInput, context);
-            case 'file_write_local':
-                return await this.handleLocalFileWrite(toolInput, context);
-            case 'execute_script_local':
-                return await this.handleLocalScriptExecution(toolInput, context);
-            case 'validate_data':
-                return await this.handleDataValidation(toolInput, context);
-            case 'transform_data':
-                return await this.handleDataTransformation(toolInput, context);
-            case 'calculate':
-                return await this.handleCalculation(toolInput, context);
-            case 'format_output':
-                return await this.handleOutputFormatting(toolInput, context);
-            default:
-                throw new Error(`Unknown local tool: ${toolName}`);
-        }
-    }
-    async executeToolHandler(handler, toolInput, context) {
-        // Validate input if validator is provided
-        if (handler.validate && !handler.validate(toolInput)) {
-            throw new Error(`Invalid input for tool ${handler.name}`);
-        }
-        // Execute with timeout
-        const timeout = handler.timeout || this.defaultExecutionTimeout;
-        const timeoutPromise = new Promise((_, reject) => {
-            setTimeout(() => reject(new Error(`Tool execution timeout: ${handler.name}`)), timeout);
-        });
-        const executionPromise = Promise.resolve(handler.execute(toolInput, context));
-        try {
-            const result = await Promise.race([executionPromise, timeoutPromise]);
-            return typeof result === 'string' ? result : JSON.stringify(result);
-        }
-        catch (error) {
-            throw new Error(`Tool execution failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async handleLocalPrefixTool(toolName, toolInput, context) {
-        const actualToolName = toolName.replace('local--', '');
-        if (this.enableLogging) {
-            console.log(`[LocalToolInterceptor] Handling local tool: ${actualToolName}`);
-        }
-        // Simple local tool implementations
-        switch (actualToolName) {
-            case 'echo':
-                return `Local echo: ${JSON.stringify(toolInput)}`;
-            case 'timestamp':
-                return `Current timestamp: ${new Date().toISOString()}`;
-            case 'uuid':
-                return `Generated UUID: ${this.generateUUID()}`;
-            case 'hash':
-                return `Hash of input: ${this.simpleHash(JSON.stringify(toolInput))}`;
-            default:
-                return `Local tool executed: ${actualToolName} with input: ${JSON.stringify(toolInput)}`;
-        }
-    }
-    async handleCustomPrefixTool(toolName, toolInput, context) {
-        const actualToolName = toolName.replace('custom--', '');
-        if (this.enableLogging) {
-            console.log(`[LocalToolInterceptor] Handling custom tool: ${actualToolName}`);
-        }
-        // Custom tool implementations can be added here
-        return `Custom tool ${actualToolName} executed with result: ${JSON.stringify(toolInput)}`;
-    }
-    async handleInternalPrefixTool(toolName, toolInput, context) {
-        const actualToolName = toolName.replace('internal--', '');
-        if (this.enableLogging) {
-            console.log(`[LocalToolInterceptor] Handling internal tool: ${actualToolName}`);
-        }
-        // Internal tool implementations
-        switch (actualToolName) {
-            case 'context_info':
-                return `Context information: ${JSON.stringify(context, null, 2)}`;
-            case 'memory_usage':
-                return `Memory usage: ${JSON.stringify(process.memoryUsage(), null, 2)}`;
-            case 'environment':
-                return `Environment: ${process.env.NODE_ENV || 'development'}`;
-            default:
-                return `Internal tool ${actualToolName} executed`;
-        }
-    }
-    async handleLocalFileRead(toolInput, context) {
-        const filePath = toolInput.filePath || toolInput.path;
-        if (!filePath) {
-            throw new Error('File path is required for local file read');
-        }
-        try {
-            const fs = await import('fs/promises');
-            const content = await fs.readFile(filePath, 'utf-8');
-            return `File read successfully: ${filePath}\nContent length: ${content.length} characters`;
-        }
-        catch (error) {
-            throw new Error(`Failed to read file ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async handleLocalFileWrite(toolInput, context) {
-        const filePath = toolInput.filePath || toolInput.path;
-        const content = toolInput.content;
-        if (!filePath || content === undefined) {
-            throw new Error('File path and content are required for local file write');
-        }
-        try {
-            const fs = await import('fs/promises');
-            await fs.writeFile(filePath, content, 'utf-8');
-            return `File written successfully: ${filePath}\nContent length: ${content.length} characters`;
-        }
-        catch (error) {
-            throw new Error(`Failed to write file ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async handleLocalScriptExecution(toolInput, context) {
-        const script = toolInput.script;
-        const args = toolInput.args || [];
-        if (!script) {
-            throw new Error('Script is required for local script execution');
-        }
-        // For security, only allow specific safe scripts
-        const allowedScripts = ['echo', 'date', 'pwd', 'ls'];
-        if (!allowedScripts.includes(script)) {
-            throw new Error(`Script not allowed for local execution: ${script}`);
-        }
-        try {
-            const { exec } = await import('child_process');
-            const { promisify } = await import('util');
-            const execAsync = promisify(exec);
-            const command = `${script} ${args.join(' ')}`;
-            const { stdout, stderr } = await execAsync(command);
-            return `Script executed: ${command}\nOutput: ${stdout}${stderr ? `\nError: ${stderr}` : ''}`;
-        }
-        catch (error) {
-            throw new Error(`Script execution failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async handleDataValidation(toolInput, context) {
-        const data = toolInput.data;
-        const schema = toolInput.schema;
-        if (!data) {
-            throw new Error('Data is required for validation');
-        }
-        // Simple validation logic
-        const validationResults = {
-            isValid: true,
-            errors: [],
-            warnings: []
-        };
-        if (schema) {
-            // Basic schema validation
-            if (schema.required && Array.isArray(schema.required)) {
-                schema.required.forEach((field) => {
-                    if (!(field in data)) {
-                        validationResults.isValid = false;
-                        validationResults.errors.push(`Required field missing: ${field}`);
-                    }
-                });
-            }
-        }
-        return `Data validation completed: ${validationResults.isValid ? 'VALID' : 'INVALID'}\n${JSON.stringify(validationResults, null, 2)}`;
-    }
-    async handleDataTransformation(toolInput, context) {
-        const data = toolInput.data;
-        const transformation = toolInput.transformation;
-        if (!data || !transformation) {
-            throw new Error('Data and transformation are required');
-        }
-        let result = data;
-        // Apply transformations
-        switch (transformation.type) {
-            case 'uppercase':
-                result = typeof data === 'string' ? data.toUpperCase() : JSON.stringify(data).toUpperCase();
-                break;
-            case 'lowercase':
-                result = typeof data === 'string' ? data.toLowerCase() : JSON.stringify(data).toLowerCase();
-                break;
-            case 'reverse':
-                result = typeof data === 'string' ? data.split('').reverse().join('') : JSON.stringify(data);
-                break;
-            case 'sort':
-                if (Array.isArray(data)) {
-                    result = [...data].sort();
-                }
-                break;
-            default:
-                result = data;
-        }
-        return `Data transformation completed: ${transformation.type}\nResult: ${JSON.stringify(result)}`;
-    }
-    async handleCalculation(toolInput, context) {
-        const expression = toolInput.expression;
-        const values = toolInput.values || {};
-        if (!expression) {
-            throw new Error('Expression is required for calculation');
-        }
-        try {
-            // Simple calculator for basic operations
-            let result;
-            if (expression.includes('+')) {
-                const [a, b] = expression.split('+').map(x => parseFloat(x.trim()));
-                result = a + b;
-            }
-            else if (expression.includes('-')) {
-                const [a, b] = expression.split('-').map(x => parseFloat(x.trim()));
-                result = a - b;
-            }
-            else if (expression.includes('*')) {
-                const [a, b] = expression.split('*').map(x => parseFloat(x.trim()));
-                result = a * b;
-            }
-            else if (expression.includes('/')) {
-                const [a, b] = expression.split('/').map(x => parseFloat(x.trim()));
-                result = a / b;
-            }
-            else {
-                result = parseFloat(expression);
-            }
-            return `Calculation result: ${expression} = ${result}`;
-        }
-        catch (error) {
-            throw new Error(`Calculation failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async handleOutputFormatting(toolInput, context) {
-        const data = toolInput.data;
-        const format = toolInput.format || 'json';
-        if (!data) {
-            throw new Error('Data is required for output formatting');
-        }
-        try {
-            let formattedOutput;
-            switch (format.toLowerCase()) {
-                case 'json':
-                    formattedOutput = JSON.stringify(data, null, 2);
-                    break;
-                case 'yaml':
-                    // Simple YAML-like formatting
-                    formattedOutput = this.toYamlLike(data);
-                    break;
-                case 'csv':
-                    formattedOutput = this.toCsv(data);
-                    break;
-                case 'table':
-                    formattedOutput = this.toTable(data);
-                    break;
-                default:
-                    formattedOutput = String(data);
-            }
-            return `Output formatted as ${format}:\n${formattedOutput}`;
-        }
-        catch (error) {
-            throw new Error(`Output formatting failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    getExecutionMethod(toolName) {
-        if (this.localTools.has(toolName)) {
-            return 'local';
-        }
-        if (toolName.startsWith('custom--')) {
-            return 'custom';
-        }
-        return 'delegated';
-    }
-    generateUUID() {
-        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-            const r = Math.random() * 16 | 0;
-            const v = c === 'x' ? r : (r & 0x3 | 0x8);
-            return v.toString(16);
-        });
-    }
-    simpleHash(str) {
-        let hash = 0;
-        for (let i = 0; i < str.length; i++) {
-            const char = str.charCodeAt(i);
-            hash = ((hash << 5) - hash) + char;
-            hash = hash & hash; // Convert to 32-bit integer
-        }
-        return hash.toString(16);
-    }
-    toYamlLike(data, indent = 0) {
-        const spaces = '  '.repeat(indent);
-        if (typeof data === 'object' && data !== null) {
-            if (Array.isArray(data)) {
-                return data.map(item => `${spaces}- ${this.toYamlLike(item, indent + 1)}`).join('\n');
-            }
-            else {
-                return Object.entries(data)
-                    .map(([key, value]) => `${spaces}${key}: ${this.toYamlLike(value, indent + 1)}`)
-                    .join('\n');
-            }
-        }
-        return String(data);
-    }
-    toCsv(data) {
-        if (Array.isArray(data) && data.length > 0) {
-            const headers = Object.keys(data[0]);
-            const csvHeaders = headers.join(',');
-            const csvRows = data.map(row => headers.map(header => JSON.stringify(row[header] || '')).join(','));
-            return [csvHeaders, ...csvRows].join('\n');
-        }
-        return JSON.stringify(data);
-    }
-    toTable(data) {
-        if (Array.isArray(data) && data.length > 0) {
-            const headers = Object.keys(data[0]);
-            const headerRow = '| ' + headers.join(' | ') + ' |';
-            const separatorRow = '|' + headers.map(() => '---').join('|') + '|';
-            const dataRows = data.map(row => '| ' + headers.map(header => String(row[header] || '')).join(' | ') + ' |');
-            return [headerRow, separatorRow, ...dataRows].join('\n');
-        }
-        return JSON.stringify(data, null, 2);
-    }
-    // Public methods for tool management
-    addLocalTool(handler) {
-        this.localTools.set(handler.name, handler);
-        if (this.enableLogging) {
-            console.log(`[LocalToolInterceptor] Added local tool: ${handler.name}`);
-        }
-    }
-    removeLocalTool(toolName) {
-        const removed = this.localTools.delete(toolName);
-        if (removed && this.enableLogging) {
-            console.log(`[LocalToolInterceptor] Removed local tool: ${toolName}`);
-        }
-        return removed;
-    }
-    getLocalTools() {
-        return Array.from(this.localTools.keys());
-    }
-    hasLocalTool(toolName) {
-        return this.localTools.has(toolName);
-    }
-}
-exports.LocalToolInterceptorProcessor = LocalToolInterceptorProcessor;

package/dist/processor-pieces/preToolCall/toolParameterModifierProcessor.d.ts

@@ -1,44 +0,0 @@
-import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
-export interface ToolParameterModificationInfo {
-    toolName: string;
-    originalParameters: any;
-    modifiedParameters: any;
-    modificationsApplied: string[];
-    transformationsApplied: string[];
-}
-export interface ParameterTransformation {
-    name: string;
-    condition?: (toolName: string, params: any) => boolean;
-    transform: (params: any, context?: Record<string, any>) => any;
-    description?: string;
-}
-export interface ToolParameterModifierProcessorOptions {
-    enableParameterTransformation?: boolean;
-    enableParameterEnrichment?: boolean;
-    enableParameterSanitization?: boolean;
-    transformations?: ParameterTransformation[];
-    defaultTransformations?: boolean;
-    enableLogging?: boolean;
-}
-/**
- * Processor that modifies tool parameters before execution, applying transformations,
- * enrichments, and sanitization to improve tool execution.
- */
-export declare class ToolParameterModifierProcessor extends BaseProcessor {
-    private readonly enableParameterTransformation;
-    private readonly enableParameterEnrichment;
-    private readonly enableParameterSanitization;
-    private readonly transformations;
-    private readonly enableLogging;
-    constructor(options?: ToolParameterModifierProcessorOptions);
-    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
-    private modifyParameters;
-    private sanitizeParameters;
-    private enrichParameters;
-    private getDefaultTransformations;
-    private deepClone;
-    addTransformation(transformation: ParameterTransformation): void;
-    removeTransformation(name: string): boolean;
-    getTransformations(): string[];
-    hasTransformation(name: string): boolean;
-}