@codebolt/agent 6.1.16 → 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/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/codeboltAgent.js

@@ -63,6 +63,7 @@ class CodeboltAgent {
             mentionedMCPs: [],
             uploadedImages: [],
             mentionedAgents: [],
+            mentionedEnvironments: [],
             messageId: `msg-${Date.now()}`,
             threadId: `thread-${Date.now()}`
         };

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

@@ -19,6 +19,8 @@ export declare class ResponseExecutor implements AgentResponseExecutor {
     private runRequiredCompaction;
     private executeTools;
     private sendFinalMessageToChat;
+    private extractCompletionMessage;
+    private formatCompletionValue;
     private executeSingleToolCall;
     private executeTool;
     private parseToolResult;

package/dist/unified/base/responseExecutor.js

@@ -176,6 +176,7 @@ class ResponseExecutor {
         }
     }
     async executeTools(llmResponse) {
+        var _a;
         const lastMessageContent = this.extractLastMessageContent(llmResponse);
         const toolCalls = this.getToolCalls(llmResponse);
         if (toolCalls.length === 0) {
@@ -228,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);
             }
@@ -253,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;

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/package.json

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