@codebolt/agent 5.0.7 → 5.0.9

package/dist/processor-pieces/processors/toolExecutionProcessor.js

@@ -1,207 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToolExecutionProcessor = void 0;
-const processor_1 = require("../../processor");
-const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
-class ToolExecutionProcessor extends processor_1.BaseProcessor {
-    constructor(options = {}) {
-        super(options);
-        this.executedTools = new Map();
-        this.enableToolConfirmation = options.enableToolConfirmation !== false;
-        this.maxRetries = options.maxRetries || 3;
-        this.retryDelay = options.retryDelay || 1000;
-        this.enableLogging = options.enableLogging !== false;
-    }
-    async processInput(input) {
-        try {
-            const { message, context } = input;
-            // Check if message contains tool calls
-            const toolCalls = this.extractToolCalls(message);
-            if (toolCalls.length === 0) {
-                return [this.createEvent('NoToolCalls', {
-                        reason: 'No tool calls found in message'
-                    })];
-            }
-            const events = [
-                this.createEvent('ToolCallsDetected', {
-                    count: toolCalls.length,
-                    tools: toolCalls.map(tc => tc.function.name)
-                })
-            ];
-            // Process each tool call
-            for (const toolCall of toolCalls) {
-                const executionInfo = await this.processToolCall(toolCall, context);
-                if (executionInfo.needsConfirmation) {
-                    events.push(this.createEvent('ToolConfirmationRequired', executionInfo));
-                }
-                else {
-                    const result = await this.executeTool(executionInfo);
-                    events.push(this.createEvent('ToolExecuted', result));
-                }
-            }
-            // Add summary event
-            events.push(this.createEvent('ToolExecutionSummary', {
-                totalTools: toolCalls.length,
-                executedTools: Array.from(this.executedTools.values()),
-                successRate: this.calculateSuccessRate()
-            }));
-            return events;
-        }
-        catch (error) {
-            console.error('Error in ToolExecutionProcessor:', error);
-            return [this.createEvent('ToolExecutionError', {
-                    error: error instanceof Error ? error.message : String(error)
-                })];
-        }
-    }
-    extractToolCalls(message) {
-        const toolCalls = [];
-        message.messages.forEach((msg) => {
-            if (msg.tool_calls && Array.isArray(msg.tool_calls)) {
-                toolCalls.push(...msg.tool_calls);
-            }
-        });
-        return toolCalls;
-    }
-    async processToolCall(toolCall, context) {
-        const [toolbox, toolName] = toolCall.function.name.split('--');
-        if (!toolbox || !toolName) {
-            throw new Error(`Invalid tool name format: ${toolCall.function.name}`);
-        }
-        // Parse tool arguments
-        let parameters = {};
-        try {
-            parameters = typeof toolCall.function.arguments === 'string'
-                ? JSON.parse(toolCall.function.arguments)
-                : toolCall.function.arguments;
-        }
-        catch (error) {
-            console.warn(`Failed to parse tool arguments for ${toolCall.function.name}:`, error);
-        }
-        // Check if tool needs confirmation
-        const needsConfirmation = this.shouldConfirmTool(toolCall, parameters);
-        return {
-            toolCall,
-            toolName,
-            toolbox,
-            parameters,
-            needsConfirmation
-        };
-    }
-    shouldConfirmTool(toolCall, parameters) {
-        // Check for dangerous operations
-        const dangerousOperations = [
-            'delete', 'remove', 'drop', 'destroy', 'format', 'wipe',
-            'shutdown', 'restart', 'kill', 'terminate'
-        ];
-        const toolName = toolCall.function.name.toLowerCase();
-        const hasDangerousOperation = dangerousOperations.some(op => toolName.includes(op));
-        // Check for file system operations with important paths
-        if (parameters.filePath || parameters.path) {
-            const path = (parameters.filePath || parameters.path || '').toLowerCase();
-            const importantPaths = ['/', 'c:', 'system', 'windows', 'etc', 'usr'];
-            const hasImportantPath = importantPaths.some(ip => path.includes(ip));
-            if (hasImportantPath) {
-                return true;
-            }
-        }
-        // Check for network operations
-        if (parameters.url || parameters.host || parameters.port) {
-            return true;
-        }
-        return hasDangerousOperation;
-    }
-    async executeTool(executionInfo) {
-        const startTime = Date.now();
-        const { toolCall, toolbox, toolName, parameters } = executionInfo;
-        try {
-            // Execute tool using CodeBolt's MCP
-            const { data } = await codeboltjs_1.default.mcp.executeTool(toolbox, toolName, parameters);
-            // Data comes as [failure: boolean, content: string] from CodeBolt MCP
-            let resultData;
-            let success = true;
-            if (Array.isArray(data) && data.length >= 2) {
-                const [failure, content] = data;
-                if (failure) {
-                    success = false;
-                    resultData = content; // Content is error message on failure
-                }
-                else {
-                    resultData = content; // Content is result on success
-                }
-            }
-            else {
-                // Fallback for unexpected data format
-                console.warn(`[Tool] Unexpected data format from ${toolCall.function.name}:`, data);
-                resultData = data;
-            }
-            const executionResult = {
-                toolCallId: toolCall.id,
-                result: resultData,
-                success: success,
-                executionTime: Date.now() - startTime,
-                error: success ? undefined : String(resultData)
-            };
-            // Store result
-            this.executedTools.set(toolCall.id, executionResult);
-            // Log execution if enabled
-            if (this.enableLogging) {
-                console.log(`[Tool] Successfully executed ${toolbox}--${toolName} in ${executionResult.executionTime}ms`);
-            }
-            return executionResult;
-        }
-        catch (error) {
-            const executionResult = {
-                toolCallId: toolCall.id,
-                result: null,
-                error: error instanceof Error ? error.message : String(error),
-                success: false,
-                executionTime: Date.now() - startTime
-            };
-            // Store result
-            this.executedTools.set(toolCall.id, executionResult);
-            // Log error if enabled
-            if (this.enableLogging) {
-                console.error(`[Tool] Failed to execute ${toolbox}--${toolName}:`, error);
-            }
-            return executionResult;
-        }
-    }
-    calculateSuccessRate() {
-        if (this.executedTools.size === 0)
-            return 0;
-        const successfulTools = Array.from(this.executedTools.values())
-            .filter(result => result.success).length;
-        return (successfulTools / this.executedTools.size) * 100;
-    }
-    // Public methods for external control
-    async confirmToolExecution(toolCallId, confirmed) {
-        // This method can be used to track confirmation status in the future
-        // For now, we'll just log the confirmation
-        if (this.enableLogging) {
-            console.log(`[ToolExecutor] Tool ${toolCallId} confirmation: ${confirmed}`);
-        }
-    }
-    getToolExecutionHistory() {
-        return Array.from(this.executedTools.values());
-    }
-    clearToolHistory() {
-        this.executedTools.clear();
-    }
-    setMaxRetries(maxRetries) {
-        this.maxRetries = Math.max(1, maxRetries);
-    }
-    setRetryDelay(delay) {
-        this.retryDelay = Math.max(100, delay);
-    }
-    enableLoggingForSession() {
-        this.enableLogging = true;
-    }
-    disableLoggingForSession() {
-        this.enableLogging = false;
-    }
-}
-exports.ToolExecutionProcessor = ToolExecutionProcessor;

package/dist/processor-pieces/tools/fileTools.d.ts

@@ -1,26 +0,0 @@
-import { BaseTool } from '../../processor';
-export declare class FileReadTool extends BaseTool {
-    constructor();
-    execute(params: any, abortSignal?: AbortSignal): Promise<string>;
-    protected validateParameters(params: any): boolean;
-}
-export declare class FileWriteTool extends BaseTool {
-    constructor();
-    execute(params: any, abortSignal?: AbortSignal): Promise<string>;
-    protected validateParameters(params: any): boolean;
-}
-export declare class FileDeleteTool extends BaseTool {
-    constructor();
-    execute(params: any, abortSignal?: AbortSignal): Promise<string>;
-    protected validateParameters(params: any): boolean;
-}
-export declare class FileMoveTool extends BaseTool {
-    constructor();
-    execute(params: any, abortSignal?: AbortSignal): Promise<string>;
-    protected validateParameters(params: any): boolean;
-}
-export declare class FileCopyTool extends BaseTool {
-    constructor();
-    execute(params: any, abortSignal?: AbortSignal): Promise<string>;
-    protected validateParameters(params: any): boolean;
-}

package/dist/processor-pieces/tools/fileTools.js

@@ -1,162 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileCopyTool = exports.FileMoveTool = exports.FileDeleteTool = exports.FileWriteTool = exports.FileReadTool = void 0;
-const processor_1 = require("../../processor");
-const fs = __importStar(require("fs/promises"));
-const path = __importStar(require("path"));
-class FileReadTool extends processor_1.BaseTool {
-    constructor() {
-        super('FileRead', 'Read content from a file', {
-            filePath: { type: 'string', required: true, description: 'Path to the file to read' }
-        });
-    }
-    async execute(params, abortSignal) {
-        await this.checkAbortSignal(abortSignal);
-        if (!this.validateParameters(params)) {
-            throw new Error('Invalid parameters: filePath is required');
-        }
-        const { filePath } = params;
-        const content = await fs.readFile(filePath, 'utf-8');
-        return content;
-    }
-    validateParameters(params) {
-        return params && typeof params.filePath === 'string' && params.filePath.trim() !== '';
-    }
-}
-exports.FileReadTool = FileReadTool;
-class FileWriteTool extends processor_1.BaseTool {
-    constructor() {
-        super('FileWrite', 'Write content to a file', {
-            filePath: { type: 'string', required: true, description: 'Path to the file to write' },
-            content: { type: 'string', required: true, description: 'Content to write to the file' }
-        });
-    }
-    async execute(params, abortSignal) {
-        await this.checkAbortSignal(abortSignal);
-        if (!this.validateParameters(params)) {
-            throw new Error('Invalid parameters: filePath and content are required');
-        }
-        const { filePath, content } = params;
-        // Ensure directory exists
-        const dir = path.dirname(filePath);
-        await fs.mkdir(dir, { recursive: true });
-        await fs.writeFile(filePath, content, 'utf-8');
-        return `Successfully wrote ${content.length} characters to ${filePath}`;
-    }
-    validateParameters(params) {
-        return params &&
-            typeof params.filePath === 'string' &&
-            params.filePath.trim() !== '' &&
-            typeof params.content === 'string';
-    }
-}
-exports.FileWriteTool = FileWriteTool;
-class FileDeleteTool extends processor_1.BaseTool {
-    constructor() {
-        super('FileDelete', 'Delete a file', {
-            filePath: { type: 'string', required: true, description: 'Path to the file to delete' }
-        });
-    }
-    async execute(params, abortSignal) {
-        await this.checkAbortSignal(abortSignal);
-        if (!this.validateParameters(params)) {
-            throw new Error('Invalid parameters: filePath is required');
-        }
-        const { filePath } = params;
-        await fs.unlink(filePath);
-        return `Successfully deleted ${filePath}`;
-    }
-    validateParameters(params) {
-        return params && typeof params.filePath === 'string' && params.filePath.trim() !== '';
-    }
-}
-exports.FileDeleteTool = FileDeleteTool;
-class FileMoveTool extends processor_1.BaseTool {
-    constructor() {
-        super('FileMove', 'Move a file from one location to another', {
-            sourcePath: { type: 'string', required: true, description: 'Source file path' },
-            destinationPath: { type: 'string', required: true, description: 'Destination file path' }
-        });
-    }
-    async execute(params, abortSignal) {
-        await this.checkAbortSignal(abortSignal);
-        if (!this.validateParameters(params)) {
-            throw new Error('Invalid parameters: sourcePath and destinationPath are required');
-        }
-        const { sourcePath, destinationPath } = params;
-        // Ensure destination directory exists
-        const dir = path.dirname(destinationPath);
-        await fs.mkdir(dir, { recursive: true });
-        await fs.rename(sourcePath, destinationPath);
-        return `Successfully moved ${sourcePath} to ${destinationPath}`;
-    }
-    validateParameters(params) {
-        return params &&
-            typeof params.sourcePath === 'string' &&
-            params.sourcePath.trim() !== '' &&
-            typeof params.destinationPath === 'string' &&
-            params.destinationPath.trim() !== '';
-    }
-}
-exports.FileMoveTool = FileMoveTool;
-class FileCopyTool extends processor_1.BaseTool {
-    constructor() {
-        super('FileCopy', 'Copy a file from one location to another', {
-            sourcePath: { type: 'string', required: true, description: 'Source file path' },
-            destinationPath: { type: 'string', required: true, description: 'Destination file path' }
-        });
-    }
-    async execute(params, abortSignal) {
-        await this.checkAbortSignal(abortSignal);
-        if (!this.validateParameters(params)) {
-            throw new Error('Invalid parameters: sourcePath and destinationPath are required');
-        }
-        const { sourcePath, destinationPath } = params;
-        // Ensure destination directory exists
-        const dir = path.dirname(destinationPath);
-        await fs.mkdir(dir, { recursive: true });
-        await fs.copyFile(sourcePath, destinationPath);
-        return `Successfully copied ${sourcePath} to ${destinationPath}`;
-    }
-    validateParameters(params) {
-        return params &&
-            typeof params.sourcePath === 'string' &&
-            params.sourcePath.trim() !== '' &&
-            typeof params.destinationPath === 'string' &&
-            params.destinationPath.trim() !== '';
-    }
-}
-exports.FileCopyTool = FileCopyTool;