@codebolt/agent 1.1.0 → 2.2.2

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

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenManagementProcessor = void 0;
+const processor_1 = require("../../processor");
+class TokenManagementProcessor extends processor_1.BaseProcessor {
+    constructor(options = {}) {
+        super();
+        // Token cache for performance
+        this.tokenCache = new Map();
+        this.maxTokens = options.maxTokens || 128000;
+        this.warningThreshold = options.warningThreshold || 0.8;
+        this.enableCompression = options.enableCompression !== false;
+        this.compressionThreshold = options.compressionThreshold || 0.7;
+        this.enableCaching = options.enableCaching !== false;
+        this.modelTokenLimits = options.modelTokenLimits || {
+            'gemini-pro': 128000,
+            'gemini-pro-vision': 128000,
+            'gemini-flash': 1000000,
+            'gpt-4': 128000,
+            'gpt-3.5-turbo': 16385,
+            'claude-3': 200000
+        };
+    }
+    async processInput(input) {
+        var _a, _b;
+        const { message, context } = input;
+        try {
+            // Calculate current token usage
+            const tokenUsage = await this.calculateTokenUsage(message);
+            // Get model-specific limit if available
+            const modelName = ((_a = context === null || context === void 0 ? void 0 : context.llmconfig) === null || _a === void 0 ? void 0 : _a.model) || ((_b = context === null || context === void 0 ? void 0 : context.llmconfig) === null || _b === void 0 ? void 0 : _b.llmname) || 'gemini-pro';
+            const modelLimit = this.modelTokenLimits[modelName] || this.maxTokens;
+            const results = [];
+            // Add token usage information
+            results.push(this.createEvent('TokenUsageCalculated', {
+                usage: tokenUsage,
+                modelLimit,
+                utilizationPercentage: (tokenUsage.total / modelLimit) * 100
+            }));
+            // Check if we're approaching token limits
+            if (tokenUsage.total > modelLimit * this.warningThreshold) {
+                results.push(this.createEvent('TokenLimitWarning', {
+                    usage: tokenUsage,
+                    limit: modelLimit,
+                    warningThreshold: this.warningThreshold,
+                    recommendation: this.enableCompression ? 'compression_suggested' : 'trim_history'
+                }));
+            }
+            // Check if we need compression
+            if (this.enableCompression && tokenUsage.total > modelLimit * this.compressionThreshold) {
+                results.push(this.createEvent('CompressionTriggered', {
+                    usage: tokenUsage,
+                    limit: modelLimit,
+                    compressionThreshold: this.compressionThreshold
+                }));
+            }
+            // Check if we're over the limit
+            if (tokenUsage.total > modelLimit) {
+                results.push(this.createEvent('TokenLimitExceeded', {
+                    usage: tokenUsage,
+                    limit: modelLimit,
+                    excessTokens: tokenUsage.total - modelLimit,
+                    action: 'truncation_required'
+                }));
+            }
+            return results;
+        }
+        catch (error) {
+            console.error('[TokenManagement] Error calculating tokens:', error);
+            return [this.createEvent('TokenCalculationError', {
+                    error: error instanceof Error ? error.message : String(error),
+                    fallbackEstimate: this.estimateTokens(message)
+                })];
+        }
+    }
+    async calculateTokenUsage(message) {
+        try {
+            // Try to use CodeBolt's LLM service for accurate token counting
+            const messagesText = this.extractTextFromMessage(message);
+            // Check cache first
+            if (this.enableCaching) {
+                const cacheKey = this.getCacheKey(messagesText);
+                const cachedCount = this.tokenCache.get(cacheKey);
+                if (cachedCount !== undefined) {
+                    return {
+                        input: cachedCount,
+                        output: 0,
+                        cached: cachedCount,
+                        total: cachedCount
+                    };
+                }
+            }
+            // For now, use estimation since we don't have direct access to token counting
+            // In a real implementation, you would use codebolt.llm.countTokens() or similar
+            const estimatedTokens = this.estimateTokens(message);
+            // Cache the result
+            if (this.enableCaching) {
+                const cacheKey = this.getCacheKey(messagesText);
+                this.tokenCache.set(cacheKey, estimatedTokens);
+                // Limit cache size
+                if (this.tokenCache.size > 1000) {
+                    const firstKey = this.tokenCache.keys().next().value;
+                    if (firstKey !== undefined) {
+                        this.tokenCache.delete(firstKey);
+                    }
+                }
+            }
+            return {
+                input: estimatedTokens,
+                output: 0,
+                cached: 0,
+                total: estimatedTokens,
+                estimated: true
+            };
+        }
+        catch (error) {
+            console.error('[TokenManagement] Token calculation failed:', error);
+            const fallbackEstimate = this.estimateTokens(message);
+            return {
+                input: fallbackEstimate,
+                output: 0,
+                cached: 0,
+                total: fallbackEstimate,
+                estimated: true
+            };
+        }
+    }
+    extractTextFromMessage(message) {
+        if (typeof message === 'string') {
+            return message;
+        }
+        if ((message === null || message === void 0 ? void 0 : message.messages) && Array.isArray(message.messages)) {
+            return message.messages
+                .map((msg) => {
+                if (typeof msg.content === 'string') {
+                    return msg.content;
+                }
+                if (Array.isArray(msg.content)) {
+                    return msg.content
+                        .filter((part) => part.type === 'text' || typeof part === 'string')
+                        .map((part) => typeof part === 'string' ? part : part.text)
+                        .join(' ');
+                }
+                return JSON.stringify(msg.content);
+            })
+                .join('\n');
+        }
+        return JSON.stringify(message);
+    }
+    estimateTokens(message) {
+        const text = this.extractTextFromMessage(message);
+        // Rough estimation: ~4 characters per token for English text
+        // This is a simplified estimation - real tokenizers are more complex
+        const charCount = text.length;
+        const wordCount = text.split(/\s+/).length;
+        // Use a combination of character and word count for better estimation
+        const charBasedEstimate = Math.ceil(charCount / 4);
+        const wordBasedEstimate = Math.ceil(wordCount * 1.3); // Account for subword tokens
+        // Use the higher estimate to be conservative
+        return Math.max(charBasedEstimate, wordBasedEstimate);
+    }
+    getCacheKey(text) {
+        // Create a hash-like key for caching
+        return text.length.toString() + '_' + text.slice(0, 100).replace(/\s+/g, '');
+    }
+    getTokenUsageStats() {
+        // In a real implementation, you would track these statistics
+        return {
+            cacheSize: this.tokenCache.size,
+            cacheHitRate: 0, // Would track cache hits vs misses
+            averageTokensPerMessage: 0 // Would track running average
+        };
+    }
+    clearCache() {
+        this.tokenCache.clear();
+    }
+}
+exports.TokenManagementProcessor = TokenManagementProcessor;

package/dist/processor-pieces/processors/toolExecutionProcessor.d.ts

@@ -0,0 +1,43 @@
+import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
+export interface ToolExecutionInfo {
+    toolCall: any;
+    toolName: string;
+    toolbox: string;
+    parameters: Record<string, any>;
+    needsConfirmation: boolean;
+    confirmed?: boolean;
+}
+export interface ToolExecutionResult {
+    toolCallId: string;
+    result: any;
+    error?: string;
+    success: boolean;
+    executionTime: number;
+}
+export interface ToolExecutionProcessorOptions {
+    enableToolConfirmation?: boolean;
+    maxRetries?: number;
+    retryDelay?: number;
+    enableLogging?: boolean;
+}
+export declare class ToolExecutionProcessor extends BaseProcessor {
+    private readonly enableToolConfirmation;
+    private readonly maxRetries;
+    private readonly retryDelay;
+    private readonly enableLogging;
+    private executedTools;
+    constructor(options?: ToolExecutionProcessorOptions);
+    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
+    private extractToolCalls;
+    private processToolCall;
+    private shouldConfirmTool;
+    private executeTool;
+    private calculateSuccessRate;
+    confirmToolExecution(toolCallId: string, confirmed: boolean): Promise<void>;
+    getToolExecutionHistory(): ToolExecutionResult[];
+    clearToolHistory(): void;
+    setMaxRetries(maxRetries: number): void;
+    setRetryDelay(delay: number): void;
+    enableLoggingForSession(): void;
+    disableLoggingForSession(): void;
+}

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

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

@@ -0,0 +1,26 @@
+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

@@ -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-pieces/utils/messageModifierHelper.d.ts

@@ -0,0 +1,4 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+export declare const mergeMessages: (existing: ProcessedMessage, additional: ProcessedMessage) => ProcessedMessage;
+export declare const addSystemMessage: (message: ProcessedMessage, systemContent: string) => ProcessedMessage;
+export declare const addUserContext: (message: ProcessedMessage, contextKey: string, contextValue: unknown) => ProcessedMessage;

package/dist/processor-pieces/utils/messageModifierHelper.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addUserContext = exports.addSystemMessage = exports.mergeMessages = void 0;
+// Helper method to merge messages
+const mergeMessages = (existing, additional) => {
+    return {
+        message: {
+            ...existing.message,
+            ...additional.message,
+            messages: [...existing.message.messages, ...additional.message.messages],
+            tools: additional.message.tools
+        },
+        metadata: {
+            ...existing.metadata,
+            ...additional.metadata,
+            merged: true,
+            mergedAt: new Date().toISOString()
+        }
+    };
+};
+exports.mergeMessages = mergeMessages;
+// Helper method to add system message
+const addSystemMessage = (message, systemContent) => {
+    const systemMessage = {
+        role: 'system',
+        content: systemContent
+    };
+    return {
+        message: {
+            ...message.message,
+            messages: [systemMessage, ...message.message.messages]
+        },
+        metadata: {
+            ...message.metadata,
+            systemMessageAdded: true
+        }
+    };
+};
+exports.addSystemMessage = addSystemMessage;
+// Helper method to add user context
+const addUserContext = (message, contextKey, contextValue) => {
+    const contextString = typeof contextValue === 'string' ? contextValue : JSON.stringify(contextValue);
+    const contextMessage = {
+        role: 'user',
+        content: `Context (${contextKey}): ${contextString}`
+    };
+    return {
+        message: {
+            ...message.message,
+            messages: [...message.message.messages, contextMessage]
+        },
+        metadata: {
+            ...message.metadata,
+            contextAdded: contextKey
+        }
+    };
+};
+exports.addUserContext = addUserContext;