@codebolt/agent 6.0.0 → 6.1.2

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

@@ -0,0 +1,316 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryTypeContextModifier = exports.RuleBasedContextModifier = exports.ContextAssemblyModifier = void 0;
+const base_1 = require("../base");
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const promptContext_1 = require("../../unified/base/promptContext");
+class ContextAssemblyModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.options = {
+            scopeVariables: options.scopeVariables || {},
+            additionalVariables: options.additionalVariables,
+            explicitMemory: options.explicitMemory,
+            ruleEngineIds: options.ruleEngineIds,
+            constraints: options.constraints,
+            includeUserInput: options.includeUserInput !== false,
+            messageRole: options.messageRole || 'system',
+            validateBeforeAssembly: options.validateBeforeAssembly || false,
+            formatContribution: options.formatContribution,
+        };
+    }
+    async modify(_originalRequest, createdMessage) {
+        var _a, _b, _c, _d;
+        try {
+            const request = this.buildRequest(createdMessage);
+            // Optionally validate first
+            if (this.options.validateBeforeAssembly) {
+                const validation = await codeboltjs_1.default.contextAssembly.validate(request);
+                if (!validation.success || (((_a = validation.data) === null || _a === void 0 ? void 0 : _a.validation) && !validation.data.validation.valid)) {
+                    console.warn('Context assembly validation failed:', (_c = (_b = validation.data) === null || _b === void 0 ? void 0 : _b.validation) === null || _c === void 0 ? void 0 : _c.errors);
+                    return createdMessage;
+                }
+            }
+            const response = await codeboltjs_1.default.contextAssembly.getContext(request);
+            if (!response.success || !((_d = response.data) === null || _d === void 0 ? void 0 : _d.context)) {
+                console.warn('Context assembly failed:', response.error || response.message);
+                return createdMessage;
+            }
+            const { context } = response.data;
+            const contextContent = this.formatContext(context.contributions);
+            if (!contextContent.trim()) {
+                return createdMessage;
+            }
+            const contextMessage = {
+                role: this.options.messageRole,
+                content: contextContent,
+            };
+            const updatedMessage = this.options.messageRole === 'user'
+                ? (0, promptContext_1.appendUserContextMessage)(createdMessage, contextMessage)
+                : (0, promptContext_1.appendSystemContextMessage)(createdMessage, contextMessage);
+            return {
+                ...updatedMessage,
+                metadata: {
+                    ...createdMessage.metadata,
+                    contextAssemblyAdded: true,
+                    contextAssemblyStats: {
+                        totalTokens: context.total_tokens,
+                        assemblyTimeMs: context.assembly_time_ms,
+                        contributionCount: context.contributions.length,
+                        appliedRules: context.applied_rules,
+                        warnings: context.warnings,
+                    },
+                },
+            };
+        }
+        catch (error) {
+            console.error('Error in ContextAssemblyModifier:', error);
+            return createdMessage;
+        }
+    }
+    buildRequest(createdMessage) {
+        const request = {
+            scope_variables: { ...this.options.scopeVariables },
+        };
+        if (this.options.includeUserInput) {
+            const userMessage = createdMessage.message.messages.find(msg => msg.role === 'user');
+            if (userMessage && typeof userMessage.content === 'string') {
+                request.input = userMessage.content;
+            }
+        }
+        if (this.options.additionalVariables) {
+            request.additional_variables = this.options.additionalVariables;
+        }
+        if (this.options.explicitMemory) {
+            request.explicit_memory = this.options.explicitMemory;
+        }
+        if (this.options.constraints) {
+            request.constraints = this.options.constraints;
+        }
+        if (this.options.ruleEngineIds) {
+            request.rule_engine_ids = this.options.ruleEngineIds;
+        }
+        return request;
+    }
+    formatContext(contributions) {
+        if (contributions.length === 0)
+            return '';
+        const formatter = this.options.formatContribution || this.defaultFormatContribution;
+        const parts = contributions.map(formatter);
+        return `## Assembled Context\n\n${parts.join('\n\n')}`;
+    }
+    defaultFormatContribution(contribution) {
+        return `### ${contribution.memory_label}\n${contribution.content}`;
+    }
+    /** Update scope variables at runtime */
+    setScopeVariables(variables) {
+        this.options.scopeVariables = { ...this.options.scopeVariables, ...variables };
+    }
+    /** Update additional variables at runtime */
+    setAdditionalVariables(variables) {
+        this.options.additionalVariables = { ...this.options.additionalVariables, ...variables };
+    }
+    /** Set explicit memory IDs to include */
+    setExplicitMemory(memoryIds) {
+        this.options.explicitMemory = memoryIds;
+    }
+    /** Set constraints for context assembly */
+    setConstraints(constraints) {
+        this.options.constraints = constraints;
+    }
+}
+exports.ContextAssemblyModifier = ContextAssemblyModifier;
+class RuleBasedContextModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.options = {
+            scopeVariables: options.scopeVariables || {},
+            ruleEngineIds: options.ruleEngineIds,
+            messageRole: options.messageRole || 'system',
+            constraints: options.constraints,
+        };
+    }
+    async modify(_originalRequest, createdMessage) {
+        var _a;
+        try {
+            // First evaluate rules to determine which memories to include
+            const userMessage = createdMessage.message.messages.find(msg => msg.role === 'user');
+            const input = userMessage && typeof userMessage.content === 'string' ? userMessage.content : undefined;
+            const request = {
+                scope_variables: { ...this.options.scopeVariables },
+            };
+            if (input) {
+                request.input = input;
+            }
+            const ruleResult = await codeboltjs_1.default.contextAssembly.evaluateRules(request, this.options.ruleEngineIds);
+            if (!ruleResult.success || !ruleResult.data) {
+                console.warn('Rule evaluation failed:', ruleResult.error || ruleResult.message);
+                return createdMessage;
+            }
+            const { included_memories, forced_memories } = ruleResult.data;
+            const memoriesToFetch = [...new Set([...included_memories, ...forced_memories])];
+            if (memoriesToFetch.length === 0) {
+                return createdMessage;
+            }
+            // Now assemble context with only the rule-determined memories
+            const assemblyRequest = {
+                scope_variables: { ...this.options.scopeVariables },
+                explicit_memory: memoriesToFetch,
+            };
+            if (input) {
+                assemblyRequest.input = input;
+            }
+            if (this.options.constraints) {
+                assemblyRequest.constraints = this.options.constraints;
+            }
+            const response = await codeboltjs_1.default.contextAssembly.getContext(assemblyRequest);
+            if (!response.success || !((_a = response.data) === null || _a === void 0 ? void 0 : _a.context)) {
+                console.warn('Context assembly failed after rule evaluation:', response.error);
+                return createdMessage;
+            }
+            const { context } = response.data;
+            const parts = context.contributions.map((c) => `### ${c.memory_label}\n${c.content}`);
+            const contextContent = `## Rule-Based Context\n\n${parts.join('\n\n')}`;
+            if (!contextContent.trim()) {
+                return createdMessage;
+            }
+            const contextMessage = {
+                role: this.options.messageRole,
+                content: contextContent,
+            };
+            const messages = [...createdMessage.message.messages, contextMessage];
+            return {
+                message: {
+                    ...createdMessage.message,
+                    messages,
+                },
+                metadata: {
+                    ...createdMessage.metadata,
+                    ruleBasedContextAdded: true,
+                    ruleEvaluation: {
+                        matchedRules: ruleResult.data.matched_rules,
+                        includedMemories: included_memories,
+                        excludedMemories: ruleResult.data.excluded_memories,
+                        forcedMemories: forced_memories,
+                    },
+                    contextAssemblyStats: {
+                        totalTokens: context.total_tokens,
+                        assemblyTimeMs: context.assembly_time_ms,
+                        contributionCount: context.contributions.length,
+                    },
+                },
+            };
+        }
+        catch (error) {
+            console.error('Error in RuleBasedContextModifier:', error);
+            return createdMessage;
+        }
+    }
+    /** Update scope variables at runtime */
+    setScopeVariables(variables) {
+        this.options.scopeVariables = { ...this.options.scopeVariables, ...variables };
+    }
+    /** Set specific rule engine IDs to evaluate */
+    setRuleEngineIds(ruleEngineIds) {
+        this.options.ruleEngineIds = ruleEngineIds;
+    }
+}
+exports.RuleBasedContextModifier = RuleBasedContextModifier;
+class MemoryTypeContextModifier extends base_1.BaseMessageModifier {
+    constructor(options) {
+        super();
+        this.options = {
+            memoryNames: options.memoryNames,
+            scopeVariables: options.scopeVariables || {},
+            autoResolveVariables: options.autoResolveVariables || false,
+            messageRole: options.messageRole || 'system',
+            constraints: options.constraints,
+        };
+    }
+    async modify(_originalRequest, createdMessage) {
+        var _a;
+        try {
+            let additionalVariables;
+            // Auto-resolve required variables if enabled
+            if (this.options.autoResolveVariables) {
+                const requiredVarsResponse = await codeboltjs_1.default.contextAssembly.getRequiredVariables(this.options.memoryNames);
+                if (requiredVarsResponse.success && requiredVarsResponse.data) {
+                    additionalVariables = this.resolveVariables(requiredVarsResponse.data, createdMessage);
+                }
+            }
+            const userMessage = createdMessage.message.messages.find(msg => msg.role === 'user');
+            const input = userMessage && typeof userMessage.content === 'string' ? userMessage.content : undefined;
+            const request = {
+                scope_variables: { ...this.options.scopeVariables },
+                explicit_memory: this.options.memoryNames,
+            };
+            if (input) {
+                request.input = input;
+            }
+            if (additionalVariables) {
+                request.additional_variables = additionalVariables;
+            }
+            if (this.options.constraints) {
+                request.constraints = this.options.constraints;
+            }
+            const response = await codeboltjs_1.default.contextAssembly.getContext(request);
+            if (!response.success || !((_a = response.data) === null || _a === void 0 ? void 0 : _a.context)) {
+                console.warn('Memory type context assembly failed:', response.error || response.message);
+                return createdMessage;
+            }
+            const { context } = response.data;
+            const parts = context.contributions.map((c) => `### ${c.memory_label}\n${c.content}`);
+            const contextContent = parts.join('\n\n');
+            if (!contextContent.trim()) {
+                return createdMessage;
+            }
+            const contextMessage = {
+                role: this.options.messageRole,
+                content: contextContent,
+            };
+            const messages = [...createdMessage.message.messages, contextMessage];
+            return {
+                message: {
+                    ...createdMessage.message,
+                    messages,
+                },
+                metadata: {
+                    ...createdMessage.metadata,
+                    memoryTypeContextAdded: true,
+                    memoryNames: this.options.memoryNames,
+                    contextAssemblyStats: {
+                        totalTokens: context.total_tokens,
+                        assemblyTimeMs: context.assembly_time_ms,
+                        contributionCount: context.contributions.length,
+                    },
+                },
+            };
+        }
+        catch (error) {
+            console.error('Error in MemoryTypeContextModifier:', error);
+            return createdMessage;
+        }
+    }
+    resolveVariables(requiredVars, createdMessage) {
+        const resolved = {};
+        for (const [key, _spec] of Object.entries(requiredVars.additional_variables)) {
+            // Try to resolve from existing metadata
+            if (createdMessage.metadata && key in createdMessage.metadata) {
+                resolved[key] = createdMessage.metadata[key];
+            }
+        }
+        return resolved;
+    }
+    /** Update memory names to fetch */
+    setMemoryNames(memoryNames) {
+        this.options.memoryNames = memoryNames;
+    }
+    /** Update scope variables at runtime */
+    setScopeVariables(variables) {
+        this.options.scopeVariables = { ...this.options.scopeVariables, ...variables };
+    }
+}
+exports.MemoryTypeContextModifier = MemoryTypeContextModifier;

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CoreSystemPromptModifier = void 0;
 const base_1 = require("../base");
+const promptContext_1 = require("../../unified/base/promptContext");
 class CoreSystemPromptModifier extends base_1.BaseMessageModifier {
     constructor(options = {}) {
         super();
@@ -12,26 +13,8 @@ class CoreSystemPromptModifier extends base_1.BaseMessageModifier {
         // Get user memory from metadata or options
         const userMemory = ((_a = createdMessage.metadata) === null || _a === void 0 ? void 0 : _a['userMemory']) || this.options.userMemory;
         const systemPrompt = this.options.customSystemPrompt || this.getCoreSystemPrompt(userMemory);
-        const systemMessage = {
-            role: 'system',
-            content: systemPrompt
-        };
-        // Find existing system message or add new one
-        const messages = [...createdMessage.message.messages];
-        const systemMessageIndex = messages.findIndex(msg => msg.role === 'system');
-        if (systemMessageIndex !== -1) {
-            // Replace existing system message
-            messages[systemMessageIndex] = systemMessage;
-        }
-        else {
-            // Add new system message at the beginning
-            messages.unshift(systemMessage);
-        }
         return Promise.resolve({
-            message: {
-                ...createdMessage.message,
-                messages
-            },
+            ...(0, promptContext_1.setSystemPrompt)(createdMessage, systemPrompt),
             metadata: {
                 ...createdMessage.metadata,
                 coreSystemPromptAdded: true,

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

@@ -41,6 +41,7 @@ const base_1 = require("../base");
 const fs = __importStar(require("node:fs/promises"));
 const path = __importStar(require("node:path"));
 const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const promptContext_1 = require("../../unified/base/promptContext");
 const MAX_ITEMS = 200;
 const TRUNCATION_INDICATOR = '...';
 const DEFAULT_IGNORED_FOLDERS = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.cache', '.tmp', 'tmp']);
@@ -100,13 +101,8 @@ ${folderStructure}`;
                 role: 'user', // Note: gemini-cli adds this as user message, not system
                 content: directoryContext
             };
-            // Add as user message (like gemini-cli does)
-            const messages = [...createdMessage.message.messages, contextMessage];
             return Promise.resolve({
-                message: {
-                    ...createdMessage.message,
-                    messages
-                },
+                ...(0, promptContext_1.appendUserContextMessage)(createdMessage, contextMessage),
                 metadata: {
                     ...createdMessage.metadata,
                     directoryContextAdded: true,

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

@@ -41,6 +41,7 @@ const base_1 = require("../base");
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const promptContext_1 = require("../../unified/base/promptContext");
 class EnvironmentContextModifier extends base_1.BaseMessageModifier {
     constructor(options = {}) {
         super();
@@ -119,14 +120,8 @@ ${directoryListing}
                 role: 'user',
                 content: finalContent
             };
-            // Push the context message to the messages array
-            const messages = [...createdMessage.message.messages];
-            messages.push(contextMessage);
             return Promise.resolve({
-                message: {
-                    ...createdMessage.message,
-                    messages
-                },
+                ...(0, promptContext_1.appendUserContextMessage)(createdMessage, contextMessage),
                 metadata: {
                     ...createdMessage.metadata,
                     environmentContextAdded: true,

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IdeContextModifier = void 0;
 const base_1 = require("../base");
+const promptContext_1 = require("../../unified/base/promptContext");
 class IdeContextModifier extends base_1.BaseMessageModifier {
     constructor(options = {}) {
         super();
@@ -29,32 +30,12 @@ class IdeContextModifier extends base_1.BaseMessageModifier {
                 role: 'system',
                 content: contextParts.join('\n')
             };
-            // Find existing system message or add new one
-            const messages = [...createdMessage.message.messages];
-            const systemMessageIndex = messages.findIndex(msg => msg.role === 'system');
-            if (systemMessageIndex !== -1) {
-                // Append to existing system message
-                const existingMessage = messages[systemMessageIndex];
-                if (existingMessage) {
-                    messages[systemMessageIndex] = {
-                        role: existingMessage.role,
-                        content: `${existingMessage.content}\n\n${ideContextMessage.content}`
-                    };
-                }
-            }
-            else {
-                // Add new system message
-                messages.unshift(ideContextMessage);
-            }
             if (newIdeContext) {
                 this.lastSentIdeContext = newIdeContext;
             }
             this.forceFullContext = false;
             return Promise.resolve({
-                message: {
-                    ...createdMessage.message,
-                    messages
-                },
+                ...(0, promptContext_1.appendSystemContextMessage)(createdMessage, ideContextMessage),
                 metadata: {
                     ...createdMessage.metadata,
                     ideContextAdded: true,

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

@@ -9,3 +9,6 @@ export { LoopDetectionModifier, type LoopDetectionOptions } from '../postInferen
 export { ToolInjectionModifier, type ToolInjectionOptions } from './toolInjectionModifier';
 export { ChatRecordingModifier, type ChatRecordingOptions } from './chatRecordingModifier';
 export { ChatHistoryMessageModifier, type ChatHistoryMessageModifierOptions } from './chatHistoryMessageModifier';
+export { ContextAssemblyModifier, type ContextAssemblyModifierOptions } from './contextAssemblyModifier';
+export { RuleBasedContextModifier, type RuleBasedContextModifierOptions } from './contextAssemblyModifier';
+export { MemoryTypeContextModifier, type MemoryTypeContextModifierOptions } from './contextAssemblyModifier';

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChatHistoryMessageModifier = exports.ChatRecordingModifier = exports.ToolInjectionModifier = exports.LoopDetectionModifier = exports.MemoryImportModifier = exports.ArgumentProcessorModifier = exports.AtFileProcessorModifier = exports.IdeContextModifier = exports.DirectoryContextModifier = exports.CoreSystemPromptModifier = exports.EnvironmentContextModifier = void 0;
+exports.MemoryTypeContextModifier = exports.RuleBasedContextModifier = exports.ContextAssemblyModifier = exports.ChatHistoryMessageModifier = exports.ChatRecordingModifier = exports.ToolInjectionModifier = exports.LoopDetectionModifier = exports.MemoryImportModifier = exports.ArgumentProcessorModifier = exports.AtFileProcessorModifier = exports.IdeContextModifier = exports.DirectoryContextModifier = exports.CoreSystemPromptModifier = exports.EnvironmentContextModifier = void 0;
 // Gemini-CLI equivalent modifiers
 var environmentContextModifier_1 = require("./environmentContextModifier");
 Object.defineProperty(exports, "EnvironmentContextModifier", { enumerable: true, get: function () { return environmentContextModifier_1.EnvironmentContextModifier; } });
@@ -24,3 +24,9 @@ var chatRecordingModifier_1 = require("./chatRecordingModifier");
 Object.defineProperty(exports, "ChatRecordingModifier", { enumerable: true, get: function () { return chatRecordingModifier_1.ChatRecordingModifier; } });
 var chatHistoryMessageModifier_1 = require("./chatHistoryMessageModifier");
 Object.defineProperty(exports, "ChatHistoryMessageModifier", { enumerable: true, get: function () { return chatHistoryMessageModifier_1.ChatHistoryMessageModifier; } });
+var contextAssemblyModifier_1 = require("./contextAssemblyModifier");
+Object.defineProperty(exports, "ContextAssemblyModifier", { enumerable: true, get: function () { return contextAssemblyModifier_1.ContextAssemblyModifier; } });
+var contextAssemblyModifier_2 = require("./contextAssemblyModifier");
+Object.defineProperty(exports, "RuleBasedContextModifier", { enumerable: true, get: function () { return contextAssemblyModifier_2.RuleBasedContextModifier; } });
+var contextAssemblyModifier_3 = require("./contextAssemblyModifier");
+Object.defineProperty(exports, "MemoryTypeContextModifier", { enumerable: true, get: function () { return contextAssemblyModifier_3.MemoryTypeContextModifier; } });

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

@@ -107,7 +107,8 @@ class ToolInjectionModifier extends base_1.BaseMessageModifier {
                 ...createdMessage.metadata,
                 toolsInjected: true,
                 toolsLocation: 'Tool',
-                toolsCount: tools.length
+                toolsCount: tools.length,
+                allowedTools: this.options.allowedTools
             }
         };
     }

package/dist/processor-pieces/postToolCallProcessors/conversationCompactorModifier.d.ts

@@ -121,20 +121,28 @@ export declare class ConversationCompactorModifier extends BasePostToolCallProce
     private readonly options;
     private failedCompressionAttempts;
     private hasFailedCompression;
+    private lastCompressionTokenCount;
+    private stepsSinceLastCompression;
     constructor(options?: ConversationCompactorOptions);
+    /**
+     * Calibrated characters-per-token ratio.
+     * Starts at 4 (rough default) but gets refined when actual API usage data is available.
+     */
+    private charsPerToken;
     /**
      * Estimates token count for a string
-     * Uses the ~4 characters per token approximation
+     * Uses calibrated chars-per-token ratio (refined by actual API usage when available)
      */
     private estimateTokens;
     /**
-     * Counts tokens for an array of messages
+     * Calibrates the chars-per-token ratio using actual API usage data.
+     * Called when rawLLMResponseMessage.usage is available to improve estimation accuracy.
      */
-    private countMessageTokens;
+    private calibrateTokenEstimation;
     /**
-     * Gets content length from a message (handles string and array content)
+     * Counts tokens for an array of messages
      */
-    private getMessageContentLength;
+    private countMessageTokens;
     /**
      * Extracts text content from a message
      */
@@ -143,6 +151,15 @@ export declare class ConversationCompactorModifier extends BasePostToolCallProce
      * Checks if a message is a function/tool response
      */
     private isToolResponseMessage;
+    /**
+     * Finds the original user request (first non-system, non-tool user message)
+     */
+    private getOriginalUserMessage;
+    /**
+     * Inserts the original user message right after system messages if it's
+     * not already present in the preserved messages.
+     */
+    private ensureOriginalUserMessage;
     /**
      * Truncates content to a specified number of lines
      * Keeps first half and last half of allowed lines for context
@@ -180,6 +197,18 @@ export declare class ConversationCompactorModifier extends BasePostToolCallProce
      * Optional verification pass - asks LLM to verify and correct the summary
      */
     private verifySummary;
+    /**
+     * Extracts file paths from the "Required Files" section of a summary.
+     * Looks for section 9 (REQUIRED FILES) and extracts paths listed there.
+     */
+    private extractRequiredFiles;
+    /**
+     * Deduplicates repeated file reads in conversation history.
+     * When the same file is read multiple times, older reads are replaced with
+     * a short note, keeping only the latest read for each file path.
+     * This reduces token count before full compression kicks in.
+     */
+    private deduplicateFileReads;
     /**
      * Simple compression strategy - just removes old messages
      */