@codebolt/agent 6.0.0 → 6.1.2

package/dist/unified/agent/codeboltAgent.js

@@ -1,70 +1,25 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CodeboltAgent = void 0;
 exports.createCodeboltAgent = createCodeboltAgent;
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
 const base_1 = require("../base");
-const responseExecutor_1 = require("../base/responseExecutor");
 const agentStep_1 = require("../base/agentStep");
+const responseExecutor_1 = require("../base/responseExecutor");
+const promptContext_1 = require("../base/promptContext");
+const compactionOrchestrator_1 = require("../services/compaction/compactionOrchestrator");
 const processor_pieces_1 = require("../../processor-pieces");
-/**
- * CodeboltAgent is a high-level agent class that:
- * - Uses InitialPromptGenerator with configurable processors/modifiers
- * - Runs an agent loop with AgentStep and ResponseExecutor
- * - Handles tool execution and conversation flow automatically
- * - Is triggered via processMessage (not via onMessage listener)
- *
- * @example
- * ```typescript
- * import { CodeboltAgent } from '@codebolt/agent/unified';
- * import {
- *     EnvironmentContextModifier,
- *     CoreSystemPromptModifier,
- *     DirectoryContextModifier,
- *     IdeContextModifier,
- *     AtFileProcessorModifier,
- *     ToolInjectionModifier,
- *     ChatHistoryMessageModifier
- * } from '@codebolt/agent/processor-pieces';
- *
- * const systemPrompt = `You are an AI coding assistant...`;
- *
- * const agent = new CodeboltAgent({
- *     instructions: systemPrompt,
- *     processors: {
- *         messageModifiers: [
- *             new ChatHistoryMessageModifier({ enableChatHistory: true }),
- *             new EnvironmentContextModifier({ enableFullContext: true }),
- *             new DirectoryContextModifier(),
- *             new IdeContextModifier({
- *                 includeActiveFile: true,
- *                 includeOpenFiles: true,
- *                 includeCursorPosition: true,
- *                 includeSelectedText: true
- *             }),
- *             new CoreSystemPromptModifier({ customSystemPrompt: systemPrompt }),
- *             new ToolInjectionModifier({ includeToolDescriptions: true }),
- *             new AtFileProcessorModifier({ enableRecursiveSearch: true })
- *         ],
- *         preInferenceProcessors: [],
- *         postInferenceProcessors: [],
- *         preToolCallProcessors: [],
- *         postToolCallProcessors: []
- *     }
- * });
- *
- * // Process a message (triggered from graph node)
- * const result = await agent.processMessage(userMessage);
- * ```
- */
 class CodeboltAgent {
     constructor(config) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e, _f, _g;
         this.config = { ...config };
         this.enableLogging = config.enableLogging !== false;
         this.baseSystemPrompt = config.instructions || 'Based on User Message send reply';
         this.context = config.context;
         this.allowedTools = config.allowedTools;
-        // Use provided modifiers or default ones
         this.messageModifiers = ((_b = (_a = config.processors) === null || _a === void 0 ? void 0 : _a.messageModifiers) === null || _b === void 0 ? void 0 : _b.length)
             ? config.processors.messageModifiers
             : this.createDefaultMessageModifiers(this.baseSystemPrompt, this.allowedTools);
@@ -72,39 +27,29 @@ class CodeboltAgent {
         this.postInferenceProcessors = ((_d = config.processors) === null || _d === void 0 ? void 0 : _d.postInferenceProcessors) || [];
         this.preToolCallProcessors = ((_e = config.processors) === null || _e === void 0 ? void 0 : _e.preToolCallProcessors) || [];
         this.postToolCallProcessors = ((_f = config.processors) === null || _f === void 0 ? void 0 : _f.postToolCallProcessors) || [];
+        this.compactionOrchestrator = new compactionOrchestrator_1.CompactionOrchestrator(config.compaction);
+        this.loopDetectionService = config.loopDetectionService;
+        this.maxTurns = (_g = config.maxTurns) !== null && _g !== void 0 ? _g : 25;
     }
-    /**
-     * Creates default message modifiers when none are provided
-     */
     createDefaultMessageModifiers(systemPrompt, allowedTools) {
         return [
-            // 1. Chat History
             new processor_pieces_1.ChatHistoryMessageModifier({ enableChatHistory: true }),
-            // 2. Environment Context (date, OS)
             new processor_pieces_1.EnvironmentContextModifier({ enableFullContext: true }),
-            // 3. Directory Context (folder structure)
             new processor_pieces_1.DirectoryContextModifier(),
-            // 4. IDE Context (active file, opened files)
             new processor_pieces_1.IdeContextModifier({
                 includeActiveFile: true,
                 includeOpenFiles: true,
                 includeCursorPosition: true,
                 includeSelectedText: true
             }),
-            // 5. Core System Prompt (instructions)
             new processor_pieces_1.CoreSystemPromptModifier({ customSystemPrompt: systemPrompt }),
-            // 6. Tools (function declarations)
             new processor_pieces_1.ToolInjectionModifier({
                 includeToolDescriptions: true,
                 ...(allowedTools && { allowedTools })
             }),
-            // 7. At-file processing (@file mentions)
             new processor_pieces_1.AtFileProcessorModifier({ enableRecursiveSearch: true })
         ];
     }
-    /**
-     * Creates a default FlatUserMessage from a string
-     */
     createDefaultUserMessage(message) {
         return {
             userMessage: message,
@@ -122,27 +67,14 @@ class CodeboltAgent {
             threadId: `thread-${Date.now()}`
         };
     }
-    /**
-     * Process a message through the agent pipeline.
-     * This is the main entry point - triggered from graph nodes.
-     * @param message - Either a string message or a FlatUserMessage object
-     * @param context - Optional context from a previous agent to continue from
-     */
     async processMessage(message, context) {
         try {
-            if (this.enableLogging) {
-                console.log('[CodeboltAgent] Processing message');
-            }
             const reqMessage = typeof message === 'string'
                 ? this.createDefaultUserMessage(message)
                 : message;
-            // Use provided context, config context, or generate new one
-            const contextToUse = context || this.context;
             let prompt;
+            const contextToUse = context || this.context;
             if (contextToUse) {
-                if (this.enableLogging) {
-                    console.log('[CodeboltAgent] Continuing from previous context');
-                }
                 prompt = contextToUse;
             }
             else {
@@ -154,16 +86,52 @@ class CodeboltAgent {
                 prompt = await promptGenerator.processMessage(reqMessage);
             }
             let completed = false;
+            let turnNumber = 0;
+            let finalMessage;
             while (!completed) {
+                turnNumber += 1;
+                if (turnNumber > this.maxTurns) {
+                    throw new Error(`Agent exceeded the maximum turn limit of ${this.maxTurns}.`);
+                }
+                this.compactionOrchestrator.resetForTurn();
+                prompt = await this.applyCompaction(prompt);
+                prompt = await this.refreshAvailableTools(reqMessage, prompt);
                 const agentStep = new agentStep_1.AgentStep({
                     preInferenceProcessors: this.preInferenceProcessors,
                     postInferenceProcessors: this.postInferenceProcessors
                 });
-                const stepResult = await agentStep.executeStep(reqMessage, prompt);
-                prompt = stepResult.nextMessage;
+                let stepResult;
+                while (!stepResult) {
+                    try {
+                        const nextStepResult = await agentStep.executeStep(reqMessage, prompt);
+                        const recoverableResponseError = this.getRecoverableResponseError(nextStepResult.rawLLMResponse);
+                        if (!recoverableResponseError) {
+                            stepResult = nextStepResult;
+                            break;
+                        }
+                        const recoveredPrompt = await this.tryRecoverPrompt(prompt, new Error(recoverableResponseError));
+                        if (!recoveredPrompt) {
+                            throw new Error(recoverableResponseError);
+                        }
+                        prompt = recoveredPrompt;
+                    }
+                    catch (error) {
+                        const recoveredPrompt = await this.tryRecoverPrompt(prompt, error);
+                        if (!recoveredPrompt) {
+                            throw error;
+                        }
+                        prompt = recoveredPrompt;
+                    }
+                }
+                if (!stepResult) {
+                    throw new Error('Agent step did not produce a response.');
+                }
                 const responseExecutor = new responseExecutor_1.ResponseExecutor({
                     preToolCallProcessors: this.preToolCallProcessors,
-                    postToolCallProcessors: this.postToolCallProcessors
+                    postToolCallProcessors: this.postToolCallProcessors,
+                    ...(this.loopDetectionService
+                        ? { loopDetectionService: this.loopDetectionService }
+                        : {}),
                 });
                 const executionResult = await responseExecutor.executeResponse({
                     initialUserMessage: reqMessage,
@@ -173,14 +141,13 @@ class CodeboltAgent {
                 });
                 completed = executionResult.completed;
                 prompt = executionResult.nextMessage;
-            }
-            if (this.enableLogging) {
-                console.log('[CodeboltAgent] Message processing completed');
+                finalMessage = executionResult.finalMessage;
             }
             return {
                 success: true,
                 result: prompt,
-                context: prompt
+                context: prompt,
+                ...(finalMessage !== undefined ? { finalMessage } : {}),
             };
         }
         catch (error) {
@@ -196,47 +163,177 @@ class CodeboltAgent {
             };
         }
     }
-    /**
-     * Get the current configuration
-     */
     getConfig() {
         return { ...this.config };
     }
-    /**
-     * Get all message modifiers
-     */
     getMessageModifiers() {
         return [...this.messageModifiers];
     }
-    /**
-     * Get all pre-inference processors
-     */
     getPreInferenceProcessors() {
         return [...this.preInferenceProcessors];
     }
-    /**
-     * Get all post-inference processors
-     */
     getPostInferenceProcessors() {
         return [...this.postInferenceProcessors];
     }
-    /**
-     * Get all pre-tool-call processors
-     */
     getPreToolCallProcessors() {
         return [...this.preToolCallProcessors];
     }
-    /**
-     * Get all post-tool-call processors
-     */
     getPostToolCallProcessors() {
         return [...this.postToolCallProcessors];
     }
+    async applyCompaction(prompt) {
+        const result = await this.compactionOrchestrator.compact((0, promptContext_1.getTranscriptMessages)(prompt));
+        if (!result.wasCompacted) {
+            return prompt;
+        }
+        return {
+            ...(0, promptContext_1.replaceTranscriptMessages)(prompt, result.messages),
+            metadata: {
+                ...prompt.metadata,
+                compaction: {
+                    totalTokensFreed: result.totalTokensFreed,
+                    layersApplied: result.layersApplied,
+                    boundaries: result.boundaries,
+                    timestamp: new Date().toISOString(),
+                },
+            },
+        };
+    }
+    async tryRecoverPrompt(prompt, error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (!this.compactionOrchestrator.getReactiveLayer().isRecoverableError(errorMessage)) {
+            return null;
+        }
+        const recovery = await this.compactionOrchestrator.recoverFromError((0, promptContext_1.getTranscriptMessages)(prompt), error);
+        if (!recovery.wasCompacted) {
+            return null;
+        }
+        return {
+            ...(0, promptContext_1.replaceTranscriptMessages)(prompt, recovery.messages),
+            metadata: {
+                ...prompt.metadata,
+                reactiveCompaction: {
+                    totalTokensFreed: recovery.totalTokensFreed,
+                    layersApplied: recovery.layersApplied,
+                    boundaries: recovery.boundaries,
+                    timestamp: new Date().toISOString(),
+                    error: errorMessage,
+                },
+            },
+        };
+    }
+    async refreshAvailableTools(originalRequest, prompt) {
+        var _a, _b, _c, _d;
+        if (((_a = prompt.metadata) === null || _a === void 0 ? void 0 : _a['toolsInjected']) !== true ||
+            ((_b = prompt.metadata) === null || _b === void 0 ? void 0 : _b['toolsLocation']) !== 'Tool') {
+            return prompt;
+        }
+        const existingTools = Array.isArray(prompt.message.tools)
+            ? prompt.message.tools
+            : [];
+        try {
+            const toolsResponse = await codeboltjs_1.default.mcp.listMcpFromServers(['codebolt']);
+            let refreshedTools = ((_c = toolsResponse === null || toolsResponse === void 0 ? void 0 : toolsResponse.data) === null || _c === void 0 ? void 0 : _c.tools) || (toolsResponse === null || toolsResponse === void 0 ? void 0 : toolsResponse.data) || [];
+            const mentionedMCPs = Array.isArray(originalRequest.mentionedMCPs)
+                ? originalRequest.mentionedMCPs
+                : [];
+            if (mentionedMCPs.length > 0) {
+                const { data: mentionedTools } = await codeboltjs_1.default.mcp.getTools(mentionedMCPs);
+                refreshedTools = [...refreshedTools, ...(mentionedTools || [])];
+            }
+            const allowedToolNames = this.getAllowedToolNames(prompt);
+            if (allowedToolNames && allowedToolNames.length > 0) {
+                const allowed = new Set(allowedToolNames);
+                refreshedTools = refreshedTools.filter((tool) => { var _a; return !!((_a = tool.function) === null || _a === void 0 ? void 0 : _a.name) && allowed.has(tool.function.name); });
+            }
+            const mergedTools = this.mergeTools(existingTools, refreshedTools);
+            return {
+                ...prompt,
+                message: {
+                    ...prompt.message,
+                    tools: mergedTools,
+                    ...(mergedTools.length > 0
+                        ? { tool_choice: (_d = prompt.message.tool_choice) !== null && _d !== void 0 ? _d : 'auto' }
+                        : {}),
+                },
+                metadata: {
+                    ...prompt.metadata,
+                    toolsCount: mergedTools.length,
+                    toolsRefreshedAt: new Date().toISOString(),
+                },
+            };
+        }
+        catch (error) {
+            if (this.enableLogging) {
+                console.error('[CodeboltAgent] Failed to refresh tools:', error);
+            }
+            return prompt;
+        }
+    }
+    mergeTools(existingTools, refreshedTools) {
+        var _a, _b;
+        const mergedTools = new Map();
+        for (const tool of refreshedTools) {
+            const toolName = (_a = tool.function) === null || _a === void 0 ? void 0 : _a.name;
+            if (toolName) {
+                mergedTools.set(toolName, tool);
+            }
+        }
+        for (const tool of existingTools) {
+            const toolName = (_b = tool.function) === null || _b === void 0 ? void 0 : _b.name;
+            if (toolName && !mergedTools.has(toolName)) {
+                mergedTools.set(toolName, tool);
+            }
+        }
+        return Array.from(mergedTools.values());
+    }
+    getAllowedToolNames(prompt) {
+        var _a;
+        const metadataAllowedTools = (_a = prompt.metadata) === null || _a === void 0 ? void 0 : _a['allowedTools'];
+        if (Array.isArray(metadataAllowedTools)) {
+            const allowedToolNames = metadataAllowedTools.filter((toolName) => typeof toolName === 'string' && toolName.length > 0);
+            if (allowedToolNames.length > 0) {
+                return allowedToolNames;
+            }
+        }
+        return this.allowedTools;
+    }
+    getRecoverableResponseError(response) {
+        var _a, _b, _c, _d;
+        const reactiveLayer = this.compactionOrchestrator.getReactiveLayer();
+        const candidateMessages = this.collectResponseMessages(response);
+        const recoverableMessage = candidateMessages.find((message) => reactiveLayer.isRecoverableError(message));
+        if (recoverableMessage) {
+            return recoverableMessage;
+        }
+        const finishReasons = [
+            response.finish_reason,
+            ...((_a = response.choices) !== null && _a !== void 0 ? _a : []).map((choice) => choice.finish_reason),
+        ].filter((reason) => typeof reason === 'string');
+        const hasLengthFinishReason = finishReasons.some((reason) => reason.toLowerCase() === 'length');
+        const hasToolCalls = ((_c = (_b = response.tool_calls) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0) > 0 ||
+            ((_d = response.choices) !== null && _d !== void 0 ? _d : []).some((choice) => { var _a, _b, _c; return ((_c = (_b = (_a = choice.message) === null || _a === void 0 ? void 0 : _a.tool_calls) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0) > 0; });
+        if (hasLengthFinishReason && candidateMessages.length === 0 && !hasToolCalls) {
+            return 'Too many tokens or token limit reached before producing usable output.';
+        }
+        return null;
+    }
+    collectResponseMessages(response) {
+        var _a, _b;
+        const messages = [];
+        if (typeof response.content === 'string' && response.content.trim().length > 0) {
+            messages.push(response.content.trim());
+        }
+        for (const choice of (_a = response.choices) !== null && _a !== void 0 ? _a : []) {
+            if (typeof ((_b = choice.message) === null || _b === void 0 ? void 0 : _b.content) === 'string' &&
+                choice.message.content.trim().length > 0) {
+                messages.push(choice.message.content.trim());
+            }
+        }
+        return messages;
+    }
 }
 exports.CodeboltAgent = CodeboltAgent;
-/**
- * Factory function to create a CodeboltAgent with common defaults
- */
 function createCodeboltAgent(options) {
     var _a;
     return new CodeboltAgent({
@@ -248,6 +345,9 @@ function createCodeboltAgent(options) {
             preToolCallProcessors: options.preToolCallProcessors || [],
             postToolCallProcessors: options.postToolCallProcessors || []
         },
-        enableLogging: (_a = options.enableLogging) !== null && _a !== void 0 ? _a : true
+        enableLogging: (_a = options.enableLogging) !== null && _a !== void 0 ? _a : true,
+        ...(options.compaction ? { compaction: options.compaction } : {}),
+        ...(options.loopDetectionService ? { loopDetectionService: options.loopDetectionService } : {}),
+        ...(options.maxTurns !== undefined ? { maxTurns: options.maxTurns } : {}),
     });
 }

package/dist/unified/base/agentStep.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentStep = void 0;
 const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const promptContext_1 = require("./promptContext");
 /**
  * Unified agent step that handles LLM interaction and tool call analysis
  */
@@ -20,40 +21,39 @@ class AgentStep {
     async executeStep(originalRequest, createdMessage) {
         var _a;
         try {
+            let preparedMessage = (0, promptContext_1.syncProcessedMessageWithRuntimeContext)(createdMessage);
             for (const preInferenceProcessor of this.preInferenceProcessors) {
                 try {
-                    // Each modifier returns a new ProcessedMessage
-                    createdMessage = await preInferenceProcessor.modify(originalRequest, createdMessage);
+                    preparedMessage = await preInferenceProcessor.modify(originalRequest, preparedMessage);
+                    preparedMessage = (0, promptContext_1.reconcileRuntimePromptContext)(preparedMessage);
                 }
                 catch (error) {
                     console.error(`[InitialPromptGenerator] Error in message modifier:`, error);
-                    // Continue with other modifiers
                 }
             }
-            // Generate LLM response
-            const rawLLMResponse = await this.generateResponse(createdMessage.message);
-            // add llm reslponse to created message
-            let modifiedMessage = createdMessage;
-            (_a = rawLLMResponse.choices) === null || _a === void 0 ? void 0 : _a.forEach(contentBlock => {
-                modifiedMessage.message.messages.push({
-                    ...contentBlock.message,
-                    role: contentBlock.message.role
-                });
-            });
+            const actualMessageSentToLLM = {
+                ...preparedMessage,
+                message: (0, promptContext_1.buildInferenceParams)(preparedMessage),
+            };
+            const rawLLMResponse = await this.generateResponse(actualMessageSentToLLM.message);
+            const assistantMessages = ((_a = rawLLMResponse.choices) !== null && _a !== void 0 ? _a : []).map((contentBlock) => ({
+                ...contentBlock.message,
+                role: contentBlock.message.role
+            }));
+            let modifiedMessage = (0, promptContext_1.appendTranscriptMessages)(preparedMessage, assistantMessages);
             for (const postInferenceProcessor of this.postInferenceProcessors) {
                 try {
-                    // Each modifier returns a new ProcessedMessage
-                    modifiedMessage = await postInferenceProcessor.modify(createdMessage, rawLLMResponse, modifiedMessage);
+                    modifiedMessage = await postInferenceProcessor.modify(actualMessageSentToLLM, rawLLMResponse, modifiedMessage);
+                    modifiedMessage = (0, promptContext_1.reconcileRuntimePromptContext)(modifiedMessage);
                 }
                 catch (error) {
                     console.error(`[InitialPromptGenerator] Error in message modifier:`, error);
-                    // Continue with other modifiers
                 }
             }
             const output = {
                 rawLLMResponse: rawLLMResponse,
                 nextMessage: modifiedMessage,
-                actualMessageSentToLLM: createdMessage
+                actualMessageSentToLLM
             };
             return output;
         }

package/dist/unified/base/initialPromptGenerator.js

@@ -7,6 +7,7 @@ exports.InitialPromptGenerator = void 0;
 exports.createUnifiedMessageProcessor = createUnifiedMessageProcessor;
 const types_1 = require("../types/types");
 const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const promptContext_1 = require("./promptContext");
 /**
  * Initial prompt generator that combines message modifiers with unified processing
  */
@@ -29,13 +30,9 @@ class InitialPromptGenerator {
             if (this.enableLogging) {
                 // console.log('[InitialPromptGenerator] Processing message:', input);
             }
-            // Create initial ProcessedMessage from FlatUserMessage
-            const content = input.userMessage;
-            // Create messages array, starting with system message if baseSystemPrompt is defined
-            const messages = [];
             let createdMessage = {
                 message: {
-                    messages: messages,
+                    messages: [],
                     tools: []
                 },
                 metadata: {
@@ -44,52 +41,37 @@ class InitialPromptGenerator {
                     threadId: input.threadId
                 }
             };
-            // Apply all message modifiers in sequence
-            // Each modifier receives the original request (FlatUserMessage) and the current processed message
+            createdMessage = (0, promptContext_1.syncProcessedMessageWithRuntimeContext)(createdMessage);
+            if (this.baseSystemPrompt !== undefined) {
+                createdMessage = (0, promptContext_1.setSystemPrompt)(createdMessage, this.baseSystemPrompt);
+            }
+            createdMessage = (0, promptContext_1.appendTranscriptMessage)(createdMessage, {
+                role: 'user',
+                content: input.userMessage.trim(),
+            });
             for (const messageModifier of this.processors) {
                 try {
-                    // Each modifier returns a new ProcessedMessage
                     createdMessage = await messageModifier.modify(input, createdMessage);
+                    createdMessage = (0, promptContext_1.reconcileRuntimePromptContext)(createdMessage);
                 }
                 catch (error) {
                     console.error(`[InitialPromptGenerator] Error in message modifier:`, error);
-                    // Continue with other modifiers
                 }
             }
-            const lastMessage = createdMessage.message.messages[createdMessage.message.messages.length - 1];
-            if (!lastMessage || lastMessage.role !== 'system') {
-                createdMessage.message.messages.push({
-                    role: 'assistant',
-                    content: "Got it. Thanks for the context!"
-                });
-            }
             let { todos } = await codeboltjs_1.default.todo.getAllIncompleteTodos();
             if (todos && todos.length == 0) {
-                createdMessage.message.messages.push({
+                createdMessage = (0, promptContext_1.appendUserContextMessage)(createdMessage, {
                     role: 'user',
                     content: "<system-reminder>\nThis is a reminder that your todo list is currently empty. DO NOT mention this to the user explicitly because they are already aware. If you are working on tasks that would benefit from a todo list please use the TodoWrite tool to create one. If not, please feel free to ignore. Again do not mention this message to the user.\n</system-reminder>"
                 });
             }
-            createdMessage.message.messages.push({
-                role: 'user',
-                content: content.trim()
-            });
             if (this.enableLogging) {
                 // console.log('[InitialPromptGenerator] Processing completed:', {
                 //     messageCount: createdMessage.message.messages.length,
                 //     metadata: createdMessage.metadata
                 // });
             }
-            if (this.baseSystemPrompt !== undefined) {
-                const hasSystem = createdMessage.message.messages.some(msg => msg.role === 'system');
-                if (!hasSystem) {
-                    createdMessage.message.messages.unshift({
-                        role: 'system',
-                        content: this.baseSystemPrompt
-                    });
-                }
-            }
-            return createdMessage;
+            return (0, promptContext_1.syncProcessedMessageWithRuntimeContext)(createdMessage);
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';

package/dist/unified/base/promptContext.d.ts

@@ -0,0 +1,13 @@
+import type { ProcessedMessage } from '@codebolt/types/agent';
+import type { LLMInferenceParams, MessageObject } from '@codebolt/types/sdk';
+export declare function syncProcessedMessageWithRuntimeContext(prompt: ProcessedMessage): ProcessedMessage;
+export declare function reconcileRuntimePromptContext(prompt: ProcessedMessage): ProcessedMessage;
+export declare function setSystemPrompt(prompt: ProcessedMessage, systemPrompt: string): ProcessedMessage;
+export declare function appendSystemContextMessage(prompt: ProcessedMessage, message: MessageObject): ProcessedMessage;
+export declare function appendUserContextMessage(prompt: ProcessedMessage, message: MessageObject): ProcessedMessage;
+export declare function appendTranscriptMessage(prompt: ProcessedMessage, message: MessageObject): ProcessedMessage;
+export declare function appendTranscriptMessages(prompt: ProcessedMessage, messages: MessageObject[]): ProcessedMessage;
+export declare function prependTranscriptMessages(prompt: ProcessedMessage, messages: MessageObject[]): ProcessedMessage;
+export declare function replaceTranscriptMessages(prompt: ProcessedMessage, messages: MessageObject[]): ProcessedMessage;
+export declare function getTranscriptMessages(prompt: ProcessedMessage): MessageObject[];
+export declare function buildInferenceParams(prompt: ProcessedMessage): LLMInferenceParams;