@codebolt/agent 6.0.0 → 6.0.1

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * as ProcessorPieces from './processor-pieces';
+export * from './unified';

package/dist/index.js

@@ -0,0 +1,41 @@
+"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;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessorPieces = void 0;
+exports.ProcessorPieces = __importStar(require("./processor-pieces"));
+__exportStar(require("./unified"), exports);

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

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChatHistoryMessageModifier = void 0;
 const base_1 = require("../base");
 const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const promptContext_1 = require("../../unified/base/promptContext");
 // Using MessageObject from SDK types for chat history messages
 class ChatHistoryMessageModifier extends base_1.BaseMessageModifier {
     constructor(options = {}) {
@@ -26,10 +27,7 @@ class ChatHistoryMessageModifier extends base_1.BaseMessageModifier {
             }
             // Directly use the chat history messages - they're already in MessageObject format
             return {
-                message: {
-                    ...createdMessage.message,
-                    messages: [...chatHistory, ...createdMessage.message.messages]
-                },
+                ...(0, promptContext_1.prependTranscriptMessages)(createdMessage, chatHistory),
                 metadata: {
                     ...createdMessage.metadata,
                     chatHistoryAdded: true,

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

@@ -0,0 +1,81 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+import type { ContextConstraints, MemoryContribution } from "@codebolt/types/lib";
+export interface ContextAssemblyModifierOptions {
+    /** Scope variables to pass to the context assembly engine */
+    scopeVariables?: Record<string, any>;
+    /** Additional variables for memory resolution */
+    additionalVariables?: Record<string, any> | undefined;
+    /** Explicit memory IDs to include */
+    explicitMemory?: string[] | undefined;
+    /** Rule engine IDs to use for filtering */
+    ruleEngineIds?: string[] | undefined;
+    /** Constraints for context assembly */
+    constraints?: ContextConstraints | undefined;
+    /** Whether to include the user's input in the context request */
+    includeUserInput?: boolean;
+    /** Whether to inject context as system or user message */
+    messageRole?: 'system' | 'user';
+    /** Whether to validate the request before assembling */
+    validateBeforeAssembly?: boolean;
+    /** Custom formatter for memory contributions */
+    formatContribution?: ((contribution: MemoryContribution) => string) | undefined;
+}
+export declare class ContextAssemblyModifier extends BaseMessageModifier {
+    private readonly options;
+    constructor(options?: ContextAssemblyModifierOptions);
+    modify(_originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private buildRequest;
+    private formatContext;
+    private defaultFormatContribution;
+    /** Update scope variables at runtime */
+    setScopeVariables(variables: Record<string, any>): void;
+    /** Update additional variables at runtime */
+    setAdditionalVariables(variables: Record<string, any>): void;
+    /** Set explicit memory IDs to include */
+    setExplicitMemory(memoryIds: string[]): void;
+    /** Set constraints for context assembly */
+    setConstraints(constraints: ContextConstraints): void;
+}
+export interface RuleBasedContextModifierOptions {
+    /** Scope variables for rule evaluation */
+    scopeVariables?: Record<string, any>;
+    /** Specific rule engine IDs to evaluate */
+    ruleEngineIds?: string[] | undefined;
+    /** Whether to inject context as system or user message */
+    messageRole?: 'system' | 'user';
+    /** Constraints for the final context assembly */
+    constraints?: ContextConstraints | undefined;
+}
+export declare class RuleBasedContextModifier extends BaseMessageModifier {
+    private readonly options;
+    constructor(options?: RuleBasedContextModifierOptions);
+    modify(_originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    /** Update scope variables at runtime */
+    setScopeVariables(variables: Record<string, any>): void;
+    /** Set specific rule engine IDs to evaluate */
+    setRuleEngineIds(ruleEngineIds: string[]): void;
+}
+export interface MemoryTypeContextModifierOptions {
+    /** Specific memory type names to fetch */
+    memoryNames: string[];
+    /** Scope variables for context assembly */
+    scopeVariables?: Record<string, any>;
+    /** Whether to auto-resolve required variables from the message */
+    autoResolveVariables?: boolean;
+    /** Whether to inject context as system or user message */
+    messageRole?: 'system' | 'user';
+    /** Constraints for context assembly */
+    constraints?: ContextConstraints | undefined;
+}
+export declare class MemoryTypeContextModifier extends BaseMessageModifier {
+    private readonly options;
+    constructor(options: MemoryTypeContextModifierOptions);
+    modify(_originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private resolveVariables;
+    /** Update memory names to fetch */
+    setMemoryNames(memoryNames: string[]): void;
+    /** Update scope variables at runtime */
+    setScopeVariables(variables: Record<string, any>): void;
+}

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
             }
         };
     }