@codebolt/agent 1.2.1 → 2.2.3

package/dist/local-tools/fileTools.js

@@ -0,0 +1,162 @@
+"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;

package/dist/processor/agent/agentStep.d.ts

@@ -0,0 +1,49 @@
+import { IAgentStep, AgentStepInput, AgentStepOutput, ProcessedMessage, ToolList, ToolExecutor, Processor } from '../types/interfaces';
+export interface AgentStepOptions {
+    inputProcessors?: Processor[];
+    outputProcessors?: Processor[];
+    toolList?: ToolList;
+    toolExecutor?: ToolExecutor;
+    maxIterations?: number;
+}
+export declare abstract class AgentStep implements IAgentStep {
+    protected readonly inputProcessors: Processor[];
+    protected readonly outputProcessors: Processor[];
+    protected readonly toolList?: ToolList;
+    protected readonly toolExecutor?: ToolExecutor;
+    protected readonly maxIterations: number;
+    constructor(options?: AgentStepOptions);
+    /**
+     * Single step processing with input/output processors
+     */
+    step(message: ProcessedMessage, context?: Record<string, any>): Promise<ProcessedMessage>;
+    generateOneStep(input: AgentStepInput): Promise<AgentStepOutput>;
+    generateWithToolExecution(input: AgentStepInput): Promise<AgentStepOutput>;
+    loop(input: AgentStepInput, maxIterations?: number): Promise<AgentStepOutput>;
+    protected abstract analyzeForToolCalls(message: ProcessedMessage, tools: any[], context?: Record<string, any>): Promise<Array<{
+        tool: string;
+        parameters: any;
+    }> | null>;
+    protected abstract generateFinalResponse(message: ProcessedMessage, toolResults: any, context?: Record<string, any>): Promise<AgentStepOutput>;
+}
+export interface LLMConfig {
+    llmname?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    apiKey?: string;
+    baseUrl?: string;
+}
+export interface LLMAgentStepOptions extends AgentStepOptions {
+    llmconfig?: LLMConfig;
+}
+export declare class LLMAgentStep extends AgentStep {
+    protected readonly llmConfig: LLMConfig;
+    constructor(options?: LLMAgentStepOptions);
+    protected analyzeForToolCalls(message: ProcessedMessage, tools: any[], context?: Record<string, any>): Promise<Array<{
+        tool: string;
+        parameters: any;
+    }> | null>;
+    protected generateFinalResponse(message: ProcessedMessage, toolResults: any, context?: Record<string, any>): Promise<AgentStepOutput>;
+    private extractFilePath;
+}

package/dist/processor/agent/agentStep.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMAgentStep = exports.AgentStep = void 0;
+class AgentStep {
+    constructor(options = {}) {
+        this.inputProcessors = options.inputProcessors || [];
+        this.outputProcessors = options.outputProcessors || [];
+        this.toolList = options.toolList;
+        this.toolExecutor = options.toolExecutor;
+        this.maxIterations = options.maxIterations || 10;
+    }
+    /**
+     * Single step processing with input/output processors
+     */
+    async step(message, context) {
+        var _a;
+        try {
+            let processedMessage = message;
+            // Apply input processors
+            for (const processor of this.inputProcessors) {
+                const results = await processor.processInput({
+                    message: processedMessage,
+                    context
+                });
+                // Find the processed message from results
+                const messageEvent = results.find(r => r.type === 'MessageProcessed' || r.type === 'MessageWithContext');
+                if (messageEvent && messageEvent.value) {
+                    processedMessage = messageEvent.value;
+                }
+            }
+            // Analyze for tool calls
+            const toolCalls = await this.analyzeForToolCalls(processedMessage, ((_a = this.toolList) === null || _a === void 0 ? void 0 : _a.getAllTools()) || [], context);
+            if (toolCalls && toolCalls.length > 0) {
+                // Execute tools if we have a tool executor
+                if (this.toolExecutor) {
+                    const toolResults = await this.toolExecutor.executeTools({
+                        toolCalls,
+                        tools: this.toolList || { getAllTools: () => [], getTool: () => undefined, addTool: () => { }, removeTool: () => { } },
+                        context
+                    });
+                    // Generate response with tool results
+                    const stepOutput = await this.generateFinalResponse(processedMessage, toolResults, context);
+                    processedMessage = stepOutput.response;
+                }
+                else {
+                    // Return message with tool calls for external execution
+                    processedMessage = {
+                        messages: [
+                            ...processedMessage.messages,
+                            {
+                                role: 'assistant',
+                                content: `I need to use tools: ${toolCalls.map(t => t.tool).join(', ')}`,
+                                tool_calls: toolCalls.map(t => ({
+                                    id: `tool-${Date.now()}`,
+                                    function: { name: t.tool, arguments: t.parameters }
+                                }))
+                            }
+                        ]
+                    };
+                }
+            }
+            else {
+                // No tool calls needed, generate final response
+                const stepOutput = await this.generateFinalResponse(processedMessage, null, context);
+                processedMessage = stepOutput.response;
+            }
+            // Apply output processors
+            for (const processor of this.outputProcessors) {
+                const results = await processor.processInput({
+                    message: processedMessage,
+                    context
+                });
+                // Find the processed message from results
+                const messageEvent = results.find(r => r.type === 'MessageProcessed' || r.type === 'FinalResponse');
+                if (messageEvent && messageEvent.value) {
+                    processedMessage = messageEvent.value;
+                }
+            }
+            return processedMessage;
+        }
+        catch (error) {
+            console.error('Error in AgentStep.step:', error);
+            throw error;
+        }
+    }
+    async generateOneStep(input) {
+        try {
+            const { message, tools, context } = input;
+            // Analyze for tool calls
+            const toolCalls = await this.analyzeForToolCalls(message, tools, context);
+            if (toolCalls && toolCalls.length > 0) {
+                // Execute tools
+                const toolResults = await this.toolExecutor.executeTools({
+                    toolCalls,
+                    tools: { getAllTools: () => tools, getTool: (name) => tools.find(t => t.name === name), addTool: () => { }, removeTool: () => { } },
+                    context
+                });
+                // Generate response with tool results
+                return await this.generateFinalResponse(message, toolResults, context);
+            }
+            else {
+                // No tool calls needed, generate final response
+                return await this.generateFinalResponse(message, null, context);
+            }
+        }
+        catch (error) {
+            console.error('Error in generateOneStep:', error);
+            throw error;
+        }
+    }
+    async generateWithToolExecution(input) {
+        try {
+            const { message, tools, context } = input;
+            // Analyze for tool calls
+            const toolCalls = await this.analyzeForToolCalls(message, tools, context);
+            if (toolCalls && toolCalls.length > 0) {
+                // Execute tools
+                const toolResults = await this.toolExecutor.executeTools({
+                    toolCalls,
+                    tools: { getAllTools: () => tools, getTool: (name) => tools.find(t => t.name === name), addTool: () => { }, removeTool: () => { } },
+                    context
+                });
+                // Generate response with tool results
+                return await this.generateFinalResponse(message, toolResults, context);
+            }
+            else {
+                // No tool calls needed, generate final response
+                return await this.generateFinalResponse(message, null, context);
+            }
+        }
+        catch (error) {
+            console.error('Error in generateWithToolExecution:', error);
+            throw error;
+        }
+    }
+    async loop(input, maxIterations) {
+        const maxIter = maxIterations || this.maxIterations;
+        let currentMessage = input.message;
+        let iteration = 0;
+        while (iteration < maxIter) {
+            iteration++;
+            // Generate one step
+            const stepResult = await this.generateOneStep({
+                message: currentMessage,
+                tools: input.tools,
+                context: input.context
+            });
+            // Check if finished
+            if (stepResult.finished) {
+                return stepResult;
+            }
+            // Update message for next iteration
+            currentMessage = stepResult.response;
+        }
+        // Max iterations reached
+        return await this.generateFinalResponse(currentMessage, null, input.context);
+    }
+}
+exports.AgentStep = AgentStep;
+class LLMAgentStep extends AgentStep {
+    constructor(options = {}) {
+        super(options);
+        this.llmConfig = options.llmconfig || { llmname: "DefaultLLM" };
+    }
+    async analyzeForToolCalls(message, tools, context) {
+        // Generic implementation that can work with any LLM
+        // In a real scenario, you would call your LLM service here
+        const lastMessage = message.messages[message.messages.length - 1];
+        const content = typeof lastMessage.content === 'string'
+            ? lastMessage.content.toLowerCase()
+            : JSON.stringify(lastMessage.content).toLowerCase();
+        const toolCalls = [];
+        // Simple keyword-based tool detection (replace with actual LLM call)
+        if (content.includes('read') && content.includes('file')) {
+            const filePath = this.extractFilePath(content);
+            if (filePath) {
+                toolCalls.push({
+                    tool: 'FileRead',
+                    parameters: { filePath }
+                });
+            }
+        }
+        if (content.includes('write') && content.includes('file')) {
+            const filePath = this.extractFilePath(content);
+            if (filePath) {
+                toolCalls.push({
+                    tool: 'FileWrite',
+                    parameters: { filePath, content: 'Content to be written' }
+                });
+            }
+        }
+        if (content.includes('delete') && content.includes('file')) {
+            const filePath = this.extractFilePath(content);
+            if (filePath) {
+                toolCalls.push({
+                    tool: 'FileDelete',
+                    parameters: { filePath }
+                });
+            }
+        }
+        return toolCalls.length > 0 ? toolCalls : null;
+    }
+    async generateFinalResponse(message, toolResults, context) {
+        // Generic implementation that can work with any LLM
+        // In a real scenario, you would call your LLM service here
+        const lastMessage = message.messages[message.messages.length - 1];
+        let responseContent = `I've processed your request: "${lastMessage.content}". Here's my response based on the available information.`;
+        // Add tool results if available
+        if (toolResults && toolResults.results) {
+            const toolResultsText = toolResults.results
+                .map((r) => `${r.tool}: ${r.success ? 'Success' : 'Failed'}`)
+                .join(', ');
+            responseContent += `\n\nTool execution results: ${toolResultsText}`;
+        }
+        const response = {
+            messages: [
+                ...message.messages,
+                {
+                    role: 'assistant',
+                    content: responseContent
+                }
+            ],
+            metadata: {
+                ...message.metadata,
+                responseGenerated: true,
+                timestamp: new Date().toISOString(),
+                model: this.llmConfig.model || this.llmConfig.llmname || 'generic-llm'
+            }
+        };
+        return {
+            response,
+            finished: true
+        };
+    }
+    extractFilePath(content) {
+        // Simple file path extraction (replace with more sophisticated parsing)
+        const filePathMatch = content.match(/['"`]([^'"`]+\.\w+)['"`]/);
+        return filePathMatch ? filePathMatch[1] : null;
+    }
+}
+exports.LLMAgentStep = LLMAgentStep;

package/dist/processor/agent/toolExecutor.d.ts

@@ -0,0 +1,19 @@
+import { ToolExecutor as IToolExecutor, ToolExecutionInput, ToolExecutionOutput, ToolList } from '../types/interfaces';
+export interface ToolExecutorOptions {
+    maxRetries?: number;
+    retryDelay?: number;
+    enableLogging?: boolean;
+}
+export declare class ToolExecutor implements IToolExecutor {
+    private readonly toolList;
+    private readonly maxRetries;
+    private readonly retryDelay;
+    private readonly enableLogging;
+    constructor(toolList: ToolList, options?: ToolExecutorOptions);
+    executeTools(input: ToolExecutionInput): Promise<ToolExecutionOutput>;
+    private executeToolWithRetry;
+    private delay;
+    addTool(tool: any): void;
+    removeTool(toolName: string): boolean;
+    getToolNames(): string[];
+}

package/dist/processor/agent/toolExecutor.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolExecutor = void 0;
+class ToolExecutor {
+    constructor(toolList, options = {}) {
+        this.toolList = toolList;
+        this.maxRetries = options.maxRetries || 3;
+        this.retryDelay = options.retryDelay || 1000;
+        this.enableLogging = options.enableLogging !== false;
+    }
+    async executeTools(input) {
+        try {
+            const { toolCalls, tools, context } = input;
+            const results = [];
+            for (const toolCall of toolCalls) {
+                try {
+                    const tool = tools.getTool(toolCall.tool);
+                    if (!tool) {
+                        results.push({
+                            tool: toolCall.tool,
+                            result: null,
+                            error: `Tool '${toolCall.tool}' not found`
+                        });
+                        continue;
+                    }
+                    // Execute tool with retry logic
+                    const result = await this.executeToolWithRetry(tool, toolCall.parameters);
+                    results.push({
+                        tool: toolCall.tool,
+                        result,
+                        error: undefined
+                    });
+                }
+                catch (error) {
+                    results.push({
+                        tool: toolCall.tool,
+                        result: null,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+            const success = results.every(r => !r.error);
+            return {
+                results,
+                success
+            };
+        }
+        catch (error) {
+            console.error('Error in ToolExecutor.executeTools:', error);
+            throw error;
+        }
+    }
+    async executeToolWithRetry(tool, parameters) {
+        let lastError = null;
+        for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+            try {
+                if (this.enableLogging) {
+                    console.log(`[ToolExecutor] Executing ${tool.name} (attempt ${attempt}/${this.maxRetries})`);
+                }
+                const result = await tool.execute(parameters);
+                return result;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                if (this.enableLogging) {
+                    console.warn(`[ToolExecutor] Attempt ${attempt} failed for ${tool.name}:`, lastError.message);
+                }
+                if (attempt < this.maxRetries) {
+                    await this.delay(this.retryDelay);
+                }
+            }
+        }
+        throw lastError || new Error(`Tool execution failed after ${this.maxRetries} attempts`);
+    }
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    // Helper methods for tool management
+    addTool(tool) {
+        this.toolList.addTool(tool);
+    }
+    removeTool(toolName) {
+        this.toolList.removeTool(toolName);
+        return true;
+    }
+    getToolNames() {
+        return this.toolList.getAllTools().map(tool => tool.name);
+    }
+}
+exports.ToolExecutor = ToolExecutor;

package/dist/processor/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types/interfaces';
+export { BaseProcessor } from './processors/baseProcessor';
+export { BaseMessageModifier, RequestMessage } from './messageModifiers/baseMessageModifier';
+export { BaseTool } from './tools/baseTool';
+export { AgentStep, AgentStepOptions, LLMAgentStep, LLMAgentStepOptions, LLMConfig } from './agent/agentStep';
+export { ToolExecutor, ToolExecutorOptions } from './agent/toolExecutor';
+export { ToolList as ToolListClass } from './tools/toolList';

package/dist/processor/index.js

@@ -0,0 +1,36 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolListClass = exports.ToolExecutor = exports.LLMAgentStep = exports.AgentStep = exports.BaseTool = exports.RequestMessage = exports.BaseMessageModifier = exports.BaseProcessor = void 0;
+// Core interfaces
+__exportStar(require("./types/interfaces"), exports);
+// Base classes
+var baseProcessor_1 = require("./processors/baseProcessor");
+Object.defineProperty(exports, "BaseProcessor", { enumerable: true, get: function () { return baseProcessor_1.BaseProcessor; } });
+var baseMessageModifier_1 = require("./messageModifiers/baseMessageModifier");
+Object.defineProperty(exports, "BaseMessageModifier", { enumerable: true, get: function () { return baseMessageModifier_1.BaseMessageModifier; } });
+Object.defineProperty(exports, "RequestMessage", { enumerable: true, get: function () { return baseMessageModifier_1.RequestMessage; } });
+var baseTool_1 = require("./tools/baseTool");
+Object.defineProperty(exports, "BaseTool", { enumerable: true, get: function () { return baseTool_1.BaseTool; } });
+// Agent components
+var agentStep_1 = require("./agent/agentStep");
+Object.defineProperty(exports, "AgentStep", { enumerable: true, get: function () { return agentStep_1.AgentStep; } });
+Object.defineProperty(exports, "LLMAgentStep", { enumerable: true, get: function () { return agentStep_1.LLMAgentStep; } });
+var toolExecutor_1 = require("./agent/toolExecutor");
+Object.defineProperty(exports, "ToolExecutor", { enumerable: true, get: function () { return toolExecutor_1.ToolExecutor; } });
+// Tool management
+var toolList_1 = require("./tools/toolList");
+Object.defineProperty(exports, "ToolListClass", { enumerable: true, get: function () { return toolList_1.ToolList; } });

package/dist/processor/messageModifiers/baseMessageModifier.d.ts

@@ -0,0 +1,20 @@
+import { MessageModifier, MessageModifierInput, ProcessedMessage } from '../types/interfaces';
+export interface MessageModifierOptions {
+    context?: Record<string, any>;
+}
+export declare abstract class BaseMessageModifier implements MessageModifier {
+    protected context: Record<string, any>;
+    constructor(options?: MessageModifierOptions);
+    abstract modify(input: MessageModifierInput): Promise<ProcessedMessage>;
+    setContext(key: string, value: any): void;
+    getContext(key: string): any;
+    clearContext(): void;
+}
+export declare class RequestMessage {
+    private messageModifiers;
+    constructor(options?: {
+        messageModifiers?: MessageModifier[];
+    });
+    addModifier(modifier: MessageModifier): void;
+    modify(message: any): Promise<ProcessedMessage>;
+}