@codebolt/agent 5.0.1 → 5.0.6

package/dist/processor-pieces/messageModifiers/workingDirectoryMessageModifier.js

@@ -37,49 +37,37 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkingDirectoryMessageModifier = void 0;
-const base_1 = require("../base");
+const processor_1 = require("../../processor");
 const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
 const path = __importStar(require("path"));
-const fs = __importStar(require("fs/promises"));
-class WorkingDirectoryMessageModifier extends base_1.BaseMessageModifier {
+class WorkingDirectoryMessageModifier extends processor_1.BaseMessageModifier {
     constructor(options = {}) {
         super({ context: options });
-        this.defaultIgnoredFolders = new Set(['node_modules', '.git', 'dist', '.codebolt', '.codeboltAgents']);
-        this.truncationIndicator = '...';
         this.showFolderStructureSummary = options.showFolderStructureSummary || false;
         this.listFiles = options.listFiles || false;
         this.listFilesDepth = options.listFilesDepth || 2;
-        this.listFilesLimit = options.listFilesLimit || 100;
+        this.listFilesLimit = options.listFilesLimit || 200;
         this.listFilesIgnoreFromGitignore = options.listFilesIgnoreFromGitignore || true;
-        this.listFilesIgnore = options.listFilesIgnore || ['node_modules', '.git', 'dist', '.codebolt', '.codeboltAgents'];
-        this.maxItems = options.maxItems || 200;
-        this.showFullDirectoryContext = options.showFullDirectoryContext || true;
+        this.listFilesIgnore = options.listFilesIgnore || ['node_modules', '.git', 'dist', 'build'];
     }
-    async modify(originalRequest, createdMessage) {
+    async modify(input) {
         try {
+            const { originalRequest, createdMessage, context } = input;
             const contextParts = [];
             // Get project information
             try {
-                const { projectPath } = await codeboltjs_1.default.project.getProjectPath();
-                if (!projectPath) {
-                    throw new Error('Project path not available');
+                const projectPathResponse = await codeboltjs_1.default.project.getProjectPath();
+                const projectPath = typeof projectPathResponse === 'string'
+                    ? projectPathResponse
+                    : (projectPathResponse === null || projectPathResponse === void 0 ? void 0 : projectPathResponse.path) || String(projectPathResponse) || '';
+                contextParts.push(`Project Directory: ${projectPath}`);
+                if (this.showFolderStructureSummary) {
+                    const summary = await this.generateFolderStructureSummary(projectPath);
+                    contextParts.push(`Folder Structure Summary:\n${summary}`);
                 }
-                // Generate comprehensive directory context similar to gemini-cli
-                if (this.showFullDirectoryContext) {
-                    const directoryContext = await this.getDirectoryContextString(projectPath);
-                    contextParts.push(directoryContext);
-                }
-                else {
-                    // Fallback to original behavior
-                    contextParts.push(`Project Directory: ${projectPath}`);
-                    if (this.showFolderStructureSummary) {
-                        const summary = await this.generateFolderStructureSummary(projectPath);
-                        contextParts.push(`Folder Structure Summary:\n${summary}`);
-                    }
-                    if (this.listFiles) {
-                        const filesList = await this.generateFilesList(projectPath);
-                        contextParts.push(`Files List:\n${filesList}`);
-                    }
+                if (this.listFiles) {
+                    const filesList = await this.generateFilesList(projectPath);
+                    contextParts.push(`Files List:\n${filesList}`);
                 }
             }
             catch (error) {
@@ -88,30 +76,13 @@ class WorkingDirectoryMessageModifier extends base_1.BaseMessageModifier {
             }
             // Create context message if we have any context parts
             if (contextParts.length > 0) {
-                const contextContent = contextParts.join('\n\n');
-                const messages = [...createdMessage.message.messages];
-                // Find existing system message
-                const systemMessageIndex = messages.findIndex(msg => msg.role === 'system');
-                if (systemMessageIndex !== -1) {
-                    // Update existing system message
-                    messages[systemMessageIndex] = {
-                        ...messages[systemMessageIndex],
-                        content: `${messages[systemMessageIndex].content}\n\n${contextContent}`
-                    };
-                }
-                else {
-                    // Add new system message at the top
-                    messages.unshift({
-                        role: 'system',
-                        content: contextContent
-                    });
-                }
+                const contextMessage = {
+                    role: 'system',
+                    content: contextParts.join('\n\n'),
+                    name: 'working-directory-context'
+                };
                 return {
-                    ...createdMessage,
-                    message: {
-                        ...createdMessage.message,
-                        messages
-                    },
+                    messages: [contextMessage, ...createdMessage.messages],
                     metadata: {
                         ...createdMessage.metadata,
                         workingDirectoryContextAdded: true,
@@ -128,14 +99,44 @@ class WorkingDirectoryMessageModifier extends base_1.BaseMessageModifier {
     }
     async generateFolderStructureSummary(projectPath) {
         try {
+            // Use CodeBolt's directory listing with recursive option
+            const response = await codeboltjs_1.default.fs.listDirectory({
+                path: projectPath,
+                show_hidden: false,
+                detailed: false,
+                limit: 200,
+                notifyUser: false
+            });
             const directories = new Set();
-            await this.collectDirectories(projectPath, directories, 0, 3); // Max depth of 3
-            const sortedDirs = Array.from(directories)
-                .filter(dir => dir !== projectPath && !this.shouldIgnore(dir))
-                .sort()
-                .slice(0, 20);
+            // Extract directories from the response
+            if (response && response.success) {
+                let entries;
+                if (typeof response.result === 'string') {
+                    // If result is a string, we'll need to parse it or work with what we have
+                    return response.result.split('\n').slice(0, 20).join('\n');
+                }
+                else if (response.result && response.result.entries) {
+                    entries = response.result.entries;
+                }
+                else if (response.entries) {
+                    entries = response.entries;
+                }
+                if (entries) {
+                    entries.forEach((entry) => {
+                        if (entry.type === 'directory' && !this.shouldIgnore(entry.path || entry.name)) {
+                            directories.add(entry.path || entry.name);
+                        }
+                        // Also get parent directories of files
+                        const dir = path.dirname(entry.path || entry.name);
+                        if (dir !== '.' && !this.shouldIgnore(dir)) {
+                            directories.add(dir);
+                        }
+                    });
+                }
+            }
+            const sortedDirs = Array.from(directories).sort();
             return sortedDirs.length > 0
-                ? sortedDirs.join('\n')
+                ? sortedDirs.slice(0, 20).join('\n')
                 : 'No accessible directories found';
         }
         catch (error) {
@@ -144,249 +145,50 @@ class WorkingDirectoryMessageModifier extends base_1.BaseMessageModifier {
     }
     async generateFilesList(projectPath) {
         try {
+            // Use CodeBolt's directory listing to get files
+            const response = await codeboltjs_1.default.fs.listDirectory({
+                path: projectPath,
+                show_hidden: false,
+                detailed: false,
+                limit: this.listFilesLimit,
+                notifyUser: false
+            });
             const files = [];
-            await this.collectFiles(projectPath, files, 0, 2); // Max depth of 2
-            const filteredFiles = files
-                .filter(filePath => !this.shouldIgnore(filePath))
-                .slice(0, this.listFilesLimit)
-                .map(filePath => path.basename(filePath));
-            return filteredFiles.length > 0
-                ? filteredFiles.join('\n')
-                : 'No accessible files found';
-        }
-        catch (error) {
-            return 'Unable to generate files list';
-        }
-    }
-    async collectDirectories(dirPath, directories, currentDepth, maxDepth) {
-        if (currentDepth >= maxDepth)
-            return;
-        try {
-            const entries = await fs.readdir(dirPath, { withFileTypes: true });
-            for (const entry of entries) {
-                if (entry.isDirectory()) {
-                    const fullPath = path.join(dirPath, entry.name);
-                    if (!this.shouldIgnore(fullPath)) {
-                        directories.add(fullPath);
-                        await this.collectDirectories(fullPath, directories, currentDepth + 1, maxDepth);
-                    }
+            // Extract files from the response
+            if (response && response.success) {
+                let entries;
+                if (typeof response.result === 'string') {
+                    // If result is a string, split and filter for files
+                    return response.result.split('\n')
+                        .filter((line) => !this.shouldIgnore(line))
+                        .slice(0, this.listFilesLimit)
+                        .join('\n');
                 }
-            }
-        }
-        catch (error) {
-            // Skip directories we can't read
-        }
-    }
-    async collectFiles(dirPath, files, currentDepth, maxDepth) {
-        if (currentDepth >= maxDepth || files.length >= this.listFilesLimit)
-            return;
-        try {
-            const entries = await fs.readdir(dirPath, { withFileTypes: true });
-            for (const entry of entries) {
-                if (entry.isFile()) {
-                    const fullPath = path.join(dirPath, entry.name);
-                    if (!this.shouldIgnore(fullPath)) {
-                        files.push(fullPath);
-                        if (files.length >= this.listFilesLimit)
-                            break;
-                    }
+                else if (response.result && response.result.entries) {
+                    entries = response.result.entries;
                 }
-                else if (entry.isDirectory() && currentDepth < maxDepth - 1) {
-                    const fullPath = path.join(dirPath, entry.name);
-                    if (!this.shouldIgnore(fullPath)) {
-                        await this.collectFiles(fullPath, files, currentDepth + 1, maxDepth);
-                    }
+                else if (response.entries) {
+                    entries = response.entries;
+                }
+                if (entries) {
+                    entries.forEach((entry) => {
+                        if (entry.type === 'file' && !this.shouldIgnore(entry.path || entry.name)) {
+                            files.push(entry.path || entry.name);
+                        }
+                    });
                 }
             }
+            const filteredFiles = files.slice(0, this.listFilesLimit);
+            return filteredFiles.length > 0
+                ? filteredFiles.join('\n')
+                : 'No accessible files found';
         }
         catch (error) {
-            // Skip directories we can't read
+            return 'Unable to generate files list';
         }
     }
     shouldIgnore(filePath) {
-        const basename = path.basename(filePath);
-        // Ignore any folder/file that starts with a dot
-        if (basename.startsWith('.')) {
-            return true;
-        }
-        return this.listFilesIgnore.some(ignore => filePath.includes(ignore) || basename === ignore);
-    }
-    // Comprehensive directory context methods exactly like gemini-cli
-    async getDirectoryContextString(projectPath) {
-        const folderStructure = await this.getFolderStructure(projectPath);
-        const workingDirPreamble = `I'm currently working in the directory: ${projectPath}`;
-        return `${workingDirPreamble}
-Here is the folder structure of the current working directories:
-
-${folderStructure}`;
-    }
-    async getFolderStructure(directory) {
-        const resolvedPath = path.resolve(directory);
-        try {
-            const structureRoot = await this.readFullStructure(resolvedPath);
-            if (!structureRoot) {
-                return `Error: Could not read directory "${resolvedPath}". Check path and permissions.`;
-            }
-            const structureLines = [];
-            this.formatStructure(structureRoot, '', true, true, structureLines);
-            const isTruncated = this.isTruncated(structureRoot);
-            let summary = `Showing up to ${this.maxItems} items (files + folders).`;
-            if (isTruncated) {
-                summary += ` Folders or files indicated with ${this.truncationIndicator} contain more items not shown, were ignored, or the display limit (${this.maxItems} items) was reached.`;
-            }
-            return `${summary}\n\n${resolvedPath}${path.sep}\n${structureLines.join('\n')}`;
-        }
-        catch (error) {
-            console.error(`Error getting folder structure for ${resolvedPath}:`, error);
-            return `Error processing directory "${resolvedPath}": ${error instanceof Error ? error.message : String(error)}`;
-        }
-    }
-    async readFullStructure(rootPath) {
-        const rootName = path.basename(rootPath);
-        const rootNode = {
-            name: rootName,
-            path: rootPath,
-            files: [],
-            subFolders: [],
-            totalChildren: 0,
-            totalFiles: 0,
-        };
-        const queue = [
-            { folderInfo: rootNode, currentPath: rootPath },
-        ];
-        let currentItemCount = 0;
-        const processedPaths = new Set();
-        while (queue.length > 0) {
-            const { folderInfo, currentPath } = queue.shift();
-            if (processedPaths.has(currentPath)) {
-                continue;
-            }
-            processedPaths.add(currentPath);
-            if (currentItemCount >= this.maxItems) {
-                continue;
-            }
-            let entries;
-            try {
-                const rawEntries = await fs.readdir(currentPath, { withFileTypes: true });
-                entries = rawEntries.sort((a, b) => a.name.localeCompare(b.name));
-            }
-            catch (error) {
-                if (error.code === 'EACCES' || error.code === 'ENOENT') {
-                    console.warn(`Warning: Could not read directory ${currentPath}: ${error.message}`);
-                    if (currentPath === rootPath && error.code === 'ENOENT') {
-                        return null;
-                    }
-                    continue;
-                }
-                throw error;
-            }
-            const filesInCurrentDir = [];
-            const subFoldersInCurrentDir = [];
-            // Process files first
-            for (const entry of entries) {
-                if (entry.isFile()) {
-                    if (currentItemCount >= this.maxItems) {
-                        folderInfo.hasMoreFiles = true;
-                        break;
-                    }
-                    const fileName = entry.name;
-                    const filePath = path.join(currentPath, fileName);
-                    if (!this.shouldIgnore(filePath)) {
-                        filesInCurrentDir.push(fileName);
-                        currentItemCount++;
-                        folderInfo.totalFiles++;
-                        folderInfo.totalChildren++;
-                    }
-                }
-            }
-            folderInfo.files = filesInCurrentDir;
-            // Process directories
-            for (const entry of entries) {
-                if (entry.isDirectory()) {
-                    if (currentItemCount >= this.maxItems) {
-                        folderInfo.hasMoreSubfolders = true;
-                        break;
-                    }
-                    const subFolderName = entry.name;
-                    const subFolderPath = path.join(currentPath, subFolderName);
-                    const isIgnored = this.defaultIgnoredFolders.has(subFolderName) ||
-                        subFolderName.startsWith('.') ||
-                        this.shouldIgnore(subFolderPath);
-                    if (isIgnored) {
-                        const ignoredSubFolder = {
-                            name: subFolderName,
-                            path: subFolderPath,
-                            files: [],
-                            subFolders: [],
-                            totalChildren: 0,
-                            totalFiles: 0,
-                            isIgnored: true,
-                        };
-                        subFoldersInCurrentDir.push(ignoredSubFolder);
-                        currentItemCount++;
-                        folderInfo.totalChildren++;
-                        continue;
-                    }
-                    const subFolderNode = {
-                        name: subFolderName,
-                        path: subFolderPath,
-                        files: [],
-                        subFolders: [],
-                        totalChildren: 0,
-                        totalFiles: 0,
-                    };
-                    subFoldersInCurrentDir.push(subFolderNode);
-                    currentItemCount++;
-                    folderInfo.totalChildren++;
-                    queue.push({ folderInfo: subFolderNode, currentPath: subFolderPath });
-                }
-            }
-            folderInfo.subFolders = subFoldersInCurrentDir;
-        }
-        return rootNode;
-    }
-    formatStructure(node, currentIndent, isLastChildOfParent, isProcessingRootNode, builder) {
-        const connector = isLastChildOfParent ? '└───' : '├───';
-        if (!isProcessingRootNode || node.isIgnored) {
-            builder.push(`${currentIndent}${connector}${node.name}${path.sep}${node.isIgnored ? this.truncationIndicator : ''}`);
-        }
-        const indentForChildren = isProcessingRootNode
-            ? ''
-            : currentIndent + (isLastChildOfParent ? '    ' : '│   ');
-        // Render files
-        const fileCount = node.files.length;
-        for (let i = 0; i < fileCount; i++) {
-            const isLastFileAmongSiblings = i === fileCount - 1 &&
-                node.subFolders.length === 0 &&
-                !node.hasMoreSubfolders;
-            const fileConnector = isLastFileAmongSiblings ? '└───' : '├───';
-            builder.push(`${indentForChildren}${fileConnector}${node.files[i]}`);
-        }
-        if (node.hasMoreFiles) {
-            const isLastIndicatorAmongSiblings = node.subFolders.length === 0 && !node.hasMoreSubfolders;
-            const fileConnector = isLastIndicatorAmongSiblings ? '└───' : '├───';
-            builder.push(`${indentForChildren}${fileConnector}${this.truncationIndicator}`);
-        }
-        // Render subfolders
-        const subFolderCount = node.subFolders.length;
-        for (let i = 0; i < subFolderCount; i++) {
-            const isLastSubfolderAmongSiblings = i === subFolderCount - 1 && !node.hasMoreSubfolders;
-            this.formatStructure(node.subFolders[i], indentForChildren, isLastSubfolderAmongSiblings, false, builder);
-        }
-        if (node.hasMoreSubfolders) {
-            builder.push(`${indentForChildren}└───${this.truncationIndicator}`);
-        }
-    }
-    isTruncated(node) {
-        if (node.hasMoreFiles || node.hasMoreSubfolders || node.isIgnored) {
-            return true;
-        }
-        for (const sub of node.subFolders) {
-            if (this.isTruncated(sub)) {
-                return true;
-            }
-        }
-        return false;
+        return this.listFilesIgnore.some(ignore => filePath.includes(ignore) || path.basename(filePath) === ignore);
     }
 }
 exports.WorkingDirectoryMessageModifier = WorkingDirectoryMessageModifier;

package/dist/processor-pieces/postToolCallProcessors/conversationCompactorModifier.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Conversation Compactor Modifier
+ * Post-Tool Call processor for compacting conversation history to reduce context size
+ */
+import { BasePostToolCallProcessor } from '../base/basePostToolCallProcessor';
+import { PostToolCallProcessorInput, PostToolCallProcessorOutput } from '@codebolt/types/agent';
+export interface ConversationCompactorOptions {
+    maxMessages?: number;
+    preserveSystemMessages?: boolean;
+    preserveLastUserMessages?: number;
+    preserveLastToolResults?: number;
+    compactStrategy?: 'simple' | 'smart' | 'summarize';
+}
+export declare class ConversationCompactorModifier extends BasePostToolCallProcessor {
+    private options;
+    constructor(options?: ConversationCompactorOptions);
+    modify(input: PostToolCallProcessorInput): Promise<PostToolCallProcessorOutput>;
+}

package/dist/processor-pieces/postToolCallProcessors/conversationCompactorModifier.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Conversation Compactor Modifier
+ * Post-Tool Call processor for compacting conversation history to reduce context size
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationCompactorModifier = void 0;
+const basePostToolCallProcessor_1 = require("../base/basePostToolCallProcessor");
+class ConversationCompactorModifier extends basePostToolCallProcessor_1.BasePostToolCallProcessor {
+    constructor(options = {}) {
+        super();
+        this.options = {
+            maxMessages: 50,
+            preserveSystemMessages: true,
+            preserveLastUserMessages: 5,
+            preserveLastToolResults: 10,
+            compactStrategy: 'smart',
+            ...options
+        };
+    }
+    async modify(input) {
+        // For now, pass through the nextPrompt unchanged since we need to understand
+        // the ProcessedMessage structure better for compaction
+        // TODO: Implement conversation compaction logic once we understand the message structure
+        // Add metadata to track that this processor was applied
+        const modifiedNextPrompt = {
+            ...input.nextPrompt,
+            metadata: {
+                ...input.nextPrompt.metadata,
+                compactedBy: 'ConversationCompactorModifier',
+                compactedAt: new Date().toISOString(),
+                strategy: this.options.compactStrategy
+            }
+        };
+        return {
+            nextPrompt: modifiedNextPrompt,
+            shouldExit: false
+        };
+    }
+}
+exports.ConversationCompactorModifier = ConversationCompactorModifier;

package/dist/processor-pieces/postToolCallProcessors/index.d.ts

@@ -1 +1,2 @@
-export {};
+export { ShellProcessorModifier } from './shellProcessorModifier';
+export { ConversationCompactorModifier, type ConversationCompactorOptions } from './conversationCompactorModifier';

package/dist/processor-pieces/postToolCallProcessors/index.js

@@ -1,2 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationCompactorModifier = exports.ShellProcessorModifier = void 0;
+var shellProcessorModifier_1 = require("./shellProcessorModifier");
+Object.defineProperty(exports, "ShellProcessorModifier", { enumerable: true, get: function () { return shellProcessorModifier_1.ShellProcessorModifier; } });
+var conversationCompactorModifier_1 = require("./conversationCompactorModifier");
+Object.defineProperty(exports, "ConversationCompactorModifier", { enumerable: true, get: function () { return conversationCompactorModifier_1.ConversationCompactorModifier; } });

package/dist/processor-pieces/preInferenceProcessors/index.d.ts

@@ -1 +1 @@
-export {};
+export { ChatCompressionModifier, type ChatCompressionOptions } from './chatCompressionModifier';

package/dist/processor-pieces/preInferenceProcessors/index.js

@@ -1,2 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatCompressionModifier = void 0;
+var chatCompressionModifier_1 = require("./chatCompressionModifier");
+Object.defineProperty(exports, "ChatCompressionModifier", { enumerable: true, get: function () { return chatCompressionModifier_1.ChatCompressionModifier; } });

package/dist/processor-pieces/pretoolCallProcessors/index.d.ts

@@ -1 +1,2 @@
-export {};
+export { ToolParameterModifier, type ToolParameterModifierOptions } from './toolParameterModifier';
+export { ToolValidationModifier, type ToolValidationModifierOptions } from './toolValidationModifier';

package/dist/processor-pieces/pretoolCallProcessors/index.js

@@ -1,2 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolValidationModifier = exports.ToolParameterModifier = void 0;
+var toolParameterModifier_1 = require("./toolParameterModifier");
+Object.defineProperty(exports, "ToolParameterModifier", { enumerable: true, get: function () { return toolParameterModifier_1.ToolParameterModifier; } });
+var toolValidationModifier_1 = require("./toolValidationModifier");
+Object.defineProperty(exports, "ToolValidationModifier", { enumerable: true, get: function () { return toolValidationModifier_1.ToolValidationModifier; } });

package/dist/processor-pieces/pretoolCallProcessors/toolParameterModifier.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Tool Parameter Modifier
+ * Pre-Tool Call processor for modifying tool parameters before execution
+ */
+import { BasePreToolCallProcessor } from '../base/basePreToolCallProcessor';
+import { PreToolCallProcessorInput, PreToolCallProcessorOutput } from '@codebolt/types/agent';
+export interface ParameterTransformation {
+    sourcePath: string;
+    targetPath: string;
+    transformation?: (value: any) => any;
+    description?: string;
+}
+export interface ToolParameterModifierOptions {
+    parameterTransformations: Record<string, ParameterTransformation[]>;
+    toolNameMappings?: Record<string, string>;
+}
+export declare class ToolParameterModifier extends BasePreToolCallProcessor {
+    private options;
+    constructor(options: ToolParameterModifierOptions);
+    modify(input: PreToolCallProcessorInput): Promise<PreToolCallProcessorOutput>;
+}

package/dist/processor-pieces/pretoolCallProcessors/toolParameterModifier.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Tool Parameter Modifier
+ * Pre-Tool Call processor for modifying tool parameters before execution
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolParameterModifier = void 0;
+const basePreToolCallProcessor_1 = require("../base/basePreToolCallProcessor");
+class ToolParameterModifier extends basePreToolCallProcessor_1.BasePreToolCallProcessor {
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    async modify(input) {
+        // For now, pass through unchanged since we need to understand the exact structure
+        // TODO: Implement parameter modification logic once we understand the message format
+        // Add metadata to track that this processor was applied
+        const modifiedNextPrompt = {
+            ...input.nextPrompt,
+            metadata: {
+                ...input.nextPrompt.metadata,
+                modifiedBy: 'ToolParameterModifier',
+                modifiedAt: new Date().toISOString()
+            }
+        };
+        return {
+            nextPrompt: modifiedNextPrompt,
+            shouldExit: false
+        };
+    }
+}
+exports.ToolParameterModifier = ToolParameterModifier;

package/dist/processor-pieces/pretoolCallProcessors/toolValidationModifier.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Tool Validation Modifier
+ * Pre-Tool Call processor for validating tool parameters before execution
+ */
+import { BasePreToolCallProcessor } from '../base/basePreToolCallProcessor';
+import { PreToolCallProcessorInput, PreToolCallProcessorOutput, ToolValidationRule } from '@codebolt/types/agent';
+export interface ToolValidationModifierOptions {
+    validationRules: ToolValidationRule[];
+    strictMode?: boolean;
+    allowPartialValidation?: boolean;
+}
+export declare class ToolValidationModifier extends BasePreToolCallProcessor {
+    private options;
+    constructor(options: ToolValidationModifierOptions);
+    modify(input: PreToolCallProcessorInput): Promise<PreToolCallProcessorOutput>;
+}

package/dist/processor-pieces/pretoolCallProcessors/toolValidationModifier.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Tool Validation Modifier
+ * Pre-Tool Call processor for validating tool parameters before execution
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolValidationModifier = void 0;
+const basePreToolCallProcessor_1 = require("../base/basePreToolCallProcessor");
+class ToolValidationModifier extends basePreToolCallProcessor_1.BasePreToolCallProcessor {
+    constructor(options) {
+        super();
+        this.options = {
+            strictMode: false,
+            allowPartialValidation: true,
+            ...options
+        };
+    }
+    async modify(input) {
+        // For now, pass through unchanged since we need to understand the exact structure
+        // TODO: Implement tool validation logic once we understand the message format
+        // Add metadata to track that this processor was applied
+        const modifiedNextPrompt = {
+            ...input.nextPrompt,
+            metadata: {
+                ...input.nextPrompt.metadata,
+                validatedBy: 'ToolValidationModifier',
+                validatedAt: new Date().toISOString(),
+                validationMode: this.options.strictMode ? 'strict' : 'lenient'
+            }
+        };
+        return {
+            nextPrompt: modifiedNextPrompt,
+            shouldExit: false
+        };
+    }
+}
+exports.ToolValidationModifier = ToolValidationModifier;