@codebolt/agent 6.1.15 → 6.1.17

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

@@ -12,8 +12,10 @@ export declare class EnvironmentContextModifier extends BaseMessageModifier {
     private readonly options;
     private readonly defaultExcludePatterns;
     constructor(options?: EnvironmentContextOptions);
-    modify(_originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private formatMentionedEnvironments;
     private readProjectAgentMd;
+    private readAgentInstructionFile;
     private generateFullContext;
     private findRelevantFiles;
     private walkDirectory;

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

@@ -67,7 +67,7 @@ class EnvironmentContextModifier extends base_1.BaseMessageModifier {
             excludePatterns: [...this.defaultExcludePatterns, ...(options.excludePatterns || [])]
         };
     }
-    async modify(_originalRequest, createdMessage) {
+    async modify(originalRequest, createdMessage) {
         try {
             // Get current date formatted to user's locale
             const today = new Date().toLocaleDateString(undefined, {
@@ -115,6 +115,10 @@ ${directoryListing}
                     contextParts.push(baseAgentMdContext);
                 }
             }
+            const mentionedEnvironmentContext = this.formatMentionedEnvironments(originalRequest.mentionedEnvironments);
+            if (mentionedEnvironmentContext) {
+                contextParts.push(mentionedEnvironmentContext);
+            }
             // Add full file context if enabled (just like gemini-cli does)
             if (this.options.enableFullContext) {
                 try {
@@ -155,18 +159,67 @@ ${directoryListing}
             return createdMessage;
         }
     }
+    formatMentionedEnvironments(mentionedEnvironments) {
+        if (!(mentionedEnvironments === null || mentionedEnvironments === void 0 ? void 0 : mentionedEnvironments.length)) {
+            return null;
+        }
+        const environments = mentionedEnvironments
+            .map((mention) => {
+            const environment = (mention === null || mention === void 0 ? void 0 : mention.environmentData) || mention;
+            const provider = (environment === null || environment === void 0 ? void 0 : environment.provider) || (environment === null || environment === void 0 ? void 0 : environment.remoteProvider) || {};
+            const config = (environment === null || environment === void 0 ? void 0 : environment.config) || {};
+            return {
+                id: (mention === null || mention === void 0 ? void 0 : mention.id) || (environment === null || environment === void 0 ? void 0 : environment.id) || (environment === null || environment === void 0 ? void 0 : environment.environmentId) || (environment === null || environment === void 0 ? void 0 : environment.environment_id),
+                name: (mention === null || mention === void 0 ? void 0 : mention.title) || (environment === null || environment === void 0 ? void 0 : environment.name) || (environment === null || environment === void 0 ? void 0 : environment.title),
+                description: (mention === null || mention === void 0 ? void 0 : mention.description) || (environment === null || environment === void 0 ? void 0 : environment.description),
+                state: (environment === null || environment === void 0 ? void 0 : environment.state) || (environment === null || environment === void 0 ? void 0 : environment.status),
+                provider: (provider === null || provider === void 0 ? void 0 : provider.name) || (provider === null || provider === void 0 ? void 0 : provider.title) || (provider === null || provider === void 0 ? void 0 : provider.id) || (provider === null || provider === void 0 ? void 0 : provider.providerId),
+                executionMode: (config === null || config === void 0 ? void 0 : config.executionMode) || (environment === null || environment === void 0 ? void 0 : environment.executionMode) || (environment === null || environment === void 0 ? void 0 : environment.type),
+                environment,
+            };
+        })
+            .filter((environment) => environment.id || environment.name);
+        if (!environments.length) {
+            return null;
+        }
+        return [
+            '<mentioned-environments>',
+            'The user explicitly mentioned these environments with #. Treat them as routing context, not as an automatic active-environment selection.',
+            'If the user asks to run, start, delegate, create, or continue work in one of these environments, first inspect this mentioned environment list and choose the matching environment.',
+            'Use the thread tool `thread_create_background` to create a background thread in the selected remote environment. Pass the selected environment object in `environment`, set `isRemoteTask: true`, and put the requested work in `userMessage` or `task`.',
+            'If `thread_create_background` is not available in the current tool list, first use the tool search capability, such as `tool_search`, to find the thread/background-thread creation tool and then use the matching tool.',
+            'If multiple mentioned environments could match and the user did not specify which one, ask a brief clarification before creating the background thread.',
+            'Do not call environment management tools or change the active environment just because an environment was mentioned.',
+            JSON.stringify(environments, null, 2),
+            '</mentioned-environments>',
+        ].join('\n');
+    }
     async readProjectAgentMd(basePath, title = 'Project Agent Instructions') {
-        const agentMdPath = path.join(basePath, '.codebolt', 'agent.md');
-        const relativePath = path.relative(basePath, agentMdPath);
+        const instructionFiles = [
+            path.join(basePath, '.codebolt', 'agent.md'),
+            path.join(basePath, 'agent.md'),
+            path.join(basePath, 'AGENTS.md'),
+        ];
+        const sections = [];
+        for (const instructionFile of instructionFiles) {
+            const section = await this.readAgentInstructionFile(basePath, instructionFile, title);
+            if (section) {
+                sections.push(section);
+            }
+        }
+        return sections.join('\n\n');
+    }
+    async readAgentInstructionFile(basePath, filePath, title) {
+        const relativePath = path.relative(basePath, filePath);
         try {
-            const stats = await fs.promises.stat(agentMdPath);
+            const stats = await fs.promises.stat(filePath);
             if (!stats.isFile()) {
                 return '';
             }
             if (stats.size > this.options.maxFileSize) {
                 return `--- ${title} (${relativePath}) ---\n[File too large: ${stats.size} bytes]`;
             }
-            const content = await fs.promises.readFile(agentMdPath, 'utf-8');
+            const content = await fs.promises.readFile(filePath, 'utf-8');
             if (!content.trim()) {
                 return '';
             }

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

@@ -1,11 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToolInjectionModifier = void 0;
 const base_1 = require("../base");
-const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const agentToolLoader_1 = require("../../unified/utils/agentToolLoader");
 class ToolInjectionModifier extends base_1.BaseMessageModifier {
     constructor(options = {}) {
         super();
@@ -14,16 +11,16 @@ class ToolInjectionModifier extends base_1.BaseMessageModifier {
             includeToolDescriptions: options.includeToolDescriptions !== false,
             maxToolsInMessage: options.maxToolsInMessage || 30,
             giveToolExamples: options.giveToolExamples || false,
-            maxToolExamples: options.maxToolExamples || 2
+            maxToolExamples: options.maxToolExamples || 2,
         };
+        if (options.allowedTools) {
+            this.options.allowedTools = options.allowedTools;
+        }
     }
     async modify(originalRequest, createdMessage) {
         try {
-            const toolsResponse = await codeboltjs_1.default.mcp.listMcpFromServers(['codebolt']);
-            let tools = (toolsResponse === null || toolsResponse === void 0 ? void 0 : toolsResponse.data.tools) || (toolsResponse === null || toolsResponse === void 0 ? void 0 : toolsResponse.data) || [];
             let mentionedMCPs = originalRequest.mentionedMCPs || [];
-            const { data: mentionedTools } = await codeboltjs_1.default.mcp.getTools(mentionedMCPs);
-            tools = [...tools, ...(mentionedTools || [])];
+            let tools = await (0, agentToolLoader_1.listAgentAvailableTools)(Array.isArray(mentionedMCPs) ? mentionedMCPs : []);
             // Filter tools if allowedTools is specified
             if (this.options.allowedTools && this.options.allowedTools.length > 0) {
                 tools = tools.filter((tool) => this.options.allowedTools.includes(tool.function.name));

package/dist/types/InternalTypes.d.ts

@@ -488,6 +488,8 @@ export interface Message {
     }[];
     /** List of agents mentioned in the message */
     mentionedAgents: any[];
+    /** List of environments mentioned in the message */
+    mentionedEnvironments?: any[];
     remixPrompt?: string;
 }
 /**

package/dist/types/commonTypes.d.ts

@@ -332,6 +332,12 @@ export interface Agent {
     /** Detailed description of the agent and its capabilities */
     longDescription?: string;
 }
+export interface FlagContext {
+    user: string[];
+    project: string[];
+    thread: string[];
+    effective: string[];
+}
 /**
  * Interface for initial user message structure
  */
@@ -346,6 +352,12 @@ export interface InitialUserMessage {
     mentionedMCPs?: MCPTool[];
     /** List of mentioned agents */
     mentionedAgents?: Agent[];
+    /** List of mentioned environments */
+    mentionedEnvironments?: any[];
+    /** Flags mentioned in the initial message context */
+    mentionedFlags?: string[];
+    /** Flags enabled for the initial message context */
+    flags?: FlagContext;
 }
 /**
  * Type definition for an AST node.

package/dist/types/libFunctionTypes.d.ts

@@ -160,6 +160,12 @@ export interface UserMessageContent {
     /** The text content */
     text: string;
 }
+export interface FlagContext {
+    user: string[];
+    project: string[];
+    thread: string[];
+    effective: string[];
+}
 /**
  * User message received from the Codebolt platform
  * This is a simplified, user-friendly version of the internal message format
@@ -193,6 +199,30 @@ export interface UserMessage {
     selection?: any;
     remixPrompt?: string;
     mentionedAgents?: [];
+    mentionedEnvironments?: any[];
+    mentionedFlags?: string[];
+    flags?: FlagContext;
+}
+export interface DynamicAgentEvent {
+    id: string;
+    type: 'agent:dynamic:event';
+    timestamp: string;
+    source: Record<string, any>;
+    payload: {
+        name: string;
+        data?: Record<string, any>;
+        emittedAt: string;
+    };
+    metadata?: Record<string, any>;
+}
+export interface EmitAgentEventResponse {
+    success: boolean;
+    type: string;
+    requestId?: string;
+    data?: {
+        event: DynamicAgentEvent;
+    };
+    error?: string;
 }
 /**
  * Interface for codebolt API functionality
@@ -224,6 +254,11 @@ export interface CodeboltAPI {
     chat: {
         sendMessage: (message: string, metadata: any) => Promise<void>;
     };
+    agentEvents: {
+        emit: (name: string, data?: Record<string, any>, options?: {
+            metadata?: Record<string, any>;
+        }) => Promise<EmitAgentEventResponse>;
+    };
 }
 export interface ReadFileOptions {
     /** File path to read */
@@ -565,6 +600,8 @@ export interface ChatSendOptions {
     mentionedFiles?: string[];
     /** Mentioned agents */
     mentionedAgents?: string[];
+    /** Mentioned environments */
+    mentionedEnvironments?: any[];
 }
 export interface ChatHistoryOptions {
     /** Conversation ID */

package/dist/types/socketMessageTypes.d.ts

@@ -22,6 +22,12 @@ export interface BaseExecuteToolResponse extends BaseWebSocketResponse {
     result?: any;
     status?: 'pending' | 'executing' | 'success' | 'error' | 'rejected';
 }
+export interface FlagContext {
+    user: string[];
+    project: string[];
+    thread: string[];
+    effective: string[];
+}
 export interface UserMessage {
     type: "messageResponse";
     message: {
@@ -42,6 +48,7 @@ export interface UserMessage {
         actions: any[];
         mentionedAgents: any[];
         mentionedDocs: any[];
+        mentionedEnvironments?: any[];
         links: any[];
         universalAgentLastMessage: string;
         selection: any | null;
@@ -53,6 +60,8 @@ export interface UserMessage {
         templateType: string;
         processId: string;
         shadowGitHash: string;
+        mentionedFlags?: string[];
+        flags?: FlagContext;
     };
     sender: {
         senderType: string;
@@ -84,6 +93,7 @@ export interface ChatMessageFromUser {
     actions: any[];
     mentionedAgents: any[];
     mentionedDocs: any[];
+    mentionedEnvironments?: any[];
     links: any[];
     universalAgentLastMessage: string;
     selection: any | null;
@@ -95,6 +105,8 @@ export interface ChatMessageFromUser {
     templateType: string;
     processId: string;
     shadowGitHash: string;
+    mentionedFlags?: string[];
+    flags?: FlagContext;
 }
 export interface ChatMessage extends BaseWebSocketResponse {
     id: string;

package/dist/unified/agent/agent.d.ts

@@ -20,7 +20,6 @@ export declare class Agent implements AgentInterface {
     private applyCompaction;
     private tryRecoverPrompt;
     private refreshAvailableTools;
-    private mergeTools;
     private getAllowedToolNames;
     private getRecoverableResponseError;
     private collectResponseMessages;

package/dist/unified/agent/agent.js

@@ -1,15 +1,12 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Agent = void 0;
-const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
 const base_1 = require("../base");
 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 agentToolLoader_1 = require("../utils/agentToolLoader");
 class Agent {
     constructor(config) {
         var _a, _b, _c, _d, _e, _f;
@@ -157,7 +154,7 @@ class Agent {
         };
     }
     async refreshAvailableTools(originalRequest, prompt) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         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;
@@ -166,28 +163,23 @@ class Agent {
             ? 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 || [])];
-            }
+            let refreshedTools = await (0, agentToolLoader_1.listAgentAvailableTools)(mentionedMCPs);
             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);
+            const mergedTools = (0, agentToolLoader_1.mergeTools)(refreshedTools, existingTools);
             return {
                 ...prompt,
                 message: {
                     ...prompt.message,
                     tools: mergedTools,
                     ...(mergedTools.length > 0
-                        ? { tool_choice: (_d = prompt.message.tool_choice) !== null && _d !== void 0 ? _d : 'auto' }
+                        ? { tool_choice: (_c = prompt.message.tool_choice) !== null && _c !== void 0 ? _c : 'auto' }
                         : {}),
                 },
                 metadata: {
@@ -204,23 +196,6 @@ class Agent {
             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'];

package/dist/unified/agent/codeboltAgent.d.ts

@@ -43,7 +43,6 @@ export declare class CodeboltAgent {
     private applyCompaction;
     private tryRecoverPrompt;
     private refreshAvailableTools;
-    private mergeTools;
     private getAllowedToolNames;
     private getRecoverableResponseError;
     private collectResponseMessages;

package/dist/unified/agent/codeboltAgent.js

@@ -1,16 +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.CodeboltAgent = void 0;
 exports.createCodeboltAgent = createCodeboltAgent;
-const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
 const base_1 = require("../base");
 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 agentToolLoader_1 = require("../utils/agentToolLoader");
 const processor_pieces_1 = require("../../processor-pieces");
 class CodeboltAgent {
     constructor(config) {
@@ -66,6 +63,7 @@ class CodeboltAgent {
             mentionedMCPs: [],
             uploadedImages: [],
             mentionedAgents: [],
+            mentionedEnvironments: [],
             messageId: `msg-${Date.now()}`,
             threadId: `thread-${Date.now()}`
         };
@@ -228,7 +226,7 @@ class CodeboltAgent {
         };
     }
     async refreshAvailableTools(originalRequest, prompt) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         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;
@@ -237,28 +235,23 @@ class CodeboltAgent {
             ? 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 || [])];
-            }
+            let refreshedTools = await (0, agentToolLoader_1.listAgentAvailableTools)(mentionedMCPs);
             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);
+            const mergedTools = (0, agentToolLoader_1.mergeTools)(refreshedTools, existingTools);
             return {
                 ...prompt,
                 message: {
                     ...prompt.message,
                     tools: mergedTools,
                     ...(mergedTools.length > 0
-                        ? { tool_choice: (_d = prompt.message.tool_choice) !== null && _d !== void 0 ? _d : 'auto' }
+                        ? { tool_choice: (_c = prompt.message.tool_choice) !== null && _c !== void 0 ? _c : 'auto' }
                         : {}),
                 },
                 metadata: {
@@ -275,23 +268,6 @@ class CodeboltAgent {
             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'];

package/dist/unified/base/agentStep.js

@@ -63,7 +63,7 @@ class AgentStep {
         }
     }
     async generateResponse(messageForLLM) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         const response = await codeboltjs_1.default.llm.inference(messageForLLM);
         const completion = response.completion;
         // Add tokenLimit and maxOutputTokens to completion object if available in response
@@ -75,6 +75,12 @@ class AgentStep {
             if (response.maxOutputTokens !== undefined) {
                 completion.maxOutputTokens = response.maxOutputTokens;
             }
+            if (response.contextCompaction !== undefined) {
+                completion.contextCompaction = response.contextCompaction;
+            }
+            if (response.compactionRequired !== undefined) {
+                completion.compactionRequired = response.compactionRequired;
+            }
             // Also check inside completion object itself (from LLM provider response)
             if (((_a = completion.completion) === null || _a === void 0 ? void 0 : _a.tokenLimit) !== undefined) {
                 completion.tokenLimit = completion.completion.tokenLimit;
@@ -82,6 +88,12 @@ class AgentStep {
             if (((_b = completion.completion) === null || _b === void 0 ? void 0 : _b.maxOutputTokens) !== undefined) {
                 completion.maxOutputTokens = completion.completion.maxOutputTokens;
             }
+            if (((_c = completion.completion) === null || _c === void 0 ? void 0 : _c.contextCompaction) !== undefined) {
+                completion.contextCompaction = completion.completion.contextCompaction;
+            }
+            if (((_d = completion.completion) === null || _d === void 0 ? void 0 : _d.compactionRequired) !== undefined) {
+                completion.compactionRequired = completion.completion.compactionRequired;
+            }
         }
         return completion;
     }

package/dist/unified/base/initialPromptGenerator.js

@@ -8,6 +8,27 @@ exports.createUnifiedMessageProcessor = createUnifiedMessageProcessor;
 const types_1 = require("../types/types");
 const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
 const promptContext_1 = require("./promptContext");
+const formatFlagList = (flags) => flags && flags.length > 0 ? flags.join(', ') : 'none';
+const normalizeFlagList = (flags) => Array.from(new Set((flags || [])
+    .map(flag => String(flag || '').trim().toLowerCase().replace(/\s+/g, '-').replace(/^-+|-+$/g, ''))
+    .filter(Boolean))).sort();
+const mergeFlagLists = (existing, mentioned) => {
+    const merged = [...(existing || []), ...normalizeFlagList(mentioned)];
+    return Array.from(new Set(merged.filter(Boolean)));
+};
+const formatFlagContext = (flags, mentionedFlags) => {
+    const normalizedMentionedFlags = normalizeFlagList(mentionedFlags);
+    if (!flags && normalizedMentionedFlags.length === 0)
+        return null;
+    return [
+        '<flags>',
+        `user: ${formatFlagList(flags === null || flags === void 0 ? void 0 : flags.user)}`,
+        `project: ${formatFlagList(flags === null || flags === void 0 ? void 0 : flags.project)}`,
+        `thread: ${formatFlagList(mergeFlagLists(flags === null || flags === void 0 ? void 0 : flags.thread, normalizedMentionedFlags))}`,
+        `effective: ${formatFlagList(mergeFlagLists(flags === null || flags === void 0 ? void 0 : flags.effective, normalizedMentionedFlags))}`,
+        '</flags>',
+    ].join('\n');
+};
 /**
  * Initial prompt generator that combines message modifiers with unified processing
  */
@@ -49,6 +70,13 @@ class InitialPromptGenerator {
                 role: 'user',
                 content: input.userMessage.trim(),
             });
+            const flagContext = formatFlagContext(input.flags, input.mentionedFlags);
+            if (flagContext) {
+                createdMessage = (0, promptContext_1.appendUserContextMessage)(createdMessage, {
+                    role: 'user',
+                    content: flagContext,
+                });
+            }
             for (const messageModifier of this.processors) {
                 try {
                     createdMessage = await messageModifier.modify(input, createdMessage);

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

@@ -15,8 +15,12 @@ export declare class ResponseExecutor implements AgentResponseExecutor {
     private parseToolCall;
     private extractLastMessageContent;
     private getToolCalls;
+    private hasExecutableToolCalls;
+    private runRequiredCompaction;
     private executeTools;
     private sendFinalMessageToChat;
+    private extractCompletionMessage;
+    private formatCompletionValue;
     private executeSingleToolCall;
     private executeTool;
     private parseToolResult;

package/dist/unified/base/responseExecutor.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResponseExecutor = void 0;
 const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
 const promptContext_1 = require("./promptContext");
+const agentToolLoader_1 = require("../utils/agentToolLoader");
 class ResponseExecutor {
     constructor(options) {
         this.preToolCallProcessors = [];
@@ -38,10 +39,15 @@ class ResponseExecutor {
                 console.error(`[ResponseExecutor] Error in pre tool call processor:`, error);
             }
         }
+        const compactionMessagePromise = this.runRequiredCompaction(input.rawLLMOutput);
         const toolExecution = await this.executeTools(input.rawLLMOutput);
+        const compactionCompleted = await compactionMessagePromise;
+        if (compactionCompleted) {
+            await Promise.resolve(codeboltjs_1.default.chat.sendMessage('Conversation Compacted'));
+        }
         this.completed = this.completed || toolExecution.completed;
         this.finalMessage = (_a = toolExecution.finalMessage) !== null && _a !== void 0 ? _a : this.finalMessage;
-        this.injectDiscoveredTools(input.rawLLMOutput, toolExecution.toolResults, nextMessage);
+        await this.injectDiscoveredTools(input.rawLLMOutput, toolExecution.toolResults, nextMessage);
         if (toolExecution.toolResults.length > 0 || toolExecution.followUpMessages.length > 0) {
             nextMessage = (0, promptContext_1.appendTranscriptMessages)(nextMessage, [
                 ...toolExecution.toolResults.map((toolResult) => ({
@@ -142,7 +148,35 @@ class ResponseExecutor {
         }
         return Array.from(toolCallsById.values());
     }
+    hasExecutableToolCalls(llmResponse) {
+        return this.getToolCalls(llmResponse).some((toolCall) => {
+            var _a;
+            const toolName = ((_a = toolCall.function) === null || _a === void 0 ? void 0 : _a.name) || '';
+            return !toolName.includes('attempt_completion') &&
+                !toolName.includes('context_compaction') &&
+                !toolName.includes('contextCompaction');
+        });
+    }
+    async runRequiredCompaction(llmResponse) {
+        var _a;
+        const decision = llmResponse.contextCompaction;
+        if (!(decision === null || decision === void 0 ? void 0 : decision.required) || decision.hasToolCalls === false || !this.hasExecutableToolCalls(llmResponse)) {
+            return false;
+        }
+        try {
+            await codeboltjs_1.default.contextCompaction.run({
+                ...(decision.runRequest || {}),
+                reason: String(((_a = decision.runRequest) === null || _a === void 0 ? void 0 : _a['reason']) || decision.reason || 'llm_response_tool_calls'),
+            });
+            return true;
+        }
+        catch (error) {
+            console.error('[ResponseExecutor] Context compaction failed:', error);
+            return false;
+        }
+    }
     async executeTools(llmResponse) {
+        var _a;
         const lastMessageContent = this.extractLastMessageContent(llmResponse);
         const toolCalls = this.getToolCalls(llmResponse);
         if (toolCalls.length === 0) {
@@ -195,8 +229,9 @@ class ResponseExecutor {
             const completionToolCall = completionToolCalls.at(-1);
             if (completionToolCall) {
                 const completionArguments = completionToolCall.toolInput;
-                this.finalMessage = JSON.stringify(completionArguments);
                 const [, completionResult] = await this.executeTool(completionToolCall.toolName, completionArguments);
+                this.finalMessage = (_a = this.extractCompletionMessage(completionArguments)) !== null && _a !== void 0 ? _a : lastMessageContent;
+                await this.sendFinalMessageToChat(this.finalMessage);
                 const parsedCompletionResult = this.parseToolResult(completionToolCall.toolUseId, completionResult === '' ? 'The user is satisfied with the result.' : completionResult);
                 toolResults.push(parsedCompletionResult);
             }
@@ -220,6 +255,36 @@ class ResponseExecutor {
             console.error('[ResponseExecutor] Failed to send final chat message:', error);
         }
     }
+    extractCompletionMessage(toolInput) {
+        if ('result' in toolInput) {
+            return this.formatCompletionValue(toolInput['result']);
+        }
+        return this.formatCompletionValue(toolInput);
+    }
+    formatCompletionValue(value) {
+        if (typeof value === 'string') {
+            return value;
+        }
+        if (value === undefined || value === null) {
+            return undefined;
+        }
+        if (typeof value !== 'object') {
+            return String(value);
+        }
+        const valueRecord = value;
+        for (const key of ['answer', 'message', 'content', 'text', 'output', 'result']) {
+            const nestedValue = valueRecord[key];
+            if (typeof nestedValue === 'string' && nestedValue.trim().length > 0) {
+                return nestedValue;
+            }
+        }
+        try {
+            return JSON.stringify(value, null, 2);
+        }
+        catch {
+            return String(value);
+        }
+    }
     async executeSingleToolCall(toolCall) {
         try {
             let resultTuple;
@@ -271,7 +336,8 @@ class ResponseExecutor {
     }
     async executeTool(toolName, toolInput) {
         var _a, _b, _c;
-        const parts = toolName.split('--');
+        const executionToolName = (0, agentToolLoader_1.resolveToolExecutionName)(toolName);
+        const parts = executionToolName.split('--');
         const toolboxName = parts.length > 1 ? ((_a = parts[0]) !== null && _a !== void 0 ? _a : '') : 'codebolt';
         const actualToolName = parts.length > 1 ? ((_b = parts[1]) !== null && _b !== void 0 ? _b : '') : ((_c = parts[0]) !== null && _c !== void 0 ? _c : '');
         const { data } = await codeboltjs_1.default.mcp.executeTool(toolboxName, actualToolName, toolInput);
@@ -323,7 +389,7 @@ class ResponseExecutor {
     getPostToolCallProcessors() {
         return this.postToolCallProcessors;
     }
-    injectDiscoveredTools(llmResponse, toolResults, nextMessage) {
+    async injectDiscoveredTools(llmResponse, toolResults, nextMessage) {
         var _a, _b;
         try {
             const toolCalls = this.getToolCalls(llmResponse);
@@ -335,9 +401,16 @@ class ResponseExecutor {
                 const toolName = ((_b = toolCall.function) === null || _b === void 0 ? void 0 : _b.name) || '';
                 const isToolSearch = toolName === 'tool_search' ||
                     toolName === 'codebolt--tool_search' ||
-                    toolName.endsWith('--tool_search');
+                    toolName.endsWith('--tool_search') ||
+                    toolName === 'search_mcp_tool' ||
+                    toolName === 'codebolt--search_mcp_tool' ||
+                    toolName.endsWith('--search_mcp_tool') ||
+                    toolName === 'codebase_search_mcp_tool' ||
+                    toolName === 'codebolt--codebase_search_mcp_tool' ||
+                    toolName.endsWith('--codebase_search_mcp_tool');
                 if (!isToolSearch)
                     continue;
+                (0, agentToolLoader_1.appendUniqueTools)(nextMessage.message.tools, await (0, agentToolLoader_1.listProjectLocalTools)());
                 const toolCallId = toolCall.id;
                 const toolResult = toolResults.find(r => r.tool_call_id === toolCallId);
                 if (!(toolResult === null || toolResult === void 0 ? void 0 : toolResult.content))
@@ -363,7 +436,7 @@ class ResponseExecutor {
                     const rawName = schemaFunction === null || schemaFunction === void 0 ? void 0 : schemaFunction.name;
                     if (!rawName)
                         continue;
-                    const prefixedName = rawName.startsWith('codebolt--') ? rawName : `codebolt--${rawName}`;
+                    const prefixedName = rawName.includes('--') ? rawName : `codebolt--${rawName}`;
                     if (existingToolNames.has(prefixedName))
                         continue;
                     const prefixedSchema = {

package/dist/unified/types/libTypes.d.ts

@@ -206,6 +206,18 @@ export interface CodeboltAPI {
         /** List available agents */
         listAgents(): Promise<string[]>;
     };
+    /** Dynamic agent events */
+    agentEvents?: {
+        emit(name: string, data?: Record<string, unknown>, options?: {
+            metadata?: Record<string, unknown>;
+        }): Promise<{
+            success: boolean;
+            type: string;
+            requestId?: string;
+            data?: unknown;
+            error?: string;
+        }>;
+    };
 }
 /**
  * LLM configuration

package/dist/unified/utils/agentToolLoader.d.ts

@@ -0,0 +1,14 @@
+import type { Tool } from '@codebolt/types/sdk';
+type ToolResponse = {
+    data?: {
+        tools?: unknown;
+    } | unknown;
+};
+export declare function normalizeToolForModel(tool: Tool): Tool;
+export declare function resolveToolExecutionName(modelToolName: string): string;
+export declare function normalizeToolResponse(response: ToolResponse | undefined): Tool[];
+export declare function mergeTools(...toolGroups: Tool[][]): Tool[];
+export declare function listProjectLocalTools(): Promise<Tool[]>;
+export declare function listAgentAvailableTools(mentionedMCPs?: unknown[]): Promise<Tool[]>;
+export declare function appendUniqueTools(targetTools: Tool[], toolsToAppend: Tool[]): void;
+export {};

package/dist/unified/utils/agentToolLoader.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeToolForModel = normalizeToolForModel;
+exports.resolveToolExecutionName = resolveToolExecutionName;
+exports.normalizeToolResponse = normalizeToolResponse;
+exports.mergeTools = mergeTools;
+exports.listProjectLocalTools = listProjectLocalTools;
+exports.listAgentAvailableTools = listAgentAvailableTools;
+exports.appendUniqueTools = appendUniqueTools;
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const MODEL_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
+const LOCAL_TOOL_PREFIX = 'local/';
+const toolExecutionNameByModelName = new Map();
+function isTool(value) {
+    var _a;
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const candidate = value;
+    return candidate.type === 'function' && typeof ((_a = candidate.function) === null || _a === void 0 ? void 0 : _a.name) === 'string';
+}
+function hashString(value) {
+    let hash = 0;
+    for (let index = 0; index < value.length; index += 1) {
+        hash = ((hash << 5) - hash + value.charCodeAt(index)) | 0;
+    }
+    return Math.abs(hash).toString(36);
+}
+function sanitizeToolNamePart(value) {
+    const sanitized = value.replace(/[^a-zA-Z0-9_-]/g, '_').replace(/_+/g, '_');
+    return sanitized.replace(/^_+|_+$/g, '') || 'tool';
+}
+function normalizeToolForModel(tool) {
+    const originalName = tool.function.name;
+    let modelName = originalName;
+    if (!MODEL_TOOL_NAME_PATTERN.test(originalName)) {
+        const separatorIndex = originalName.indexOf('--');
+        if (originalName.startsWith(LOCAL_TOOL_PREFIX) && separatorIndex > LOCAL_TOOL_PREFIX.length) {
+            const toolboxName = originalName.slice(LOCAL_TOOL_PREFIX.length, separatorIndex);
+            const actualToolName = originalName.slice(separatorIndex + 2);
+            modelName = `local_${sanitizeToolNamePart(toolboxName)}--${sanitizeToolNamePart(actualToolName)}`;
+        }
+        else {
+            modelName = sanitizeToolNamePart(originalName);
+        }
+        const mappedName = toolExecutionNameByModelName.get(modelName);
+        if (mappedName && mappedName !== originalName) {
+            modelName = `${modelName}_${hashString(originalName)}`;
+        }
+        toolExecutionNameByModelName.set(modelName, originalName);
+    }
+    if (modelName === originalName) {
+        return tool;
+    }
+    return {
+        ...tool,
+        function: {
+            ...tool.function,
+            name: modelName,
+        },
+    };
+}
+function resolveToolExecutionName(modelToolName) {
+    return toolExecutionNameByModelName.get(modelToolName) || modelToolName;
+}
+function normalizeToolResponse(response) {
+    const data = response === null || response === void 0 ? void 0 : response.data;
+    const tools = Array.isArray(data === null || data === void 0 ? void 0 : data.tools)
+        ? data.tools
+        : Array.isArray(data)
+            ? data
+            : [];
+    return tools.filter(isTool).map(normalizeToolForModel);
+}
+function mergeTools(...toolGroups) {
+    var _a;
+    const mergedTools = new Map();
+    for (const tools of toolGroups) {
+        for (const tool of tools) {
+            const toolName = (_a = tool.function) === null || _a === void 0 ? void 0 : _a.name;
+            if (toolName && !mergedTools.has(toolName)) {
+                mergedTools.set(toolName, tool);
+            }
+        }
+    }
+    return Array.from(mergedTools.values());
+}
+async function listProjectLocalTools() {
+    const mcp = codeboltjs_1.default.mcp;
+    if (typeof mcp.getLocalMCPServers !== 'function') {
+        return [];
+    }
+    try {
+        return normalizeToolResponse(await mcp.getLocalMCPServers());
+    }
+    catch (error) {
+        console.error('[AgentToolLoader] Failed to load project-local tools:', error);
+        return [];
+    }
+}
+async function listAgentAvailableTools(mentionedMCPs = []) {
+    let codeboltTools = [];
+    let mentionedTools = [];
+    try {
+        codeboltTools = normalizeToolResponse(await codeboltjs_1.default.mcp.listMcpFromServers(['codebolt']));
+    }
+    catch (error) {
+        console.error('[AgentToolLoader] Failed to load CodeBolt tools:', error);
+    }
+    const localTools = await listProjectLocalTools();
+    if (mentionedMCPs.length > 0) {
+        try {
+            const response = await codeboltjs_1.default.mcp.getTools(mentionedMCPs);
+            mentionedTools = normalizeToolResponse(response);
+        }
+        catch (error) {
+            console.error('[AgentToolLoader] Failed to load mentioned MCP tools:', error);
+        }
+    }
+    return mergeTools(codeboltTools, localTools, mentionedTools);
+}
+function appendUniqueTools(targetTools, toolsToAppend) {
+    var _a;
+    const existingToolNames = new Set(targetTools
+        .map((tool) => { var _a; return (_a = tool.function) === null || _a === void 0 ? void 0 : _a.name; })
+        .filter((toolName) => typeof toolName === 'string' && toolName.length > 0));
+    for (const tool of toolsToAppend) {
+        const toolName = (_a = tool.function) === null || _a === void 0 ? void 0 : _a.name;
+        if (!toolName || existingToolNames.has(toolName)) {
+            continue;
+        }
+        targetTools.push(tool);
+        existingToolNames.add(toolName);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebolt/agent",
-  "version": "6.1.15",
+  "version": "6.1.17",
   "description": "CodeBolt Agent utilities for building and managing AI agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",