@codebolt/agent 1.2.1 → 2.2.3

package/dist/processor-pieces/additionalModifiers/memoryImportModifier.js

@@ -0,0 +1,129 @@
+"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.MemoryImportModifier = void 0;
+const base_1 = require("../base");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class MemoryImportModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.options = {
+            enableMemoryImport: options.enableMemoryImport !== false,
+            maxFileSize: options.maxFileSize || 1024 * 1024, // 1MB
+            allowedExtensions: options.allowedExtensions || ['.md', '.txt', '.json', '.yml', '.yaml', '.xml'],
+            basePath: options.basePath || process.cwd(),
+            maxImports: options.maxImports || 10
+        };
+    }
+    async modify(originalRequest, createdMessage) {
+        try {
+            if (!this.options.enableMemoryImport) {
+                return createdMessage;
+            }
+            // Get the user message content to process
+            const userMessage = createdMessage.message.messages.find(msg => msg.role === 'user');
+            if (!userMessage || typeof userMessage.content !== 'string') {
+                return createdMessage;
+            }
+            // Look for @path/to/file patterns (memory import syntax)
+            const memoryImportPattern = /@([^\s@]+(?:\.[a-zA-Z0-9]+)?)/g;
+            let content = userMessage.content;
+            const processedImports = [];
+            let match;
+            let importCount = 0;
+            while ((match = memoryImportPattern.exec(userMessage.content)) !== null && importCount < this.options.maxImports) {
+                const filePath = match[1];
+                const fullPath = path.isAbsolute(filePath) ? filePath : path.join(this.options.basePath, filePath);
+                try {
+                    // Check if file exists and is allowed
+                    const stats = await fs.promises.stat(fullPath);
+                    if (!stats.isFile()) {
+                        continue;
+                    }
+                    if (stats.size > this.options.maxFileSize) {
+                        content = content.replace(match[0], `[File too large: ${filePath}]`);
+                        continue;
+                    }
+                    const ext = path.extname(filePath);
+                    if (!this.options.allowedExtensions.includes(ext)) {
+                        content = content.replace(match[0], `[Unsupported file type: ${filePath}]`);
+                        continue;
+                    }
+                    // Read and import the file content
+                    const fileContent = await fs.promises.readFile(fullPath, 'utf-8');
+                    const importedContent = `--- Content from ${filePath} ---\n${fileContent}\n--- End of ${filePath} ---`;
+                    content = content.replace(match[0], importedContent);
+                    processedImports.push(filePath);
+                    importCount++;
+                }
+                catch (error) {
+                    // Replace with error message if file can't be read
+                    content = content.replace(match[0], `[Error reading ${filePath}: ${error instanceof Error ? error.message : 'unknown error'}]`);
+                }
+            }
+            if (processedImports.length === 0) {
+                return createdMessage;
+            }
+            // Update the user message with processed content
+            const messages = createdMessage.message.messages.map(msg => {
+                if (msg.role === 'user' && msg === userMessage) {
+                    return {
+                        ...msg,
+                        content
+                    };
+                }
+                return msg;
+            });
+            return Promise.resolve({
+                message: {
+                    ...createdMessage.message,
+                    messages
+                },
+                metadata: {
+                    ...createdMessage.metadata,
+                    memoryImportsProcessed: true,
+                    importedFiles: processedImports,
+                    totalImports: processedImports.length
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error in MemoryImportModifier:', error);
+            return createdMessage;
+        }
+    }
+}
+exports.MemoryImportModifier = MemoryImportModifier;

package/dist/processor-pieces/additionalModifiers/shellProcessorModifier.d.ts

@@ -0,0 +1,25 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface ShellProcessorOptions {
+    enableShellExecution?: boolean;
+    maxExecutionTime?: number;
+    allowedCommands?: string[];
+    blockedCommands?: string[];
+    workingDirectory?: string;
+}
+export declare class ShellProcessorModifier extends BaseMessageModifier {
+    private readonly options;
+    private readonly execAsync;
+    private readonly SHELL_TRIGGER;
+    private readonly SHELL_CLOSE;
+    private readonly ARGS_PLACEHOLDER;
+    constructor(options?: ShellProcessorOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private processShellInjections;
+    private extractShellInjections;
+    private validateCommand;
+    private executeCommand;
+    private escapeShellArg;
+    private escapeRegex;
+}

package/dist/processor-pieces/additionalModifiers/shellProcessorModifier.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShellProcessorModifier = void 0;
+const base_1 = require("../base");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+class ShellProcessorModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.execAsync = (0, util_1.promisify)(child_process_1.exec);
+        this.SHELL_TRIGGER = '!{';
+        this.SHELL_CLOSE = '}';
+        this.ARGS_PLACEHOLDER = '{{args}}';
+        this.options = {
+            enableShellExecution: options.enableShellExecution || false, // Disabled by default for security
+            maxExecutionTime: options.maxExecutionTime || 10000, // 10 seconds
+            allowedCommands: options.allowedCommands || ['ls', 'pwd', 'echo', 'cat', 'head', 'tail', 'grep', 'find', 'wc'],
+            blockedCommands: options.blockedCommands || ['rm', 'del', 'format', 'sudo', 'su', 'chmod', 'chown', 'kill', 'killall'],
+            workingDirectory: options.workingDirectory || process.cwd()
+        };
+    }
+    async modify(originalRequest, createdMessage) {
+        var _a;
+        try {
+            // Get the user message content to process
+            const userMessage = createdMessage.message.messages.find(msg => msg.role === 'user');
+            if (!userMessage || typeof userMessage.content !== 'string') {
+                return createdMessage;
+            }
+            const content = userMessage.content;
+            const args = ((_a = createdMessage.metadata) === null || _a === void 0 ? void 0 : _a.args) || '';
+            // First, replace {{args}} placeholders
+            let processedContent = content.replace(new RegExp(this.escapeRegex(this.ARGS_PLACEHOLDER), 'g'), args);
+            // Then process shell injections if enabled
+            if (this.options.enableShellExecution && processedContent.includes(this.SHELL_TRIGGER)) {
+                processedContent = await this.processShellInjections(processedContent, args);
+            }
+            // If content was modified, update the message
+            if (processedContent !== content) {
+                const updatedMessages = createdMessage.message.messages.map(msg => {
+                    if (msg.role === 'user' && typeof msg.content === 'string' && msg.content === content) {
+                        return {
+                            ...msg,
+                            content: processedContent
+                        };
+                    }
+                    return msg;
+                });
+                return Promise.resolve({
+                    message: {
+                        ...createdMessage.message,
+                        messages: updatedMessages
+                    },
+                    metadata: {
+                        ...createdMessage.metadata,
+                        shellProcessed: true,
+                        argsReplaced: content.includes(this.ARGS_PLACEHOLDER)
+                    }
+                });
+            }
+            return createdMessage;
+        }
+        catch (error) {
+            console.error('Error in ShellProcessorModifier:', error);
+            return createdMessage;
+        }
+    }
+    async processShellInjections(content, args) {
+        let processedContent = content;
+        const injections = this.extractShellInjections(content);
+        // Process injections in reverse order to maintain correct indices
+        for (let i = injections.length - 1; i >= 0; i--) {
+            const injection = injections[i];
+            try {
+                // Replace {{args}} in the command with shell-escaped args
+                const command = injection.command.replace(new RegExp(this.escapeRegex(this.ARGS_PLACEHOLDER), 'g'), this.escapeShellArg(args));
+                // Validate and execute command
+                this.validateCommand(command);
+                const result = await this.executeCommand(command);
+                const replacement = result;
+                processedContent = processedContent.substring(0, injection.startIndex) +
+                    replacement +
+                    processedContent.substring(injection.endIndex);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                const replacement = `[Shell command error: ${errorMessage}]`;
+                processedContent = processedContent.substring(0, injection.startIndex) +
+                    replacement +
+                    processedContent.substring(injection.endIndex);
+            }
+        }
+        return processedContent;
+    }
+    extractShellInjections(content) {
+        const injections = [];
+        let searchIndex = 0;
+        while (true) {
+            const startIndex = content.indexOf(this.SHELL_TRIGGER, searchIndex);
+            if (startIndex === -1)
+                break;
+            const contentStart = startIndex + this.SHELL_TRIGGER.length;
+            const endIndex = content.indexOf(this.SHELL_CLOSE, contentStart);
+            if (endIndex === -1) {
+                // No closing brace found, skip this occurrence
+                searchIndex = contentStart;
+                continue;
+            }
+            const command = content.substring(contentStart, endIndex).trim();
+            if (command.length > 0) {
+                injections.push({
+                    startIndex,
+                    endIndex: endIndex + this.SHELL_CLOSE.length,
+                    command
+                });
+            }
+            searchIndex = endIndex + this.SHELL_CLOSE.length;
+        }
+        return injections;
+    }
+    validateCommand(command) {
+        if (!this.options.enableShellExecution) {
+            throw new Error('Shell execution is disabled');
+        }
+        // Extract the base command (first word)
+        const baseCommand = command.trim().split(/\s+/)[0];
+        // Check blocked commands
+        if (this.options.blockedCommands.some(blocked => baseCommand.includes(blocked))) {
+            throw new Error(`Command '${baseCommand}' is blocked for security reasons`);
+        }
+        // Check allowed commands (if allowlist is defined)
+        if (this.options.allowedCommands.length > 0 &&
+            !this.options.allowedCommands.some(allowed => baseCommand.includes(allowed))) {
+            throw new Error(`Command '${baseCommand}' is not in the allowed commands list`);
+        }
+        // Additional security checks
+        if (command.includes('&&') || command.includes('||') || command.includes(';') || command.includes('|')) {
+            throw new Error('Command chaining and piping are not allowed');
+        }
+    }
+    async executeCommand(command) {
+        try {
+            const { stdout, stderr } = await this.execAsync(command, {
+                cwd: this.options.workingDirectory,
+                timeout: this.options.maxExecutionTime,
+                maxBuffer: 1024 * 1024 // 1MB buffer
+            });
+            let result = stdout;
+            if (stderr) {
+                result += `\n[stderr]: ${stderr}`;
+            }
+            return result || '[Command executed successfully with no output]';
+        }
+        catch (error) {
+            if (error.killed && error.signal === 'SIGTERM') {
+                throw new Error(`Command timed out after ${this.options.maxExecutionTime}ms`);
+            }
+            throw new Error(`Command failed: ${error.message}`);
+        }
+    }
+    escapeShellArg(arg) {
+        // Basic shell escaping - in production, use a proper shell escaping library
+        return `"${arg.replace(/"/g, '\\"')}"`;
+    }
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+}
+exports.ShellProcessorModifier = ShellProcessorModifier;

package/dist/processor-pieces/additionalModifiers/toolInjectionModifier.d.ts

@@ -0,0 +1,20 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface ToolInjectionOptions {
+    toolsLocation?: 'Tool' | 'SystemMessage' | 'InsidePrompt';
+    includeToolDescriptions?: boolean;
+    maxToolsInMessage?: number;
+    giveToolExamples?: boolean;
+    maxToolExamples?: number;
+}
+export declare class ToolInjectionModifier extends BaseMessageModifier {
+    private readonly options;
+    constructor(options?: ToolInjectionOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private addToolsInsidePrompt;
+    private addToolsAsSystemMessage;
+    private addToolsAsToolCalls;
+    private generateToolsInfo;
+    private generateToolExample;
+}

package/dist/processor-pieces/additionalModifiers/toolInjectionModifier.js

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolInjectionModifier = void 0;
+const base_1 = require("../base");
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+class ToolInjectionModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.options = {
+            toolsLocation: options.toolsLocation || 'Tool',
+            includeToolDescriptions: options.includeToolDescriptions !== false,
+            maxToolsInMessage: options.maxToolsInMessage || 20,
+            giveToolExamples: options.giveToolExamples || false,
+            maxToolExamples: options.maxToolExamples || 2
+        };
+    }
+    async modify(originalRequest, createdMessage) {
+        try {
+            const toolsResponse = await codeboltjs_1.default.mcp.listMcpFromServers(['codebolt']);
+            const tools = (toolsResponse === null || toolsResponse === void 0 ? void 0 : toolsResponse.data) || [];
+            if (tools.length === 0) {
+                return createdMessage;
+            }
+            switch (this.options.toolsLocation) {
+                case 'InsidePrompt':
+                    //@ts-ignore
+                    return this.addToolsInsidePrompt(createdMessage, tools);
+                //@ts-ignore
+                case 'SystemMessage':
+                    //@ts-ignore
+                    return this.addToolsAsSystemMessage(createdMessage, tools);
+                case 'Tool':
+                    //@ts-ignore
+                    return this.addToolsAsToolCalls(createdMessage, tools);
+                default:
+                    //@ts-ignore
+                    return this.addToolsAsToolCalls(createdMessage, tools);
+            }
+        }
+        catch (error) {
+            console.error('Error in ToolInjectionModifier:', error);
+            return createdMessage;
+        }
+    }
+    addToolsInsidePrompt(createdMessage, tools) {
+        const toolsInfo = this.generateToolsInfo(tools);
+        // Modify the last user message to include tools information
+        const modifiedMessages = createdMessage.message.messages.map((message, index) => {
+            if (message.role === 'user' && index === createdMessage.message.messages.length - 1) {
+                return {
+                    ...message,
+                    content: `${message.content}\n\n--- Available Tools ---\n${toolsInfo}`
+                };
+            }
+            return message;
+        });
+        return {
+            message: {
+                ...createdMessage.message,
+                messages: modifiedMessages
+            },
+            metadata: {
+                ...createdMessage.metadata,
+                toolsInjected: true,
+                toolsLocation: 'InsidePrompt',
+                toolsCount: tools.length
+            }
+        };
+    }
+    addToolsAsSystemMessage(createdMessage, tools) {
+        const toolsInfo = this.generateToolsInfo(tools);
+        const toolsMessage = {
+            role: 'system',
+            content: `Available Tools:\n${toolsInfo}`
+        };
+        return {
+            message: {
+                ...createdMessage.message,
+                messages: [toolsMessage, ...createdMessage.message.messages]
+            },
+            metadata: {
+                ...createdMessage.metadata,
+                toolsInjected: true,
+                toolsLocation: 'SystemMessage',
+                toolsCount: tools.length
+            }
+        };
+    }
+    addToolsAsToolCalls(createdMessage, tools) {
+        return {
+            message: {
+                ...createdMessage.message,
+                tools,
+                tool_choice: 'auto'
+            },
+            metadata: {
+                ...createdMessage.metadata,
+                toolsInjected: true,
+                toolsLocation: 'Tool',
+                toolsCount: tools.length
+            }
+        };
+    }
+    generateToolsInfo(tools) {
+        const toolsInfo = [];
+        tools.slice(0, this.options.maxToolsInMessage).forEach((tool, index) => {
+            let toolInfo = `${index + 1}. **${tool.function.name}**`;
+            if (this.options.includeToolDescriptions && tool.function.description) {
+                toolInfo += `\n   Description: ${tool.function.description}`;
+            }
+            if (tool.function.parameters) {
+                const params = typeof tool.function.parameters === 'object'
+                    ? Object.keys(tool.function.parameters).join(', ')
+                    : String(tool.function.parameters);
+                toolInfo += `\n   Parameters: ${params}`;
+            }
+            if (this.options.giveToolExamples && index < this.options.maxToolExamples) {
+                const example = this.generateToolExample(tool);
+                if (example) {
+                    toolInfo += `\n   Example: ${example}`;
+                }
+            }
+            toolsInfo.push(toolInfo);
+        });
+        return toolsInfo.join('\n\n');
+    }
+    generateToolExample(tool) {
+        // Generate simple examples based on tool name
+        const toolName = tool.function.name.toLowerCase();
+        if (toolName.includes('read') && toolName.includes('file')) {
+            return `${tool.function.name}({ filePath: "example.txt" })`;
+        }
+        if (toolName.includes('write') && toolName.includes('file')) {
+            return `${tool.function.name}({ filePath: "output.txt", content: "Hello World" })`;
+        }
+        if (toolName.includes('delete') && toolName.includes('file')) {
+            return `${tool.function.name}({ filePath: "temp.txt" })`;
+        }
+        if (toolName.includes('move') && toolName.includes('file')) {
+            return `${tool.function.name}({ sourcePath: "old.txt", destinationPath: "new.txt" })`;
+        }
+        if (toolName.includes('copy') && toolName.includes('file')) {
+            return `${tool.function.name}({ sourcePath: "source.txt", destinationPath: "copy.txt" })`;
+        }
+        // Generic example
+        return `${tool.function.name}({ /* parameters */ })`;
+    }
+}
+exports.ToolInjectionModifier = ToolInjectionModifier;

package/dist/processor-pieces/base/baseMessageModifier.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Base Message Modifier Class
+ * Abstract base class for all message modifiers
+ * Message modifiers convert user messages to prompts for the LLM
+ */
+import { MessageModifier, MessageModifierOptions, ProcessedMessage } from '@codebolt/types/agent';
+import { FlatUserMessage } from '@codebolt/types/sdk';
+export declare abstract class BaseMessageModifier implements MessageModifier {
+    protected context: Record<string, unknown>;
+    constructor(options?: MessageModifierOptions);
+    abstract modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+}

package/dist/processor-pieces/base/baseMessageModifier.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * Base Message Modifier Class
+ * Abstract base class for all message modifiers
+ * Message modifiers convert user messages to prompts for the LLM
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseMessageModifier = void 0;
+class BaseMessageModifier {
+    constructor(options = {}) {
+        this.context = {};
+        this.context = options.context || {};
+    }
+}
+exports.BaseMessageModifier = BaseMessageModifier;

package/dist/processor-pieces/base/basePostInferenceProcessor.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Base Post-Inference Processor Class
+ * Abstract base class for all post-inference processors
+ * These are called after the LLM is called and we have gotten the response
+ * This is before the actual Tool Call is done
+ */
+import { PostInferenceProcessor, ProcessedMessage } from '@codebolt/types/agent';
+import { LLMResponse } from '@codebolt/types/sdk';
+export declare abstract class BasePostInferenceProcessor implements PostInferenceProcessor {
+    protected context: Record<string, unknown>;
+    constructor();
+    abstract modify(llmMessageSent: ProcessedMessage, llmResponseMessage: LLMResponse, nextPrompt: ProcessedMessage): Promise<ProcessedMessage>;
+}

package/dist/processor-pieces/base/basePostInferenceProcessor.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Base Post-Inference Processor Class
+ * Abstract base class for all post-inference processors
+ * These are called after the LLM is called and we have gotten the response
+ * This is before the actual Tool Call is done
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasePostInferenceProcessor = void 0;
+class BasePostInferenceProcessor {
+    // constructor(options: PostInferenceProcessorOptions = {}) {
+    //     this.context = options.context || {};
+    // }
+    constructor() {
+        this.context = {};
+    }
+}
+exports.BasePostInferenceProcessor = BasePostInferenceProcessor;

package/dist/processor-pieces/base/basePostToolCallProcessor.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Base Post-Tool Call Processor Class
+ * Abstract base class for all post-tool call processors
+ * These are called after the Tool Call
+ * Help in checking the tool call results and adding them to the LLM message
+ */
+import { PostToolCallProcessor, PostToolCallProcessorInput, PostToolCallProcessorOutput } from '@codebolt/types/agent';
+export declare abstract class BasePostToolCallProcessor implements PostToolCallProcessor {
+    protected context: Record<string, unknown>;
+    constructor();
+    abstract modify(input: PostToolCallProcessorInput): Promise<PostToolCallProcessorOutput>;
+    setContext(key: string, value: unknown): void;
+    getContext(key: string): unknown;
+    clearContext(): void;
+}

package/dist/processor-pieces/base/basePostToolCallProcessor.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Base Post-Tool Call Processor Class
+ * Abstract base class for all post-tool call processors
+ * These are called after the Tool Call
+ * Help in checking the tool call results and adding them to the LLM message
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasePostToolCallProcessor = void 0;
+class BasePostToolCallProcessor {
+    constructor() {
+        this.context = {};
+        // this.context = options.context || {};
+    }
+    setContext(key, value) {
+        this.context[key] = value;
+    }
+    getContext(key) {
+        return this.context[key];
+    }
+    clearContext() {
+        this.context = {};
+    }
+}
+exports.BasePostToolCallProcessor = BasePostToolCallProcessor;

package/dist/processor-pieces/base/basePreInferenceProcessor.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Base Pre-Inference Processor Class
+ * Abstract base class for all pre-inference processors
+ * These are called before the Agent calls the LLM
+ */
+import { PreInferenceProcessor, ProcessedMessage } from '@codebolt/types/agent';
+import { FlatUserMessage } from '@codebolt/types/sdk';
+export declare abstract class BasePreInferenceProcessor implements PreInferenceProcessor {
+    protected context: Record<string, unknown>;
+    constructor();
+    abstract modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+}

package/dist/processor-pieces/base/basePreInferenceProcessor.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Base Pre-Inference Processor Class
+ * Abstract base class for all pre-inference processors
+ * These are called before the Agent calls the LLM
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasePreInferenceProcessor = void 0;
+class BasePreInferenceProcessor {
+    // constructor(options: PreInferenceProcessorOptions = {}) {
+    //     this.context = options.context || {};
+    // }
+    constructor() {
+        this.context = {};
+    }
+}
+exports.BasePreInferenceProcessor = BasePreInferenceProcessor;

package/dist/processor-pieces/base/basePreToolCallProcessor.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Base Pre-Tool Call Processor Class
+ * Abstract base class for all pre-tool call processors
+ * These are called before the Tool Call
+ * Used to check if the Tool Call is proper and handle Local Tool Interceptor
+ */
+import { PreToolCallProcessor, PreToolCallProcessorInput, PreToolCallProcessorOutput, InterceptedTool, ToolValidationRule, ToolValidationResult, ToolCall } from '@codebolt/types/agent';
+export declare abstract class BasePreToolCallProcessor implements PreToolCallProcessor {
+    protected context: Record<string, unknown>;
+    constructor();
+    abstract modify(input: PreToolCallProcessorInput): Promise<PreToolCallProcessorOutput>;
+    interceptTool?(_toolName: string, _toolInput: unknown): Promise<boolean>;
+    setContext(key: string, value: unknown): void;
+    getContext(key: string): unknown;
+    clearContext(): void;
+    protected createInterceptedTool(toolName: string, originalInput: unknown, result?: unknown, reason?: string): InterceptedTool;
+    protected validateToolCall(toolCall: ToolCall, validationRules: ToolValidationRule[]): ToolValidationResult;
+}