@codebolt/agent 2.2.2 → 2.2.5

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

@@ -1,9 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AddToolsListMessageModifier = void 0;
-const processor_1 = require("../../processor");
-class AddToolsListMessageModifier extends processor_1.BaseMessageModifier {
-    constructor(options) {
+const base_1 = require("../base");
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+class AddToolsListMessageModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
         super({ context: options });
         this.toolsList = options.toolsList;
         this.addToolsLocation = options.addToolsLocation || 'SystemMessage';
@@ -11,10 +15,10 @@ class AddToolsListMessageModifier extends processor_1.BaseMessageModifier {
         this.maxToolExamples = options.maxToolExamples || 2;
         this.includeToolDescriptions = options.includeToolDescriptions !== false; // default true
     }
-    async modify(input) {
+    async modify(originalRequest, createdMessage) {
         try {
-            const { originalRequest, createdMessage, context } = input;
-            const tools = this.toolsList.getAllTools();
+            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;
             }
@@ -26,7 +30,7 @@ class AddToolsListMessageModifier extends processor_1.BaseMessageModifier {
                 case 'Tool':
                     return this.addToolsAsToolCalls(createdMessage, tools);
                 default:
-                    return createdMessage;
+                    return this.addToolsAsToolCalls(createdMessage, tools);
             }
         }
         catch (error) {
@@ -37,8 +41,8 @@ class AddToolsListMessageModifier extends processor_1.BaseMessageModifier {
     addToolsInsidePrompt(createdMessage, tools) {
         const toolsInfo = this.generateToolsInfo(tools);
         // Modify the last user message to include tools information
-        const modifiedMessages = createdMessage.messages.map((message, index) => {
-            if (message.role === 'user' && index === createdMessage.messages.length - 1) {
+        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}`
@@ -47,7 +51,10 @@ class AddToolsListMessageModifier extends processor_1.BaseMessageModifier {
             return message;
         });
         return {
-            messages: modifiedMessages,
+            message: {
+                ...createdMessage.message,
+                messages: modifiedMessages
+            },
             metadata: {
                 ...createdMessage.metadata,
                 toolsListAdded: true,
@@ -60,11 +67,13 @@ class AddToolsListMessageModifier extends processor_1.BaseMessageModifier {
         const toolsInfo = this.generateToolsInfo(tools);
         const toolsMessage = {
             role: 'system',
-            content: `Available Tools:\n${toolsInfo}`,
-            name: 'tools-list'
+            content: `Available Tools:\n${toolsInfo}`
         };
         return {
-            messages: [toolsMessage, ...createdMessage.messages],
+            message: {
+                ...createdMessage.message,
+                messages: [toolsMessage, ...createdMessage.message.messages]
+            },
             metadata: {
                 ...createdMessage.metadata,
                 toolsListAdded: true,
@@ -74,20 +83,12 @@ class AddToolsListMessageModifier extends processor_1.BaseMessageModifier {
         };
     }
     addToolsAsToolCalls(createdMessage, tools) {
-        // This would create a message that lists tools as available tool calls
-        const toolsMessage = {
-            role: 'assistant',
-            content: 'I have access to the following tools:',
-            tool_calls: tools.map((tool, index) => ({
-                id: `tool-info-${index}`,
-                function: {
-                    name: tool.name,
-                    arguments: tool.parameters || {}
-                }
-            }))
-        };
         return {
-            messages: [...createdMessage.messages, toolsMessage],
+            message: {
+                ...createdMessage.message,
+                tools,
+                tool_choice: 'auto'
+            },
             metadata: {
                 ...createdMessage.metadata,
                 toolsListAdded: true,
@@ -99,14 +100,14 @@ class AddToolsListMessageModifier extends processor_1.BaseMessageModifier {
     generateToolsInfo(tools) {
         const toolsInfo = [];
         tools.forEach((tool, index) => {
-            let toolInfo = `${index + 1}. **${tool.name}**`;
-            if (this.includeToolDescriptions && tool.description) {
-                toolInfo += `\n   Description: ${tool.description}`;
+            let toolInfo = `${index + 1}. **${tool.function.name}**`;
+            if (this.includeToolDescriptions && tool.function.description) {
+                toolInfo += `\n   Description: ${tool.function.description}`;
             }
-            if (tool.parameters) {
-                const params = typeof tool.parameters === 'object'
-                    ? Object.keys(tool.parameters).join(', ')
-                    : String(tool.parameters);
+            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.giveToolExamples && index < this.maxToolExamples) {
@@ -121,24 +122,24 @@ class AddToolsListMessageModifier extends processor_1.BaseMessageModifier {
     }
     generateToolExample(tool) {
         // Generate simple examples based on tool name
-        const toolName = tool.name.toLowerCase();
+        const toolName = tool.function.name.toLowerCase();
         if (toolName.includes('read') && toolName.includes('file')) {
-            return `${tool.name}({ filePath: "example.txt" })`;
+            return `${tool.function.name}({ filePath: "example.txt" })`;
         }
         if (toolName.includes('write') && toolName.includes('file')) {
-            return `${tool.name}({ filePath: "output.txt", content: "Hello World" })`;
+            return `${tool.function.name}({ filePath: "output.txt", content: "Hello World" })`;
         }
         if (toolName.includes('delete') && toolName.includes('file')) {
-            return `${tool.name}({ filePath: "temp.txt" })`;
+            return `${tool.function.name}({ filePath: "temp.txt" })`;
         }
         if (toolName.includes('move') && toolName.includes('file')) {
-            return `${tool.name}({ sourcePath: "old.txt", destinationPath: "new.txt" })`;
+            return `${tool.function.name}({ sourcePath: "old.txt", destinationPath: "new.txt" })`;
         }
         if (toolName.includes('copy') && toolName.includes('file')) {
-            return `${tool.name}({ sourcePath: "source.txt", destinationPath: "copy.txt" })`;
+            return `${tool.function.name}({ sourcePath: "source.txt", destinationPath: "copy.txt" })`;
         }
         // Generic example
-        return `${tool.name}({ /* parameters */ })`;
+        return `${tool.function.name}({ /* parameters */ })`;
     }
 }
 exports.AddToolsListMessageModifier = AddToolsListMessageModifier;

package/dist/processor-pieces/messageModifiers/advancedSystemInstructionMessageModifier.d.ts

@@ -0,0 +1,9 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export declare class AdvancedSystemInstructionMessageModifier extends BaseMessageModifier {
+    private readonly systemInstruction;
+    constructor(systemInstruction?: string);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private getAdvancedSystemPrompt;
+}

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdvancedSystemInstructionMessageModifier = void 0;
+const base_1 = require("../base");
+class AdvancedSystemInstructionMessageModifier extends base_1.BaseMessageModifier {
+    constructor(systemInstruction) {
+        super();
+        this.systemInstruction = systemInstruction || this.getAdvancedSystemPrompt();
+    }
+    async modify(originalRequest, createdMessage) {
+        try {
+            const systemMessage = {
+                role: 'system',
+                content: this.systemInstruction
+            };
+            const messages = [...(createdMessage.message.messages || [])];
+            const existingSystemIndex = messages.findIndex(msg => msg.role === 'system');
+            if (existingSystemIndex !== -1) {
+                messages[existingSystemIndex] = systemMessage;
+            }
+            else {
+                messages.unshift(systemMessage);
+            }
+            return {
+                message: {
+                    ...createdMessage.message,
+                    messages
+                },
+                metadata: {
+                    ...createdMessage.metadata
+                }
+            };
+        }
+        catch (error) {
+            console.error('Error in AdvancedSystemInstructionMessageModifier:', error);
+            throw error;
+        }
+    }
+    getAdvancedSystemPrompt() {
+        const advancedPrompt = `
+You are an advanced AI software engineering assistant with expertise in multiple programming languages, frameworks, and best practices. Your primary goal is to assist users efficiently and safely while adhering to the following guidelines:
+
+1. Code Quality and Best Practices:
+   - Write clean, efficient, and maintainable code
+   - Follow SOLID principles and design patterns when appropriate
+   - Implement proper error handling and logging
+   - Write unit tests for new functionality
+   - Ensure code is secure and follows cybersecurity best practices
+
+2. Project-Specific Considerations:
+   - Analyze and adhere to existing project structure, naming conventions, and coding style
+   - Use established libraries and frameworks within the project
+   - Consider scalability and performance implications of changes
+   - Maintain backward compatibility unless explicitly instructed otherwise
+
+3. Communication and Collaboration:
+   - Provide clear, concise explanations for your decisions and implementations
+   - Ask clarifying questions when requirements are ambiguous
+   - Suggest improvements or alternatives when appropriate
+   - Break down complex tasks into manageable steps
+
+4. Continuous Learning and Adaptation:
+   - Stay updated on latest industry trends and best practices
+   - Adapt your approach based on user feedback and project requirements
+   - Recommend modern tools and techniques when beneficial to the project
+
+5. Ethical Considerations:
+   - Respect intellectual property rights and licensing
+   - Avoid implementing features that could be used maliciously
+   - Promote inclusive and accessible code practices
+
+Remember to use the provided tools effectively, always prioritize user safety and project integrity, and strive for excellence in every task you undertake.
+`.trim();
+        return advancedPrompt;
+    }
+}
+exports.AdvancedSystemInstructionMessageModifier = AdvancedSystemInstructionMessageModifier;

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

@@ -176,18 +176,18 @@ class AtFileProcessorModifier extends base_1.BaseMessageModifier {
                     contextParts.push(structure);
                     // Also read files within the folder
                     const filesInFolder = await this.getFilesInFolder(resolvedPath);
-                    console.log(`Found ${filesInFolder.length} files in ${folderPath}:`, filesInFolder.map(f => path.basename(f)));
+                    // console.log(`Found ${filesInFolder.length} files in ${folderPath}:`, filesInFolder.map(f => path.basename(f)));
                     if (filesInFolder.length > 0) {
                         contextParts.push(`\n--- Files in ${folderPath} ---`);
                         for (const filePath of filesInFolder) {
                             try {
-                                console.log(`Attempting to read file: ${filePath}`);
+                                // console.log(`Attempting to read file: ${filePath}`);
                                 const content = await this.readFileContent(filePath);
                                 const relativePath = path.relative(resolvedPath, filePath);
                                 const displayPath = `${folderPath}/${relativePath}`;
                                 contextParts.push(`\nContent from @${displayPath}:\n`);
                                 contextParts.push(content);
-                                console.log(`Successfully read file: ${displayPath} (${content.length} chars)`);
+                                // console.log(`Successfully read file: ${displayPath} (${content.length} chars)`);
                             }
                             catch (error) {
                                 const errorMessage = error instanceof Error ? error.message : 'Unknown error';
@@ -372,12 +372,12 @@ class AtFileProcessorModifier extends base_1.BaseMessageModifier {
                     // Check file extension if allowed extensions are specified
                     if (this.options.allowedExtensions.length > 0) {
                         const ext = path.extname(entry.name).toLowerCase();
-                        console.log(`Checking file ${entry.name} with extension ${ext}. Allowed:`, this.options.allowedExtensions);
+                        // console.log(`Checking file ${entry.name} with extension ${ext}. Allowed:`, this.options.allowedExtensions);
                         if (this.options.allowedExtensions.includes(ext)) {
                             files.push(path.join(folderPath, entry.name));
                         }
                         else {
-                            console.log(`File ${entry.name} extension ${ext} not in allowed list`);
+                            // console.log(`File ${entry.name} extension ${ext} not in allowed list`);
                         }
                     }
                     else {

package/dist/processor-pieces/messageModifiers/baseContextMessageModifier.d.ts

@@ -1,15 +1,7 @@
-import { BaseMessageModifier, MessageModifierInput, ProcessedMessage } from '../../processor';
-export interface BaseContextMessageModifierOptions {
-    prependmessage?: string;
-    datetime?: boolean;
-    osInfo?: boolean;
-    workingdir?: boolean;
-}
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
 export declare class BaseContextMessageModifier extends BaseMessageModifier {
-    private readonly prependMessage;
-    private readonly includeDateTime;
-    private readonly includeOsInfo;
-    private readonly includeWorkingDir;
-    constructor(options?: BaseContextMessageModifierOptions);
-    modify(input: MessageModifierInput): Promise<ProcessedMessage>;
+    constructor();
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
 }

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

@@ -4,72 +4,64 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseContextMessageModifier = void 0;
-const processor_1 = require("../../processor");
+const base_1 = require("../base");
 const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
 const os_1 = __importDefault(require("os"));
-class BaseContextMessageModifier extends processor_1.BaseMessageModifier {
-    constructor(options = {}) {
-        super({ context: options });
-        this.prependMessage = options.prependmessage || '';
-        this.includeDateTime = options.datetime || false;
-        this.includeOsInfo = options.osInfo || false;
-        this.includeWorkingDir = options.workingdir || false;
+class BaseContextMessageModifier extends base_1.BaseMessageModifier {
+    constructor() {
+        super();
     }
-    async modify(input) {
+    async modify(originalRequest, createdMessage) {
+        const contextParts = [];
+        const now = new Date();
+        contextParts.push(`Current Date/Time: ${now.toISOString()}`);
+        const osInfo = {
+            platform: os_1.default.platform(),
+            arch: os_1.default.arch(),
+            version: os_1.default.version(),
+            hostname: os_1.default.hostname()
+        };
+        contextParts.push(`Operating System: ${JSON.stringify(osInfo, null, 2)}`);
         try {
-            const { originalRequest, createdMessage, context } = input;
-            const contextParts = [];
-            // Add prepend message if provided
-            if (this.prependMessage) {
-                contextParts.push(this.prependMessage);
-            }
-            // Add date/time if requested
-            if (this.includeDateTime) {
-                const now = new Date();
-                contextParts.push(`Current Date/Time: ${now.toISOString()}`);
-            }
-            // Add OS info if requested
-            if (this.includeOsInfo) {
-                const osInfo = {
-                    platform: os_1.default.platform(),
-                    arch: os_1.default.arch(),
-                    version: os_1.default.version(),
-                    hostname: os_1.default.hostname()
+            const { projectPath } = await codeboltjs_1.default.project.getProjectPath();
+            contextParts.push(`Working Directory: ${projectPath}`);
+        }
+        catch (error) {
+            contextParts.push(`Working Directory: ${process.cwd()}`);
+        }
+        if (contextParts.length > 0) {
+            const contextMessage = {
+                role: 'system',
+                content: contextParts.join('\n\n'),
+            };
+            // Create a copy of messages array
+            const messages = [...createdMessage.message.messages];
+            // Check if system message already exists in the messages array
+            const existingSystemMessageIndex = messages.findIndex(msg => msg.role == 'system');
+            if (existingSystemMessageIndex !== -1) {
+                // Append context to existing system message content
+                const existingContent = messages[existingSystemMessageIndex].content || '';
+                messages[existingSystemMessageIndex] = {
+                    ...messages[existingSystemMessageIndex],
+                    content: existingContent + '\n\n' + contextMessage.content
                 };
-                contextParts.push(`Operating System: ${JSON.stringify(osInfo, null, 2)}`);
             }
-            // Add working directory if requested
-            if (this.includeWorkingDir) {
-                try {
-                    const projectPath = await codeboltjs_1.default.project.getProjectPath();
-                    contextParts.push(`Working Directory: ${projectPath}`);
-                }
-                catch (error) {
-                    contextParts.push(`Working Directory: ${process.cwd()}`);
-                }
+            else {
+                // Add system message to the top of the array
+                messages.unshift(contextMessage);
             }
-            // Create context message if we have any context parts
-            if (contextParts.length > 0) {
-                const contextMessage = {
-                    role: 'system',
-                    content: contextParts.join('\n\n'),
-                    name: 'base-context'
-                };
-                return {
-                    messages: [contextMessage, ...createdMessage.messages],
-                    metadata: {
-                        ...createdMessage.metadata,
-                        baseContextAdded: true,
-                        contextParts: contextParts.length
-                    }
-                };
-            }
-            return createdMessage;
-        }
-        catch (error) {
-            console.error('Error in BaseContextMessageModifier:', error);
-            throw error;
+            // Return new ProcessedMessage object
+            return {
+                message: {
+                    ...createdMessage.message,
+                    messages
+                },
+                metadata: {
+                    ...createdMessage.metadata
+                }
+            };
         }
+        return createdMessage;
     }
 }
 exports.BaseContextMessageModifier = BaseContextMessageModifier;

package/dist/processor-pieces/messageModifiers/baseSystemInstructionMessageModifier.d.ts

@@ -1,11 +1,9 @@
-import { BaseMessageModifier, MessageModifierInput, ProcessedMessage } from '../../processor';
-export interface BaseSystemInstructionMessageModifierOptions {
-    systemInstruction?: string;
-    position?: 'start' | 'end';
-}
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
 export declare class BaseSystemInstructionMessageModifier extends BaseMessageModifier {
     private readonly systemInstruction;
-    private readonly position;
-    constructor(options?: BaseSystemInstructionMessageModifierOptions);
-    modify(input: MessageModifierInput): Promise<ProcessedMessage>;
+    constructor(systemInstruction?: string);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private getCoreSystemPrompt;
 }

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

@@ -1,39 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseSystemInstructionMessageModifier = void 0;
-const processor_1 = require("../../processor");
-class BaseSystemInstructionMessageModifier extends processor_1.BaseMessageModifier {
-    constructor(options = {}) {
-        super({ context: options });
-        this.systemInstruction = options.systemInstruction || 'You are a helpful assistant.';
-        this.position = options.position || 'start';
+const base_1 = require("../base");
+class BaseSystemInstructionMessageModifier extends base_1.BaseMessageModifier {
+    constructor(systemInstruction) {
+        super();
+        this.systemInstruction = systemInstruction || this.getCoreSystemPrompt();
     }
-    async modify(input) {
+    async modify(originalRequest, createdMessage) {
         try {
-            const { originalRequest, createdMessage, context } = input;
             // Create system instruction message
             const systemMessage = {
                 role: 'system',
-                content: this.systemInstruction,
-                name: 'system-instruction'
+                content: this.systemInstruction
             };
-            let messages;
-            if (this.position === 'start') {
-                // Add system instruction at the beginning
-                messages = [systemMessage, ...createdMessage.messages];
+            // Get existing messages
+            const messages = [...(createdMessage.message.messages || [])];
+            // Check if system message already exists
+            const existingSystemIndex = messages.findIndex(msg => msg.role === 'system');
+            if (existingSystemIndex !== -1) {
+                // Update existing system message
+                messages[existingSystemIndex] = systemMessage;
             }
             else {
-                // Add system instruction at the end (before user message)
-                const userMessages = createdMessage.messages.filter(m => m.role === 'user');
-                const otherMessages = createdMessage.messages.filter(m => m.role !== 'user');
-                messages = [...otherMessages, systemMessage, ...userMessages];
+                // Add system message to first position
+                messages.unshift(systemMessage);
             }
+            // Return new ProcessedMessage object
             return {
-                messages,
+                message: {
+                    ...createdMessage.message,
+                    messages
+                },
                 metadata: {
-                    ...createdMessage.metadata,
-                    systemInstructionAdded: true,
-                    systemInstructionPosition: this.position
+                    ...createdMessage.metadata
                 }
             };
         }
@@ -42,5 +42,49 @@ class BaseSystemInstructionMessageModifier extends processor_1.BaseMessageModifi
             throw error;
         }
     }
+    getCoreSystemPrompt() {
+        // Default system prompt similar to gemini-cli but simplified for CodeBolt context
+        const basePrompt = `
+You are an interactive AI agent specializing in software engineering tasks. Your primary goal is to help users safely and efficiently, adhering strictly to the following instructions and utilizing your available tools.
+
+# Core Mandates
+
+- **Conventions:** Rigorously adhere to existing project conventions when reading or modifying code. Analyze surrounding code, tests, and configuration first.
+- **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project before employing it.
+- **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project.
+- **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically.
+- **Comments:** Add code comments sparingly. Focus on *why* something is done, especially for complex logic, rather than *what* is done.
+- **Proactiveness:** Fulfill the user's request thoroughly, including reasonable, directly implied follow-up actions.
+- **Confirm Ambiguity/Expansion:** Do not take significant actions beyond the clear scope of the request without confirming with the user.
+- **Explaining Changes:** After completing a code modification or file operation *do not* provide summaries unless asked.
+
+# Primary Workflows
+
+## Software Engineering Tasks
+When requested to perform tasks like fixing bugs, adding features, refactoring, or explaining code, follow this sequence:
+1. **Understand:** Think about the user's request and the relevant codebase context. Use search tools extensively to understand file structures, existing code patterns, and conventions.
+2. **Plan:** Build a coherent and grounded plan for how you intend to resolve the user's task. Share a concise yet clear plan with the user if it would help.
+3. **Implement:** Use the available tools to act on the plan, strictly adhering to the project's established conventions.
+4. **Verify:** If applicable and feasible, verify the changes using the project's testing procedures and build/lint commands.
+
+# Operational Guidelines
+
+## Tone and Style
+- **Concise & Direct:** Adopt a professional, direct, and concise tone.
+- **Minimal Output:** Aim for fewer than 3 lines of text output per response whenever practical.
+- **Clarity over Brevity:** While conciseness is key, prioritize clarity for essential explanations.
+- **No Chitchat:** Avoid conversational filler. Get straight to the action or answer.
+- **Formatting:** Use GitHub-flavored Markdown.
+
+## Security and Safety Rules
+- **Security First:** Always apply security best practices. Never introduce code that exposes, logs, or commits secrets, API keys, or other sensitive information.
+- **File Operations:** Always use absolute paths when referring to files with tools.
+
+# Final Reminder
+Your core function is efficient and safe assistance. Balance extreme conciseness with the crucial need for clarity, especially regarding safety and potential system modifications. Always prioritize user control and project conventions.
+ Do not ask for more information than necessary. Use the tools provided to accomplish the user's request efficiently and effectively. When you've completed your task, you must use the attempt_completion tool to present the result to the user. The user may provide feedback, which you can use to make improvements and try again.
+`.trim();
+        return basePrompt;
+    }
 }
 exports.BaseSystemInstructionMessageModifier = BaseSystemInstructionMessageModifier;

package/dist/processor-pieces/messageModifiers/chatCompressionModifier.d.ts

@@ -0,0 +1,19 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface ChatCompressionOptions {
+    tokenThreshold?: number;
+    compressionRatio?: number;
+    preserveRecentMessages?: number;
+    enableCompression?: boolean;
+}
+export declare class ChatCompressionModifier extends BaseMessageModifier {
+    private readonly options;
+    private hasFailedCompressionAttempt;
+    constructor(options?: ChatCompressionOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private shouldCompressChat;
+    private compressMessages;
+    private createConversationSummary;
+    resetCompressionState(): void;
+}