@codebolt/agent 5.0.1 → 5.0.6

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

@@ -1,391 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToolValidationProcessor = void 0;
-const processor_1 = require("../../processor");
-/**
- * Processor that validates tool calls before execution, checking parameters,
- * security constraints, and tool availability.
- */
-class ToolValidationProcessor extends processor_1.BaseProcessor {
-    constructor(options = {}) {
-        super(options);
-        this.enableParameterValidation = options.enableParameterValidation !== false;
-        this.enableSecurityValidation = options.enableSecurityValidation !== false;
-        this.enableTypeValidation = options.enableTypeValidation !== false;
-        this.strictMode = options.strictMode || false;
-        this.allowedTools = new Set(options.allowedTools || []);
-        this.blockedTools = new Set(options.blockedTools || []);
-        this.maxParameterSize = options.maxParameterSize || 1024 * 1024; // 1MB
-        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('ToolValidationSkipped', {
-                        reason: 'Not a pre-tool call processing context'
-                    })];
-            }
-            const toolName = context.toolName;
-            const toolInput = context.toolInput;
-            const toolUseId = context.toolUseId;
-            // Perform validation
-            const validationResult = await this.validateTool(toolName, toolInput, context);
-            if (!validationResult.isValid) {
-                // Tool validation failed - intercept and return error
-                const errorMessage = this.formatValidationErrors(validationResult);
-                return [
-                    this.createEvent('ToolValidationFailed', validationResult),
-                    this.createEvent('ToolIntercepted', {
-                        result: errorMessage,
-                        toolName,
-                        userRejected: false,
-                        validationFailed: true
-                    })
-                ];
-            }
-            // Validation passed
-            return [
-                this.createEvent('ToolValidationPassed', validationResult)
-            ];
-        }
-        catch (error) {
-            console.error('Error in ToolValidationProcessor:', error);
-            return [this.createEvent('ToolValidationError', {
-                    error: error instanceof Error ? error.message : String(error),
-                    toolName: (_a = input.context) === null || _a === void 0 ? void 0 : _a.toolName
-                })];
-        }
-    }
-    async validateTool(toolName, toolInput, context) {
-        const validationResult = {
-            toolName,
-            isValid: true,
-            validationErrors: [],
-            validationWarnings: [],
-            parameterValidation: {
-                required: [],
-                missing: [],
-                invalid: []
-            },
-            securityChecks: {
-                passed: true,
-                issues: []
-            }
-        };
-        // Tool availability validation
-        if (!this.validateToolAvailability(toolName, validationResult)) {
-            validationResult.isValid = false;
-        }
-        // Parameter validation
-        if (this.enableParameterValidation) {
-            if (!this.validateParameters(toolName, toolInput, validationResult)) {
-                validationResult.isValid = false;
-            }
-        }
-        // Security validation
-        if (this.enableSecurityValidation) {
-            if (!this.validateSecurity(toolName, toolInput, validationResult)) {
-                validationResult.isValid = false;
-            }
-        }
-        // Type validation
-        if (this.enableTypeValidation) {
-            if (!this.validateTypes(toolName, toolInput, validationResult)) {
-                validationResult.isValid = false;
-            }
-        }
-        // Size validation
-        if (!this.validateSize(toolInput, validationResult)) {
-            validationResult.isValid = false;
-        }
-        return validationResult;
-    }
-    validateToolAvailability(toolName, result) {
-        let isValid = true;
-        // Check if tool is explicitly blocked
-        if (this.blockedTools.has(toolName)) {
-            result.validationErrors.push(`Tool '${toolName}' is blocked and cannot be executed`);
-            isValid = false;
-        }
-        // Check if tool is in allowed list (if allowlist is configured)
-        if (this.allowedTools.size > 0 && !this.allowedTools.has(toolName)) {
-            result.validationErrors.push(`Tool '${toolName}' is not in the allowed tools list`);
-            isValid = false;
-        }
-        // Check for dangerous tool patterns
-        const dangerousPatterns = [
-            /^(rm|del|delete)$/i,
-            /^(format|fdisk)$/i,
-            /^(sudo|su)$/i,
-            /^(chmod|chown).*777/i,
-            /eval|exec|system/i
-        ];
-        if (dangerousPatterns.some(pattern => pattern.test(toolName))) {
-            result.validationWarnings.push(`Tool '${toolName}' matches potentially dangerous pattern`);
-            if (this.strictMode) {
-                result.validationErrors.push(`Tool '${toolName}' is considered dangerous in strict mode`);
-                isValid = false;
-            }
-        }
-        return isValid;
-    }
-    validateParameters(toolName, toolInput, result) {
-        let isValid = true;
-        // Get expected parameters for known tools
-        const expectedParams = this.getExpectedParameters(toolName);
-        if (expectedParams) {
-            result.parameterValidation.required = expectedParams.required || [];
-            // Check required parameters
-            for (const requiredParam of expectedParams.required || []) {
-                if (!toolInput || !(requiredParam in toolInput)) {
-                    result.parameterValidation.missing.push(requiredParam);
-                    result.validationErrors.push(`Required parameter '${requiredParam}' is missing for tool '${toolName}'`);
-                    isValid = false;
-                }
-            }
-            // Check parameter types
-            if (expectedParams.types && toolInput) {
-                for (const [paramName, expectedType] of Object.entries(expectedParams.types)) {
-                    if (paramName in toolInput) {
-                        const actualType = typeof toolInput[paramName];
-                        if (actualType !== expectedType) {
-                            result.parameterValidation.invalid.push(paramName);
-                            result.validationErrors.push(`Parameter '${paramName}' should be of type '${expectedType}' but got '${actualType}'`);
-                            isValid = false;
-                        }
-                    }
-                }
-            }
-            // Check for unexpected parameters in strict mode
-            if (this.strictMode && expectedParams.allowed && toolInput) {
-                for (const paramName of Object.keys(toolInput)) {
-                    if (!expectedParams.allowed.includes(paramName)) {
-                        result.validationWarnings.push(`Unexpected parameter '${paramName}' for tool '${toolName}'`);
-                    }
-                }
-            }
-        }
-        return isValid;
-    }
-    validateSecurity(toolName, toolInput, result) {
-        let isValid = true;
-        // Check for injection patterns in parameters
-        if (toolInput && typeof toolInput === 'object') {
-            for (const [key, value] of Object.entries(toolInput)) {
-                if (typeof value === 'string') {
-                    // SQL injection patterns
-                    const sqlInjectionPatterns = [
-                        /('|\\'|;|\\;|--|\s*or\s+|union\s+select)/i,
-                        /(drop\s+table|delete\s+from|insert\s+into)/i
-                    ];
-                    // Command injection patterns
-                    const commandInjectionPatterns = [
-                        /[;&|`$(){}[\]]/,
-                        /(rm\s+-rf)|(sudo\s+)|(chmod\s+)/i
-                    ];
-                    // Path traversal patterns
-                    const pathTraversalPatterns = [
-                        /\.\.\//,
-                        /\.\.\\/, // fixed: properly closed regex for Windows path traversal
-                        /%2[eE]%2[eE]%2[fF]/i
-                    ];
-                    const allPatterns = [
-                        ...sqlInjectionPatterns,
-                        ...commandInjectionPatterns,
-                        ...pathTraversalPatterns
-                    ];
-                    for (const pattern of allPatterns) {
-                        if (pattern.test(value)) {
-                            result.securityChecks.issues.push(`Potential security issue in parameter '${key}': suspicious pattern detected`);
-                            result.securityChecks.passed = false;
-                            if (this.strictMode) {
-                                result.validationErrors.push(`Security validation failed for parameter '${key}' in tool '${toolName}'`);
-                                isValid = false;
-                            }
-                            else {
-                                result.validationWarnings.push(`Security warning for parameter '${key}' in tool '${toolName}'`);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        // Check for sensitive file operations
-        if (toolName.includes('file') || toolName.includes('read') || toolName.includes('write')) {
-            const sensitiveFiles = [
-                '/etc/passwd',
-                '/etc/shadow',
-                '~/.ssh/',
-                '.env',
-                'config.json',
-                'secrets.json'
-            ];
-            const filePath = (toolInput === null || toolInput === void 0 ? void 0 : toolInput.filePath) || (toolInput === null || toolInput === void 0 ? void 0 : toolInput.path) || (toolInput === null || toolInput === void 0 ? void 0 : toolInput.file);
-            if (typeof filePath === 'string') {
-                for (const sensitiveFile of sensitiveFiles) {
-                    if (filePath.includes(sensitiveFile)) {
-                        result.securityChecks.issues.push(`Attempt to access sensitive file: ${filePath}`);
-                        result.securityChecks.passed = false;
-                        if (this.strictMode) {
-                            result.validationErrors.push(`Access to sensitive file '${filePath}' is not allowed`);
-                            isValid = false;
-                        }
-                        else {
-                            result.validationWarnings.push(`Warning: accessing potentially sensitive file '${filePath}'`);
-                        }
-                    }
-                }
-            }
-        }
-        return isValid;
-    }
-    validateTypes(toolName, toolInput, result) {
-        let isValid = true;
-        if (toolInput === null || toolInput === undefined) {
-            if (this.strictMode) {
-                result.validationErrors.push(`Tool input cannot be null or undefined for '${toolName}'`);
-                isValid = false;
-            }
-            return isValid;
-        }
-        // Validate input is serializable
-        try {
-            JSON.stringify(toolInput);
-        }
-        catch (error) {
-            result.validationErrors.push(`Tool input for '${toolName}' is not serializable`);
-            isValid = false;
-        }
-        // Check for circular references
-        if (typeof toolInput === 'object' && this.hasCircularReference(toolInput)) {
-            result.validationErrors.push(`Tool input for '${toolName}' contains circular references`);
-            isValid = false;
-        }
-        return isValid;
-    }
-    validateSize(toolInput, result) {
-        try {
-            const serialized = JSON.stringify(toolInput);
-            const size = new Blob([serialized]).size;
-            if (size > this.maxParameterSize) {
-                result.validationErrors.push(`Tool input size (${size} bytes) exceeds maximum allowed size (${this.maxParameterSize} bytes)`);
-                return false;
-            }
-        }
-        catch (error) {
-            result.validationWarnings.push('Could not determine tool input size');
-        }
-        return true;
-    }
-    getExpectedParameters(toolName) {
-        // Define expected parameters for common tools
-        const toolSchemas = {
-            'file_read': {
-                required: ['filePath'],
-                types: { filePath: 'string' },
-                allowed: ['filePath', 'encoding']
-            },
-            'file_write': {
-                required: ['filePath', 'content'],
-                types: { filePath: 'string', content: 'string' },
-                allowed: ['filePath', 'content', 'encoding', 'append']
-            },
-            'execute_command': {
-                required: ['command'],
-                types: { command: 'string' },
-                allowed: ['command', 'args', 'cwd', 'timeout']
-            },
-            'http_request': {
-                required: ['url'],
-                types: { url: 'string' },
-                allowed: ['url', 'method', 'headers', 'body', 'timeout']
-            },
-            'database_query': {
-                required: ['query'],
-                types: { query: 'string' },
-                allowed: ['query', 'parameters', 'database']
-            }
-        };
-        return toolSchemas[toolName] || null;
-    }
-    hasCircularReference(obj, seen = new WeakSet()) {
-        if (obj === null || typeof obj !== 'object') {
-            return false;
-        }
-        if (seen.has(obj)) {
-            return true;
-        }
-        seen.add(obj);
-        for (const value of Object.values(obj)) {
-            if (this.hasCircularReference(value, seen)) {
-                return true;
-            }
-        }
-        seen.delete(obj);
-        return false;
-    }
-    formatValidationErrors(result) {
-        const errors = result.validationErrors;
-        const warnings = result.validationWarnings;
-        let message = `Tool validation failed for '${result.toolName}':\n`;
-        if (errors.length > 0) {
-            message += '\nErrors:\n' + errors.map(error => `- ${error}`).join('\n');
-        }
-        if (warnings.length > 0) {
-            message += '\nWarnings:\n' + warnings.map(warning => `- ${warning}`).join('\n');
-        }
-        if (result.parameterValidation.missing.length > 0) {
-            message += `\nMissing required parameters: ${result.parameterValidation.missing.join(', ')}`;
-        }
-        if (result.securityChecks.issues.length > 0) {
-            message += '\nSecurity issues:\n' + result.securityChecks.issues.map(issue => `- ${issue}`).join('\n');
-        }
-        return message;
-    }
-    // Public methods for configuration
-    addAllowedTool(toolName) {
-        this.allowedTools.add(toolName);
-        if (this.enableLogging) {
-            console.log(`[ToolValidation] Added allowed tool: ${toolName}`);
-        }
-    }
-    removeAllowedTool(toolName) {
-        const removed = this.allowedTools.delete(toolName);
-        if (removed && this.enableLogging) {
-            console.log(`[ToolValidation] Removed allowed tool: ${toolName}`);
-        }
-        return removed;
-    }
-    addBlockedTool(toolName) {
-        this.blockedTools.add(toolName);
-        if (this.enableLogging) {
-            console.log(`[ToolValidation] Added blocked tool: ${toolName}`);
-        }
-    }
-    removeBlockedTool(toolName) {
-        const removed = this.blockedTools.delete(toolName);
-        if (removed && this.enableLogging) {
-            console.log(`[ToolValidation] Removed blocked tool: ${toolName}`);
-        }
-        return removed;
-    }
-    getAllowedTools() {
-        return Array.from(this.allowedTools);
-    }
-    getBlockedTools() {
-        return Array.from(this.blockedTools);
-    }
-    isToolAllowed(toolName) {
-        if (this.blockedTools.has(toolName)) {
-            return false;
-        }
-        if (this.allowedTools.size > 0) {
-            return this.allowedTools.has(toolName);
-        }
-        return true;
-    }
-}
-exports.ToolValidationProcessor = ToolValidationProcessor;

package/dist/unified/agent/tool.d.ts

@@ -1,99 +0,0 @@
-/**
- * Tool creation utilities for the Unified Agent Framework
- */
-import { z } from 'zod';
-import type { OpenAITool } from '../types/libTypes';
-import type { Tool, ToolConfig } from './agent';
-/**
- * Creates a new tool with input/output validation and execution logic
- *
- * @template TInput - Type for tool input parameters
- * @template TOutput - Type for tool output
- * @param config - Tool configuration object
- * @returns Fully configured tool with validation methods
- *
- * @example
- * ```typescript
- * const calculatorTool = createTool({
- *   id: 'calculator',
- *   name: 'Calculator',
- *   description: 'Performs basic mathematical calculations',
- *   inputSchema: z.object({
- *     expression: z.string().describe('Mathematical expression to evaluate'),
- *   }),
- *   outputSchema: z.object({
- *     result: z.number(),
- *     expression: z.string(),
- *   }),
- *   execute: async ({ input }) => {
- *     const result = eval(input.expression); // Note: eval is dangerous, use a proper parser
- *     return { result, expression: input.expression };
- *   },
- * });
- * ```
- */
-export declare function createTool<TInput = any, TOutput = any>(config: ToolConfig<TInput, TOutput>): Tool<TInput, TOutput>;
-/**
- * Creates a simple text-based tool
- */
-export declare function createTextTool(config: {
-    id: string;
-    name: string;
-    description: string;
-    execute: (text: string, context?: Record<string, any>) => Promise<string> | string;
-    timeout?: number;
-}): Tool<{
-    text: string;
-}, string>;
-/**
- * Creates a file operation tool
- */
-export declare function createFileTool(config: {
-    id: string;
-    name: string;
-    description: string;
-    operation: 'read' | 'write' | 'delete' | 'list';
-    execute: (params: any, context?: Record<string, any>) => Promise<any> | any;
-}): Tool;
-/**
- * Creates an HTTP request tool
- */
-export declare function createHttpTool(config: {
-    id: string;
-    name: string;
-    description: string;
-    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-    baseUrl?: string;
-    defaultHeaders?: Record<string, string>;
-    execute?: (params: any, context?: Record<string, any>) => Promise<any> | any;
-}): Tool;
-/**
- * Creates a validation tool
- */
-export declare function createValidationTool<T>(config: {
-    id: string;
-    name: string;
-    description: string;
-    schema: z.ZodType<T>;
-    onValid?: (data: T) => Promise<any> | any;
-    onInvalid?: (errors: string[]) => Promise<any> | any;
-}): Tool;
-/**
- * Creates a transformation tool
- */
-export declare function createTransformTool<TInput, TOutput>(config: {
-    id: string;
-    name: string;
-    description: string;
-    inputSchema: z.ZodType<TInput>;
-    outputSchema?: z.ZodType<TOutput>;
-    transform: (input: TInput, context?: Record<string, any>) => Promise<TOutput> | TOutput;
-}): Tool<TInput, TOutput>;
-/**
- * Utility to convert multiple tools to OpenAI format
- */
-export declare function toolsToOpenAIFormat(tools: Tool[]): OpenAITool[];
-/**
- * Utility to execute a tool with validation
- */
-export declare function executeTool<TInput, TOutput>(tool: Tool<TInput, TOutput>, input: unknown, context?: Record<string, any>, agent?: any): Promise<TOutput>;