@codebolt/agent 6.1.23 → 6.1.26

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export * as ProcessorPieces from './processor-pieces';
 export * from './unified';
+export type { Automation, AutomationAction, AutomationActionType, AutomationCalendarOptions, AutomationRun, AutomationRunStatus, AutomationTrigger, Recipient, RecipientAddress, RecipientKind, RecipientOption, RecipientSnapshot, ScheduleDefinition, } from './types/automation';

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

@@ -0,0 +1,8 @@
+import type { MessageModifier, ProcessedMessage } from '@codebolt/types/agent';
+import type { FlatUserMessage } from '@codebolt/types/sdk';
+import { type AgentEventQueueProcessorOptions } from '../utils/agentEventQueuePrompt';
+export declare class AgentEventQueueModifier implements MessageModifier {
+    private readonly options;
+    constructor(options?: AgentEventQueueProcessorOptions);
+    modify(_originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentEventQueueModifier = void 0;
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const agentEventQueuePrompt_1 = require("../utils/agentEventQueuePrompt");
+class AgentEventQueueModifier {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async modify(_originalRequest, createdMessage) {
+        const pendingEvents = await codeboltjs_1.default.agentEventQueue.getPendingEvents();
+        return (0, agentEventQueuePrompt_1.injectAgentQueueEventsIntoPrompt)(createdMessage, pendingEvents, this.options);
+    }
+}
+exports.AgentEventQueueModifier = AgentEventQueueModifier;

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

@@ -61,6 +61,7 @@ ${workspaceContext}
 - **Explaining Changes:** After completing a code modification or file operation *do not* provide summaries unless asked.
 - **Path Construction:** Before using any file system tool, you must construct the full absolute path for the file_path argument. Always combine the absolute path of the project's root directory with the file's path relative to the root. For example, if the project root is /path/to/project/ and the file is foo/bar/baz.txt, the final path you must use is /path/to/project/foo/bar/baz.txt. If the user provides a relative path, you must resolve it against the root directory to create an absolute path.
 - **Do Not revert changes:** Do not revert changes to the codebase unless asked to do so by the user. Only revert changes made by you if they have resulted in an error or if the user has explicitly asked you to revert the changes.
+- **Mail notifications:** If you receive a mail notification, treat it as a notification only. The event may include a short message body, but use the mail_get_message tool with the provided messageId when you need full mail details. If mail_get_message is not in your available tools, use tool search to find it.
 
 # Primary Workflows
 

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

@@ -8,9 +8,11 @@ export { ArgumentProcessorModifier, type ArgumentProcessorOptions } from './argu
 export { MemoryImportModifier, type MemoryImportOptions } from './memoryImportModifier';
 export { LoopDetectionModifier, type LoopDetectionOptions } from '../postInferenceProcessors/loopDetectionModifier';
 export { ToolInjectionModifier, type ToolInjectionOptions } from './toolInjectionModifier';
+export { ToolGroupContextModifier, type ToolGroupContextOptions } from './toolGroupContextModifier';
 export { ToolManifestPromptModifier, type ToolManifestPromptModifierOptions } from './toolManifestPromptModifier';
 export { ChatRecordingModifier, type ChatRecordingOptions } from './chatRecordingModifier';
 export { ChatHistoryMessageModifier, type ChatHistoryMessageModifierOptions } from './chatHistoryMessageModifier';
+export { AgentEventQueueModifier } from './agentEventQueueModifier';
 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.MemoryTypeContextModifier = exports.RuleBasedContextModifier = exports.ContextAssemblyModifier = exports.ChatHistoryMessageModifier = exports.ChatRecordingModifier = exports.ToolManifestPromptModifier = exports.ToolInjectionModifier = exports.LoopDetectionModifier = exports.MemoryImportModifier = exports.ArgumentProcessorModifier = exports.CapabilityContextModifier = exports.AtFileProcessorModifier = exports.IdeContextModifier = exports.DirectoryContextModifier = exports.CoreSystemPromptModifier = exports.EnvironmentContextModifier = void 0;
+exports.MemoryTypeContextModifier = exports.RuleBasedContextModifier = exports.ContextAssemblyModifier = exports.AgentEventQueueModifier = exports.ChatHistoryMessageModifier = exports.ChatRecordingModifier = exports.ToolManifestPromptModifier = exports.ToolGroupContextModifier = exports.ToolInjectionModifier = exports.LoopDetectionModifier = exports.MemoryImportModifier = exports.ArgumentProcessorModifier = exports.CapabilityContextModifier = 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; } });
@@ -22,12 +22,16 @@ var loopDetectionModifier_1 = require("../postInferenceProcessors/loopDetectionM
 Object.defineProperty(exports, "LoopDetectionModifier", { enumerable: true, get: function () { return loopDetectionModifier_1.LoopDetectionModifier; } });
 var toolInjectionModifier_1 = require("./toolInjectionModifier");
 Object.defineProperty(exports, "ToolInjectionModifier", { enumerable: true, get: function () { return toolInjectionModifier_1.ToolInjectionModifier; } });
+var toolGroupContextModifier_1 = require("./toolGroupContextModifier");
+Object.defineProperty(exports, "ToolGroupContextModifier", { enumerable: true, get: function () { return toolGroupContextModifier_1.ToolGroupContextModifier; } });
 var toolManifestPromptModifier_1 = require("./toolManifestPromptModifier");
 Object.defineProperty(exports, "ToolManifestPromptModifier", { enumerable: true, get: function () { return toolManifestPromptModifier_1.ToolManifestPromptModifier; } });
 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 agentEventQueueModifier_1 = require("./agentEventQueueModifier");
+Object.defineProperty(exports, "AgentEventQueueModifier", { enumerable: true, get: function () { return agentEventQueueModifier_1.AgentEventQueueModifier; } });
 var contextAssemblyModifier_1 = require("./contextAssemblyModifier");
 Object.defineProperty(exports, "ContextAssemblyModifier", { enumerable: true, get: function () { return contextAssemblyModifier_1.ContextAssemblyModifier; } });
 var contextAssemblyModifier_2 = require("./contextAssemblyModifier");

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

@@ -0,0 +1,27 @@
+import type { ProcessedMessage } from '@codebolt/types/agent';
+import type { FlatUserMessage } from '@codebolt/types/sdk';
+import type { RuntimeCatalogGroup, ToolSourceType } from '@codebolt/types/sdk';
+import { BaseMessageModifier } from '../base';
+export interface ToolGroupContextOptions {
+    location?: 'SystemMessage' | 'InsidePrompt';
+    groups?: RuntimeCatalogGroup[];
+    loadGroups?: () => Promise<RuntimeCatalogGroup[]>;
+    includeToolGroups?: boolean;
+    includeResourceGroups?: boolean;
+    includeCounts?: boolean;
+    includeSourceLabels?: boolean;
+    allowedGroupIds?: string[];
+    excludedGroupIds?: string[];
+    allowedSourceTypes?: ToolSourceType[];
+    maxGroups?: number;
+    maxCharacters?: number;
+}
+export declare class ToolGroupContextModifier extends BaseMessageModifier {
+    private readonly options;
+    constructor(options?: ToolGroupContextOptions);
+    modify(_originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private resolveGroups;
+    private loadRuntimeGroups;
+    private formatGroups;
+    private withMetadata;
+}

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

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolGroupContextModifier = void 0;
+const base_1 = require("../base");
+const promptContext_1 = require("../../unified/base/promptContext");
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+class ToolGroupContextModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.options = options;
+    }
+    async modify(_originalRequest, createdMessage) {
+        const groups = await this.resolveGroups();
+        if (groups.length === 0) {
+            return createdMessage;
+        }
+        const context = this.formatGroups(groups);
+        if (!context) {
+            return createdMessage;
+        }
+        if (this.options.location === 'InsidePrompt') {
+            const updatedMessage = (0, promptContext_1.updateCurrentUserMessage)(createdMessage, (message) => ({
+                ...message,
+                content: typeof message.content === 'string'
+                    ? `${message.content}\n\n${context}`
+                    : [
+                        ...(Array.isArray(message.content)
+                            ? message.content
+                            : [{ type: 'text', text: String(message.content) }]),
+                        { type: 'text', text: context },
+                    ],
+            }));
+            return this.withMetadata(updatedMessage, groups);
+        }
+        const groupMessage = { role: 'system', content: context };
+        return this.withMetadata((0, promptContext_1.appendSystemContextMessage)(createdMessage, groupMessage), groups);
+    }
+    async resolveGroups() {
+        const availableGroups = this.options.loadGroups
+            ? await this.options.loadGroups()
+            : this.options.groups || await this.loadRuntimeGroups();
+        const allowedIds = this.options.allowedGroupIds
+            ? new Set(this.options.allowedGroupIds)
+            : undefined;
+        const excludedIds = new Set(this.options.excludedGroupIds || []);
+        const allowedSourceTypes = this.options.allowedSourceTypes
+            ? new Set(this.options.allowedSourceTypes)
+            : undefined;
+        const filteredGroups = availableGroups
+            .filter((group) => this.options.includeToolGroups !== false || group.kind !== 'tool-group')
+            .filter((group) => this.options.includeResourceGroups !== false || group.kind !== 'resource-group')
+            .filter((group) => !allowedIds || allowedIds.has(group.id) || allowedIds.has(group.kind === 'tool-group' ? group.groupId : group.resourceType))
+            .filter((group) => !excludedIds.has(group.id))
+            .filter((group) => group.kind !== 'tool-group' || !allowedSourceTypes || allowedSourceTypes.has(group.sourceType))
+            .filter((group) => group.kind !== 'tool-group' || group.toolCount > 0)
+            .sort((left, right) => (right.priority || 0) - (left.priority || 0) ||
+            left.displayName.localeCompare(right.displayName));
+        return this.options.maxGroups === undefined
+            ? filteredGroups
+            : filteredGroups.slice(0, Math.max(0, this.options.maxGroups));
+    }
+    async loadRuntimeGroups() {
+        var _a;
+        const toolsApi = codeboltjs_1.default.tools;
+        if (!(toolsApi === null || toolsApi === void 0 ? void 0 : toolsApi.listToolGroups)) {
+            return [];
+        }
+        const response = await toolsApi.listToolGroups();
+        return Array.isArray((_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.groups) ? response.data.groups : [];
+    }
+    formatGroups(groups) {
+        const toolGroups = groups.filter((group) => group.kind === 'tool-group');
+        const resourceGroups = groups.filter((group) => group.kind === 'resource-group');
+        const sections = ['Available capabilities:'];
+        if (toolGroups.length > 0) {
+            sections.push('Tool groups:', ...toolGroups.map((group) => {
+                if (group.kind !== 'tool-group')
+                    return '';
+                const count = this.options.includeCounts === false ? '' : ` (${group.toolCount})`;
+                const source = this.options.includeSourceLabels ? ` [${group.sourceType}]` : '';
+                return `- ${group.displayName}${count}${source}: ${group.description}`;
+            }));
+        }
+        if (resourceGroups.length > 0) {
+            sections.push('Resource groups:', ...resourceGroups.map((group) => `- ${group.displayName}: ${group.description}`));
+        }
+        const content = sections.filter(Boolean).join('\n');
+        const maxCharacters = this.options.maxCharacters;
+        if (maxCharacters === undefined) {
+            return content;
+        }
+        return content.length <= maxCharacters
+            ? content
+            : `${content.slice(0, Math.max(0, maxCharacters - 1)).trimEnd()}…`;
+    }
+    withMetadata(message, groups) {
+        return {
+            ...message,
+            metadata: {
+                ...message.metadata,
+                toolGroupsInjected: true,
+                toolGroupCount: groups.length,
+                injectedToolGroupIds: groups.map((group) => group.id),
+            },
+        };
+    }
+}
+exports.ToolGroupContextModifier = ToolGroupContextModifier;

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

@@ -77,13 +77,11 @@ class ToolInjectionModifier extends base_1.BaseMessageModifier {
             role: 'system',
             content: `Available Tools:\n${toolsInfo}`
         };
+        const updatedMessage = (0, promptContext_1.appendSystemContextMessage)(createdMessage, toolsMessage);
         return {
-            message: {
-                ...createdMessage.message,
-                input: [toolsMessage, ...createdMessage.message.input]
-            },
+            ...updatedMessage,
             metadata: {
-                ...createdMessage.metadata,
+                ...updatedMessage.metadata,
                 toolsInjected: true,
                 toolsLocation: 'SystemMessage',
                 toolsCount: tools.length

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

@@ -0,0 +1,7 @@
+import type { PostToolCallProcessor, PostToolCallProcessorInput, PostToolCallProcessorOutput } from '@codebolt/types/agent';
+import { type AgentEventQueueProcessorOptions } from '../utils/agentEventQueuePrompt';
+export declare class AgentEventQueuePostToolCallProcessor implements PostToolCallProcessor {
+    private readonly options;
+    constructor(options?: AgentEventQueueProcessorOptions);
+    modify(input: PostToolCallProcessorInput): Promise<PostToolCallProcessorOutput>;
+}

package/dist/processor-pieces/postToolCallProcessors/agentEventQueuePostToolCallProcessor.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentEventQueuePostToolCallProcessor = void 0;
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const agentEventQueuePrompt_1 = require("../utils/agentEventQueuePrompt");
+class AgentEventQueuePostToolCallProcessor {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async modify(input) {
+        const pendingEvents = await codeboltjs_1.default.agentEventQueue.getPendingEvents();
+        return {
+            nextPrompt: (0, agentEventQueuePrompt_1.injectAgentQueueEventsIntoPrompt)(input.nextPrompt, pendingEvents, this.options),
+            shouldExit: false,
+        };
+    }
+}
+exports.AgentEventQueuePostToolCallProcessor = AgentEventQueuePostToolCallProcessor;

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

@@ -1,2 +1,3 @@
 export { ShellProcessorModifier } from './shellProcessorModifier';
+export { AgentEventQueuePostToolCallProcessor } from './agentEventQueuePostToolCallProcessor';
 export { ConversationCompactorModifier, type ConversationCompactorOptions, type CompressionMetadata, CompressionStatus } from './conversationCompactorModifier';

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

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompressionStatus = exports.ConversationCompactorModifier = exports.ShellProcessorModifier = void 0;
+exports.CompressionStatus = exports.ConversationCompactorModifier = exports.AgentEventQueuePostToolCallProcessor = exports.ShellProcessorModifier = void 0;
 var shellProcessorModifier_1 = require("./shellProcessorModifier");
 Object.defineProperty(exports, "ShellProcessorModifier", { enumerable: true, get: function () { return shellProcessorModifier_1.ShellProcessorModifier; } });
+var agentEventQueuePostToolCallProcessor_1 = require("./agentEventQueuePostToolCallProcessor");
+Object.defineProperty(exports, "AgentEventQueuePostToolCallProcessor", { enumerable: true, get: function () { return agentEventQueuePostToolCallProcessor_1.AgentEventQueuePostToolCallProcessor; } });
 var conversationCompactorModifier_1 = require("./conversationCompactorModifier");
 Object.defineProperty(exports, "ConversationCompactorModifier", { enumerable: true, get: function () { return conversationCompactorModifier_1.ConversationCompactorModifier; } });
 Object.defineProperty(exports, "CompressionStatus", { enumerable: true, get: function () { return conversationCompactorModifier_1.CompressionStatus; } });

package/dist/processor-pieces/utils/agentEventQueuePrompt.d.ts

@@ -0,0 +1,21 @@
+import type { ProcessedMessage } from '@codebolt/types/agent';
+import type { MessageObject } from '@codebolt/types/sdk';
+export interface AgentEventQueueProcessorOptions {
+    enableLogging?: boolean;
+}
+interface AgentEventMessageLike {
+    eventId?: string;
+    id?: string;
+    type?: string;
+    eventType?: string;
+    data?: Record<string, unknown>;
+    payload?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    target?: {
+        threadId?: string;
+    };
+    threadId?: string;
+}
+export declare function injectAgentQueueEventsIntoPrompt(prompt: ProcessedMessage, events: AgentEventMessageLike[], options?: AgentEventQueueProcessorOptions): ProcessedMessage;
+export declare function formatAgentQueueEventAsMessage(event: AgentEventMessageLike): MessageObject;
+export {};

package/dist/processor-pieces/utils/agentEventQueuePrompt.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectAgentQueueEventsIntoPrompt = injectAgentQueueEventsIntoPrompt;
+exports.formatAgentQueueEventAsMessage = formatAgentQueueEventAsMessage;
+const promptContext_1 = require("../../unified/base/promptContext");
+const FAILURE_STATUSES = new Set([
+    'failed',
+    'failure',
+    'error',
+    'errored',
+    'stopped',
+    'cancelled',
+    'canceled',
+    'crashed',
+    'timeout',
+    'timed_out',
+]);
+function injectAgentQueueEventsIntoPrompt(prompt, events, options = {}) {
+    if (options.enableLogging && events.length > 0) {
+        console.log(`[AgentEventQueue] injecting ${events.length} event(s)`);
+    }
+    return events.reduce((updatedPrompt, event) => (0, promptContext_1.appendTranscriptMessage)(updatedPrompt, formatAgentQueueEventAsMessage(event)), prompt);
+}
+function formatAgentQueueEventAsMessage(event) {
+    const eventType = event.type || event.eventType || 'unknown';
+    const eventData = event.data || event.payload || {};
+    switch (eventType) {
+        case 'steering':
+            return createUserMessage(`<steering_message>
+<instruction>${formatInstruction(eventData)}</instruction>
+<context>The user has sent a steering message while the agent is working. Review the instruction and adjust the current approach accordingly. Prioritize this instruction for the next actions.</context>
+</steering_message>`);
+        case 'threadCompletion':
+            return formatThreadCompletionEvent(eventData);
+        case 'backgroundCommandCompletion':
+            return formatBackgroundCommandCompletionEvent(eventData);
+        case 'forceStopCleanup':
+            return createUserMessage(`<force_stop_cleanup>
+${safeStringify(eventData)}
+</force_stop_cleanup>`);
+        case 'agentMessage':
+            return createUserMessage(`<agent_event>
+<source>${formatSource(event)}</source>
+<content>${formatContent(eventData)}</content>
+</agent_event>`);
+        case 'mailNotification':
+            return formatMailNotificationEvent(eventData);
+        case 'calendarUpdate':
+        case 'taskUpdate':
+        case 'systemNotification':
+        case 'custom':
+            return createUserMessage(`<agent_event>
+<type>${eventType}</type>
+<source>${formatSource(event)}</source>
+<content>${safeStringify(eventData)}</content>
+</agent_event>`);
+        default:
+            return createUserMessage(`<agent_event>
+<type>${eventType}</type>
+<source>${formatSource(event)}</source>
+<content>${safeStringify(eventData)}</content>
+<metadata>${safeStringify(event.metadata || {})}</metadata>
+</agent_event>`);
+    }
+}
+function formatThreadCompletionEvent(eventData) {
+    const failureReason = getEventFailureReason(eventData);
+    if (failureReason) {
+        return createUserMessage(`<thread_failure_event>
+<context>This is a Codebolt application event. A background child thread failed, stopped, or returned an error-shaped result. Treat this as a failed child task, report it to the parent workflow, and decide whether to retry, continue with remaining work, or stop based on the user's objective.</context>
+<reason>${failureReason}</reason>
+<event>${safeStringify(eventData)}</event>
+</thread_failure_event>`);
+    }
+    return createUserMessage(`<thread_completion_event>
+<context>This is an application event from Codebolt, not user text and not assistant output. Use it to update background-thread state. If this completes the current batch, continue with the next required work and use thread tools for any next batch.</context>
+<event>${safeStringify(eventData)}</event>
+</thread_completion_event>`);
+}
+function formatBackgroundCommandCompletionEvent(eventData) {
+    const failureReason = getEventFailureReason(eventData);
+    if (failureReason) {
+        return createUserMessage(`<background_command_failure_event>
+<context>This is a Codebolt application event. A background command failed, stopped, or returned an error-shaped result. Treat this as a failed background task and surface the error in the current workflow.</context>
+<reason>${failureReason}</reason>
+<event>${safeStringify(eventData)}</event>
+</background_command_failure_event>`);
+    }
+    return createUserMessage(`<background_command_completion_event>
+<context>This is an application event from Codebolt, not user text and not assistant output. Use it to update background-command state and continue the current task.</context>
+<event>${safeStringify(eventData)}</event>
+</background_command_completion_event>`);
+}
+function formatMailNotificationEvent(eventData) {
+    const messageId = String(eventData['messageId'] ||
+        getNestedValue(eventData, ['toolInput', 'messageId']) ||
+        'unknown');
+    const mailMessage = typeof eventData['message'] === 'string'
+        ? eventData['message']
+        : typeof eventData['body'] === 'string'
+            ? eventData['body']
+            : '';
+    const contentLines = [
+        `You have received a mail notification. To get the mail details, call the mail_get_message tool with parameter: { "messageId": "${messageId}" }. If mail_get_message is not in your available tools, use tool search to find it.`,
+    ];
+    if (mailMessage.trim()) {
+        contentLines.push('', 'Message:', mailMessage);
+    }
+    return createUserMessage(contentLines.join('\n'));
+}
+function createUserMessage(content) {
+    return {
+        role: 'user',
+        content,
+    };
+}
+function getEventFailureReason(eventData) {
+    if (eventData['error']) {
+        return typeof eventData['error'] === 'string'
+            ? eventData['error']
+            : safeStringify(eventData['error']);
+    }
+    const status = typeof eventData['status'] === 'string'
+        ? eventData['status'].toLowerCase()
+        : '';
+    if (FAILURE_STATUSES.has(status)) {
+        return `Event status is ${eventData['status']}`;
+    }
+    const messageObject = parseJsonObject(eventData['message']);
+    const outputObject = parseJsonObject(eventData['output']);
+    const nestedError = (messageObject === null || messageObject === void 0 ? void 0 : messageObject['error']) || (outputObject === null || outputObject === void 0 ? void 0 : outputObject['error']);
+    if (nestedError) {
+        return typeof nestedError === 'string'
+            ? nestedError
+            : safeStringify(nestedError);
+    }
+    const nestedStatus = String((messageObject === null || messageObject === void 0 ? void 0 : messageObject['status']) || (outputObject === null || outputObject === void 0 ? void 0 : outputObject['status']) || '').toLowerCase();
+    if (FAILURE_STATUSES.has(nestedStatus)) {
+        return `Nested result status is ${(messageObject === null || messageObject === void 0 ? void 0 : messageObject['status']) || (outputObject === null || outputObject === void 0 ? void 0 : outputObject['status'])}`;
+    }
+    return null;
+}
+function parseJsonObject(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function getNestedValue(source, path) {
+    let currentValue = source;
+    for (const segment of path) {
+        if (!currentValue || typeof currentValue !== 'object' || Array.isArray(currentValue)) {
+            return undefined;
+        }
+        currentValue = currentValue[segment];
+    }
+    return currentValue;
+}
+function formatInstruction(eventData) {
+    return typeof eventData['instruction'] === 'string'
+        ? eventData['instruction']
+        : safeStringify(eventData);
+}
+function formatSource(event) {
+    var _a, _b;
+    const source = ((_a = event.metadata) === null || _a === void 0 ? void 0 : _a['sourceAgentId']) || ((_b = event.metadata) === null || _b === void 0 ? void 0 : _b['source']);
+    return typeof source === 'string' && source.length > 0 ? source : 'system';
+}
+function formatContent(eventData) {
+    return typeof eventData['content'] === 'string'
+        ? eventData['content']
+        : safeStringify(eventData);
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch (error) {
+        return `[Unserializable event: ${error instanceof Error ? error.message : String(error)}]`;
+    }
+}

package/dist/types/automation.d.ts

@@ -0,0 +1,76 @@
+export type RecipientAddress = `subagent:${string}` | `threadagent:${string}` | `newagent:${string}`;
+export type RecipientKind = 'subagent' | 'threadagent' | 'newagent';
+export interface RecipientSnapshot {
+    agentId?: string;
+    agentInstanceId?: string;
+    threadId?: string;
+    agentName?: string;
+    threadName?: string;
+}
+export interface Recipient {
+    address: RecipientAddress;
+    label?: string;
+    snapshot?: RecipientSnapshot;
+}
+export interface RecipientOption extends Recipient {
+    kind: RecipientKind;
+    available: boolean;
+    description?: string;
+}
+export type AutomationRunStatus = 'running' | 'success' | 'failed' | 'skipped';
+export type AutomationActionType = 'notify' | 'sendMessage' | 'runAgent' | 'runActionBlock' | 'runCommand';
+export interface ScheduleDefinition {
+    type: 'once' | 'interval' | 'cron';
+    startAt?: string;
+    intervalMinutes?: number;
+    cronExpression?: string;
+    timezone?: string;
+    endAt?: string;
+}
+export type AutomationTrigger = {
+    type: 'manual';
+} | {
+    type: 'schedule';
+    schedule: ScheduleDefinition;
+} | {
+    type: 'event';
+    eventType: string;
+    filter?: Record<string, unknown>;
+};
+export interface AutomationAction {
+    type: AutomationActionType;
+    recipient?: Recipient;
+    payload: Record<string, unknown>;
+}
+export interface AutomationCalendarOptions {
+    show: boolean;
+    title?: string;
+    durationMinutes?: number;
+    color?: string;
+}
+export interface Automation {
+    id: string;
+    name: string;
+    description?: string;
+    enabled: boolean;
+    trigger: AutomationTrigger;
+    action: AutomationAction;
+    calendar?: AutomationCalendarOptions;
+    nextRunAt?: string;
+    lastRunAt?: string;
+    lastRunStatus?: Exclude<AutomationRunStatus, 'running'>;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface AutomationRun {
+    id: string;
+    automationId: string;
+    scheduledFor?: string;
+    startedAt: string;
+    completedAt?: string;
+    status: AutomationRunStatus;
+    recipient?: Recipient;
+    error?: string;
+    output?: unknown;
+    triggerContext?: Record<string, unknown>;
+}

package/dist/types/automation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -2,6 +2,12 @@ import { AgentConfig, AgentInterface, MessageModifier, PostInferenceProcessor, P
 import { FlatUserMessage } from "@codebolt/types/sdk";
 import { LoopDetectionService } from "../services/LoopDetectionService";
 import type { CompactionOrchestratorOptions } from "../services/compaction/types";
+import type { AgentEventQueueProcessorOptions } from "../../processor-pieces/utils/agentEventQueuePrompt";
+export interface AgentEventQueueOptions extends AgentEventQueueProcessorOptions {
+    enabled?: boolean;
+    injectOnMessage?: boolean;
+    injectAfterToolCall?: boolean;
+}
 export interface AgentOptions extends AgentConfig {
     context?: ProcessedMessage;
     allowedTools?: string[];
@@ -16,6 +22,7 @@ export interface AgentOptions extends AgentConfig {
     postInferenceProcessors?: PostInferenceProcessor[];
     preToolCallProcessors?: PreToolCallProcessor[];
     postToolCallProcessors?: PostToolCallProcessor[];
+    eventQueue?: boolean | AgentEventQueueOptions;
 }
 export interface AgentRunResult {
     success: boolean;
@@ -38,6 +45,7 @@ export interface AgentRunState {
 export interface AgentRunOptions {
     state?: AgentRunState;
     context?: ProcessedMessage;
+    contextoverride_id?: string;
 }
 export interface CreateAgentOptions extends AgentOptions {
     systemPrompt?: string;
@@ -60,6 +68,8 @@ export declare class Agent implements AgentInterface {
     private readonly localToolSchemas;
     private readonly localToolsByExecutionName;
     private readonly runtimeToolSetId;
+    private readonly localToolGroups;
+    private readonly localToolGroupAssignments;
     constructor(config: AgentOptions);
     run(message: string | FlatUserMessage, options?: ProcessedMessage | AgentRunOptions): Promise<AgentRunResult>;
     private registerRuntimeToolsForSearch;
@@ -67,16 +77,29 @@ export declare class Agent implements AgentInterface {
     processMessage(message: string | FlatUserMessage, options?: ProcessedMessage | AgentRunOptions): Promise<AgentRunResult>;
     execute(reqMessage: FlatUserMessage): Promise<{
         success: boolean;
-        result: any;
+        result: unknown;
         error?: string;
     }>;
+    start(): void;
     getConfig(): AgentOptions;
     getMessageModifiers(): MessageModifier[];
     getPreInferenceProcessors(): PreInferenceProcessor[];
     getPostInferenceProcessors(): PostInferenceProcessor[];
     getPreToolCallProcessors(): PreToolCallProcessor[];
     getPostToolCallProcessors(): PostToolCallProcessor[];
-    private resolveRunContext;
+    private resolveExplicitRunContext;
+    private resolveContextOverride;
+    private getContextOverrideId;
+    private savedContextToProcessedMessage;
+    private extractSavedContextMessages;
+    private extractSavedCompactedMessages;
+    private extractLatestSavedLlmRequestMessages;
+    private normalizeSavedLlmInputItem;
+    private previewItemToMessage;
+    private isSavedContextInputMessage;
+    private createSavedContextBoundaryMessage;
+    private formatSavedContextForPrompt;
+    private stringifyForPrompt;
     private getResumeMessageModifiers;
     private normalizeLLMRole;
     private isProcessedMessage;

package/dist/unified/agent/agent.js

@@ -45,7 +45,8 @@ function createDefaultMessageModifiers(systemPrompt, allowedTools) {
             enableChatHistory: true,
             includeSystemMessages: false,
         }),
-        new processor_pieces_1.EnvironmentContextModifier({ enableFullContext: true }),
+        new processor_pieces_1.CapabilityContextModifier(),
+        new processor_pieces_1.EnvironmentContextModifier({ enableFullContext: false }),
         new processor_pieces_1.DirectoryContextModifier(),
         new processor_pieces_1.IdeContextModifier({
             includeActiveFile: true,
@@ -58,6 +59,7 @@ function createDefaultMessageModifiers(systemPrompt, allowedTools) {
             includeToolDescriptions: true,
             ...(allowedTools ? { allowedTools } : {})
         }),
+        new processor_pieces_1.ToolGroupContextModifier(),
         new processor_pieces_1.AtFileProcessorModifier({ enableRecursiveSearch: true })
     ];
 }
@@ -73,6 +75,24 @@ function createDefaultPreToolCallProcessors() {
 function createDefaultPostToolCallProcessors() {
     return [];
 }
+function normalizeAgentEventQueueOptions(eventQueue, enableLogging) {
+    var _a, _b, _c, _d;
+    if (typeof eventQueue === 'boolean') {
+        return {
+            enabled: eventQueue,
+            injectOnMessage: eventQueue,
+            injectAfterToolCall: eventQueue,
+            enableLogging,
+        };
+    }
+    const enabled = (_a = eventQueue === null || eventQueue === void 0 ? void 0 : eventQueue.enabled) !== null && _a !== void 0 ? _a : true;
+    return {
+        enabled,
+        injectOnMessage: (_b = eventQueue === null || eventQueue === void 0 ? void 0 : eventQueue.injectOnMessage) !== null && _b !== void 0 ? _b : enabled,
+        injectAfterToolCall: (_c = eventQueue === null || eventQueue === void 0 ? void 0 : eventQueue.injectAfterToolCall) !== null && _c !== void 0 ? _c : enabled,
+        enableLogging: (_d = eventQueue === null || eventQueue === void 0 ? void 0 : eventQueue.enableLogging) !== null && _d !== void 0 ? _d : enableLogging,
+    };
+}
 function createDefaultUserMessage(message) {
     const timestamp = Date.now();
     return {
@@ -104,41 +124,66 @@ class Agent {
         const localToolRegistry = (0, agentToolLoader_1.createAgentLocalToolRegistry)(config.tools || []);
         const includeDefaultModifiers = (_b = (_a = config.includeDefaultModifiers) !== null && _a !== void 0 ? _a : config.defaultProcessors) !== null && _b !== void 0 ? _b : true;
         const includeDefaultProcessors = (_d = (_c = config.includeDefaultProcessors) !== null && _c !== void 0 ? _c : config.defaultProcessors) !== null && _d !== void 0 ? _d : true;
+        const enableLogging = config.enableLogging !== false;
+        const eventQueueOptions = normalizeAgentEventQueueOptions(config.eventQueue, enableLogging);
         const customMessageModifiers = collectProcessors((_e = config.processors) === null || _e === void 0 ? void 0 : _e.messageModifiers, config.messageModifiers);
         const defaultMessageModifiers = includeDefaultModifiers
             ? createDefaultMessageModifiers(config.instructions || DEFAULT_SYSTEM_PROMPT, config.allowedTools)
             : [];
         this.config = { ...config };
-        this.enableLogging = config.enableLogging !== false;
+        this.enableLogging = enableLogging;
         this.baseSystemPrompt = config.instructions || DEFAULT_SYSTEM_PROMPT;
         this.context = config.context;
         this.allowedTools = config.allowedTools;
         this.llmRole = this.normalizeLLMRole(config.llmRole);
-        this.messageModifiers = mergeProcessors(defaultMessageModifiers, customMessageModifiers);
+        this.messageModifiers = mergeProcessors(defaultMessageModifiers, [
+            ...customMessageModifiers,
+            ...(eventQueueOptions.enabled && eventQueueOptions.injectOnMessage
+                ? [new processor_pieces_1.AgentEventQueueModifier(eventQueueOptions)]
+                : []),
+        ]);
         this.preInferenceProcessors = mergeProcessors(includeDefaultProcessors ? createDefaultPreInferenceProcessors() : [], collectProcessors((_f = config.processors) === null || _f === void 0 ? void 0 : _f.preInferenceProcessors, config.preInferenceProcessors));
         this.postInferenceProcessors = mergeProcessors(includeDefaultProcessors ? createDefaultPostInferenceProcessors() : [], collectProcessors((_g = config.processors) === null || _g === void 0 ? void 0 : _g.postInferenceProcessors, config.postInferenceProcessors));
         this.preToolCallProcessors = mergeProcessors(includeDefaultProcessors ? createDefaultPreToolCallProcessors() : [], collectProcessors((_h = config.processors) === null || _h === void 0 ? void 0 : _h.preToolCallProcessors, config.preToolCallProcessors));
-        this.postToolCallProcessors = mergeProcessors(includeDefaultProcessors ? createDefaultPostToolCallProcessors() : [], collectProcessors((_j = config.processors) === null || _j === void 0 ? void 0 : _j.postToolCallProcessors, config.postToolCallProcessors));
+        const customPostToolCallProcessors = collectProcessors((_j = config.processors) === null || _j === void 0 ? void 0 : _j.postToolCallProcessors, config.postToolCallProcessors);
+        this.postToolCallProcessors = mergeProcessors(includeDefaultProcessors ? createDefaultPostToolCallProcessors() : [], [
+            ...customPostToolCallProcessors,
+            ...(eventQueueOptions.enabled && eventQueueOptions.injectAfterToolCall
+                ? [new processor_pieces_1.AgentEventQueuePostToolCallProcessor(eventQueueOptions)]
+                : []),
+        ]);
         const compactionLLMRole = (_l = this.normalizeLLMRole((_k = config.compaction) === null || _k === void 0 ? void 0 : _k.llmRole)) !== null && _l !== void 0 ? _l : this.llmRole;
         this.compactionOrchestrator = new compactionOrchestrator_1.CompactionOrchestrator({
             ...config.compaction,
             ...(compactionLLMRole ? { llmRole: compactionLLMRole } : {}),
         });
         this.loopDetectionService = config.loopDetectionService;
-        this.maxTurns = (_o = (_m = config.maxTurns) !== null && _m !== void 0 ? _m : config.maxIterations) !== null && _o !== void 0 ? _o : 25;
+        this.maxTurns = (_o = (_m = config.maxTurns) !== null && _m !== void 0 ? _m : config.maxIterations) !== null && _o !== void 0 ? _o : 0;
         this.localToolSchemas = localToolRegistry.schemas;
         this.localToolsByExecutionName = localToolRegistry.byExecutionName;
+        this.localToolGroups = config.toolGroups;
+        this.localToolGroupAssignments = Object.fromEntries((config.tools || []).flatMap((tool) => {
+            var _a;
+            if (!tool.groupId)
+                return [];
+            const toolName = (_a = tool.toOpenAITool().function) === null || _a === void 0 ? void 0 : _a.name;
+            return toolName ? [[toolName, tool.groupId]] : [];
+        }));
         this.runtimeToolSetId = `agent-${(0, crypto_1.randomUUID)()}`;
     }
     async run(message, options) {
-        var _a, _b;
+        var _a, _b, _c;
         try {
             await this.registerRuntimeToolsForSearch();
             const reqMessage = typeof message === 'string'
                 ? createDefaultUserMessage(message)
                 : message;
             let prompt;
-            const contextToUse = this.resolveRunContext(options);
+            const explicitContext = this.resolveExplicitRunContext(options);
+            const contextOverride = explicitContext
+                ? undefined
+                : await this.resolveContextOverride(reqMessage, options);
+            const contextToUse = (_a = explicitContext !== null && explicitContext !== void 0 ? explicitContext : contextOverride) !== null && _a !== void 0 ? _a : this.context;
             if (contextToUse) {
                 const promptGenerator = new base_1.InitialPromptGenerator({
                     processors: this.getResumeMessageModifiers(),
@@ -162,7 +207,7 @@ class Agent {
             const toolResults = [];
             while (!completed) {
                 turnNumber += 1;
-                if (turnNumber > this.maxTurns) {
+                if (this.maxTurns > 0 && turnNumber > this.maxTurns) {
                     throw new Error(`Agent exceeded the maximum turn limit of ${this.maxTurns}.`);
                 }
                 this.compactionOrchestrator.resetForTurn();
@@ -177,7 +222,7 @@ class Agent {
                 while (!stepResult) {
                     try {
                         const nextStepResult = await agentStep.executeStep(reqMessage, prompt);
-                        this.compactionOrchestrator.updateModelTokenLimit((_a = nextStepResult.rawLLMResponse) === null || _a === void 0 ? void 0 : _a.tokenLimit);
+                        this.compactionOrchestrator.updateModelTokenLimit((_b = nextStepResult.rawLLMResponse) === null || _b === void 0 ? void 0 : _b.tokenLimit);
                         const recoverableResponseError = this.getRecoverableResponseError(nextStepResult.rawLLMResponse);
                         if (!recoverableResponseError) {
                             stepResult = nextStepResult;
@@ -217,7 +262,7 @@ class Agent {
                 completed = executionResult.completed;
                 prompt = executionResult.nextMessage;
                 finalMessage = executionResult.finalMessage;
-                toolResults.push(...((_b = executionResult.toolResults) !== null && _b !== void 0 ? _b : []));
+                toolResults.push(...((_c = executionResult.toolResults) !== null && _c !== void 0 ? _c : []));
             }
             const state = { prompt };
             return {
@@ -253,7 +298,13 @@ class Agent {
             return;
         }
         try {
-            await ((_b = (_a = codeboltjs_1.default.searchableAssets) === null || _a === void 0 ? void 0 : _a.registerRuntimeTools) === null || _b === void 0 ? void 0 : _b.call(_a, this.runtimeToolSetId, this.localToolSchemas));
+            await ((_b = (_a = codeboltjs_1.default.searchableAssets) === null || _a === void 0 ? void 0 : _a.registerRuntimeTools) === null || _b === void 0 ? void 0 : _b.call(_a, this.runtimeToolSetId, this.localToolSchemas, {
+                displayName: this.config.name || 'Current Agent Tools',
+                description: `Custom tools available to ${this.config.name || 'the current agent'}.`,
+                sourceType: 'agent-local',
+                groups: this.localToolGroups,
+                toolGroupAssignments: this.localToolGroupAssignments,
+            }));
         }
         catch (error) {
             if (this.enableLogging) {
@@ -281,6 +332,34 @@ class Agent {
     async execute(reqMessage) {
         return this.run(reqMessage);
     }
+    start() {
+        codeboltjs_1.default.onMessage(async (reqMessage) => {
+            var _a, _b;
+            if (this.enableLogging) {
+                console.log(`[Agent] Started message ${(_a = reqMessage.messageId) !== null && _a !== void 0 ? _a : 'unknown'}`);
+            }
+            try {
+                const executionResult = await this.processMessage(reqMessage);
+                if (!executionResult.success) {
+                    return JSON.stringify({
+                        error: executionResult.error || 'Agent failed to process the message.',
+                    });
+                }
+                if (this.enableLogging) {
+                    console.log(`[Agent] Finished message ${(_b = reqMessage.messageId) !== null && _b !== void 0 ? _b : 'unknown'}`);
+                }
+                return executionResult.finalMessage;
+            }
+            catch (error) {
+                if (this.enableLogging) {
+                    console.error('[Agent] Message handler failed:', error);
+                }
+                return JSON.stringify({
+                    error: error instanceof Error ? error.message : 'Unknown agent message handler error',
+                });
+            }
+        });
+    }
     getConfig() {
         return { ...this.config };
     }
@@ -299,15 +378,225 @@ class Agent {
     getPostToolCallProcessors() {
         return [...this.postToolCallProcessors];
     }
-    resolveRunContext(options) {
-        var _a, _b, _c;
+    resolveExplicitRunContext(options) {
+        var _a, _b;
         if (!options) {
-            return this.context;
+            return undefined;
         }
         if (this.isProcessedMessage(options)) {
             return options;
         }
-        return (_c = (_b = (_a = options.state) === null || _a === void 0 ? void 0 : _a.prompt) !== null && _b !== void 0 ? _b : options.context) !== null && _c !== void 0 ? _c : this.context;
+        return (_b = (_a = options.state) === null || _a === void 0 ? void 0 : _a.prompt) !== null && _b !== void 0 ? _b : options.context;
+    }
+    async resolveContextOverride(reqMessage, options) {
+        const contextId = this.getContextOverrideId(reqMessage, options);
+        if (!contextId) {
+            return undefined;
+        }
+        if (!/^id_[A-Za-z0-9_-]+$/.test(contextId)) {
+            throw new Error(`Invalid contextoverride_id: ${contextId}`);
+        }
+        const getSavedThreadContext = codeboltjs_1.default.thread.getSavedThreadContext;
+        if (!getSavedThreadContext) {
+            throw new Error('Saved context getter is not available in the CodeBolt thread client');
+        }
+        const response = await getSavedThreadContext({ contextId });
+        if ((response === null || response === void 0 ? void 0 : response.success) === false || !(response === null || response === void 0 ? void 0 : response.savedContext)) {
+            throw new Error((response === null || response === void 0 ? void 0 : response.error) || `Saved context not found: ${contextId}`);
+        }
+        return this.savedContextToProcessedMessage(response.savedContext, contextId, reqMessage.threadId);
+    }
+    getContextOverrideId(reqMessage, options) {
+        const optionValue = options && !this.isProcessedMessage(options)
+            ? options.contextoverride_id
+            : undefined;
+        const messageValue = reqMessage.contextoverride_id;
+        const envValue = process.env['contextoverride_id'] || process.env['CONTEXTOVERRIDE_ID'];
+        const value = optionValue || messageValue || envValue;
+        return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+    }
+    savedContextToProcessedMessage(savedContext, contextId, targetThreadId) {
+        const runningContext = (savedContext === null || savedContext === void 0 ? void 0 : savedContext.runningContext) || {};
+        const savedMessages = this.extractSavedContextMessages(runningContext);
+        const input = savedMessages.length > 0
+            ? [
+                ...savedMessages,
+                this.createSavedContextBoundaryMessage(savedContext),
+            ]
+            : [
+                {
+                    role: 'user',
+                    content: this.formatSavedContextForPrompt(savedContext),
+                },
+            ];
+        return {
+            message: {
+                formatVersion: 'codebolt.llm.v2',
+                input,
+                tools: [],
+            },
+            metadata: {
+                timestamp: new Date().toISOString(),
+                threadId: targetThreadId,
+                contextoverride_id: contextId,
+                savedContextId: contextId,
+                savedContextSourceThreadId: savedContext === null || savedContext === void 0 ? void 0 : savedContext.sourceThreadId,
+                savedContextCreatedAt: savedContext === null || savedContext === void 0 ? void 0 : savedContext.createdAt,
+            },
+        };
+    }
+    extractSavedContextMessages(runningContext) {
+        const fullLlmRequestMessages = this.extractLatestSavedLlmRequestMessages(runningContext === null || runningContext === void 0 ? void 0 : runningContext.messages, {
+            requireFullInput: true,
+        });
+        if (fullLlmRequestMessages.length > 0) {
+            return fullLlmRequestMessages;
+        }
+        const compactedMessages = this.extractSavedCompactedMessages(runningContext === null || runningContext === void 0 ? void 0 : runningContext.compactedContext);
+        if (compactedMessages.length > 0) {
+            return compactedMessages;
+        }
+        return this.extractLatestSavedLlmRequestMessages(runningContext === null || runningContext === void 0 ? void 0 : runningContext.messages, {
+            requireFullInput: false,
+        });
+    }
+    extractSavedCompactedMessages(compactedContext) {
+        var _a;
+        const data = typeof compactedContext === 'object' && compactedContext !== null
+            ? compactedContext.data
+            : undefined;
+        const messages = typeof data === 'object' && data !== null
+            ? ((_a = data.input) !== null && _a !== void 0 ? _a : data.messages)
+            : undefined;
+        if (!Array.isArray(messages)) {
+            return [];
+        }
+        return messages
+            .filter((message) => this.isServerCompactedMessage(message))
+            .map((message) => ({ ...message }));
+    }
+    extractLatestSavedLlmRequestMessages(messages, options) {
+        if (!Array.isArray(messages)) {
+            return [];
+        }
+        const latestRequest = [...messages]
+            .reverse()
+            .find((message) => (message === null || message === void 0 ? void 0 : message.type) === 'llm_request');
+        if (!latestRequest || typeof latestRequest !== 'object') {
+            return [];
+        }
+        const request = latestRequest;
+        const fullInput = Array.isArray(request.input)
+            ? request.input
+            : Array.isArray(request.messages)
+                ? request.messages
+                : undefined;
+        if (options.requireFullInput && !fullInput) {
+            return [];
+        }
+        const sourceMessages = fullInput
+            ? fullInput.map((message) => this.normalizeSavedLlmInputItem(message))
+            : Array.isArray(request.inputPreviewItems)
+                ? request.inputPreviewItems.map((item) => this.previewItemToMessage(item))
+                : [];
+        return sourceMessages
+            .filter((message) => !!message && this.isSavedContextInputMessage(message))
+            .filter((message) => !(0, promptContext_1.isGeneratedUserContextMessage)(message))
+            .map((message) => ({ ...message }));
+    }
+    normalizeSavedLlmInputItem(item) {
+        if (!item || typeof item !== 'object') {
+            return null;
+        }
+        return { ...item };
+    }
+    previewItemToMessage(item) {
+        if (!item || typeof item !== 'object') {
+            return null;
+        }
+        const preview = item;
+        const type = typeof preview.type === 'string' ? preview.type : undefined;
+        const role = typeof preview.role === 'string' ? preview.role : undefined;
+        const content = typeof preview.contentPreview === 'string' ? preview.contentPreview : undefined;
+        const callId = typeof preview.call_id === 'string'
+            ? preview.call_id
+            : typeof preview.id === 'string'
+                ? preview.id
+                : undefined;
+        if (type === 'function_call') {
+            return {
+                type,
+                name: typeof preview.name === 'string' ? preview.name : undefined,
+                call_id: callId,
+                arguments: content || '',
+            };
+        }
+        if (type === 'function_call_output' || type === 'tool_search_output') {
+            return {
+                type,
+                call_id: callId,
+                output: content || '',
+                status: 'completed',
+            };
+        }
+        if (role && content !== undefined) {
+            return {
+                ...(type ? { type } : {}),
+                role,
+                content,
+            };
+        }
+        if (type && content !== undefined) {
+            return {
+                type,
+                call_id: callId,
+                output: content,
+            };
+        }
+        return null;
+    }
+    isSavedContextInputMessage(message) {
+        if (typeof message.role === 'string' && message.content !== undefined) {
+            return true;
+        }
+        return typeof message.type === 'string' && (message.type === 'function_call' ||
+            message.type === 'function_call_output' ||
+            message.type === 'tool_search_output');
+    }
+    createSavedContextBoundaryMessage(savedContext) {
+        const contextId = (savedContext === null || savedContext === void 0 ? void 0 : savedContext.id) || '';
+        const sourceThreadId = (savedContext === null || savedContext === void 0 ? void 0 : savedContext.sourceThreadId) || '';
+        return {
+            role: 'user',
+            content: [
+                `--- End of saved context ${contextId} ---`,
+                '',
+                `The above messages were loaded from saved context ${contextId}${sourceThreadId ? ` for source thread ${sourceThreadId}` : ''}.`,
+                'Some entries may be reconstructed from saved LLM request previews if full input messages were not available.',
+                'Continue from that context and respond to the current user message.',
+            ].join('\n'),
+        };
+    }
+    formatSavedContextForPrompt(savedContext) {
+        var _a;
+        const runningContext = (savedContext === null || savedContext === void 0 ? void 0 : savedContext.runningContext) || {};
+        const parts = [
+            `<saved-context id="${(savedContext === null || savedContext === void 0 ? void 0 : savedContext.id) || ''}" sourceThreadId="${(savedContext === null || savedContext === void 0 ? void 0 : savedContext.sourceThreadId) || ''}">`,
+            (savedContext === null || savedContext === void 0 ? void 0 : savedContext.title) ? `Title: ${savedContext.title}` : '',
+            (runningContext === null || runningContext === void 0 ? void 0 : runningContext.summary) ? `Summary:\n${runningContext.summary}` : '',
+            ((_a = runningContext === null || runningContext === void 0 ? void 0 : runningContext.compactedContext) === null || _a === void 0 ? void 0 : _a.content) ? `Compacted Context:\n${runningContext.compactedContext.content}` : '',
+            `Running Context Messages:\n${this.stringifyForPrompt(Array.isArray(runningContext === null || runningContext === void 0 ? void 0 : runningContext.messages) ? runningContext.messages.slice(-20) : [])}`,
+            '</saved-context>',
+        ].filter(Boolean);
+        return parts.join('\n\n');
+    }
+    stringifyForPrompt(value) {
+        try {
+            return JSON.stringify(value, null, 2);
+        }
+        catch {
+            return String(value);
+        }
     }
     getResumeMessageModifiers() {
         return this.messageModifiers.filter((modifier) => { var _a; return ((_a = modifier.constructor) === null || _a === void 0 ? void 0 : _a.name) !== 'ChatHistoryMessageModifier'; });

package/dist/unified/base/agentStep.js

@@ -67,7 +67,7 @@ class AgentStep {
     }
     async generateResponse(messageForLLM) {
         var _a, _b, _c, _d, _e;
-        console.log('[AgentStep] llm.inference payload:', messageForLLM);
+        //   console.log('[AgentStep] llm.inference payload:', messageForLLM);
         const response = await codeboltjs_1.default.llm.inference(messageForLLM);
         const completion = this.extractCompletion(response);
         if (!completion) {

package/dist/unified/base/promptContext.js

@@ -34,6 +34,20 @@ function cloneMessage(message) {
 function cloneMessages(messages) {
     return messages.map((message) => cloneMessage(message));
 }
+function legacyPromptMessages(prompt) {
+    const messages = prompt.message.messages;
+    if (!Array.isArray(messages)) {
+        return [];
+    }
+    return cloneMessages(messages.filter((message) => (!!message &&
+        typeof message === 'object' &&
+        typeof message.role === 'string' &&
+        Object.prototype.hasOwnProperty.call(message, 'content'))));
+}
+function stripChatStyleFields(message) {
+    const { messages: _messages, functions: _functions, max_tokens: _maxTokens, choices: _choices, tool_calls: _toolCalls, ...rest } = message;
+    return rest;
+}
 function textFromContent(content) {
     if (typeof content === 'string') {
         return content;
@@ -155,7 +169,10 @@ function flattenRuntimeMessages(runtimeContext) {
 }
 function inferRuntimeContext(prompt) {
     var _a;
-    const messages = (_a = prompt.message.input) !== null && _a !== void 0 ? _a : [];
+    const messages = [
+        ...((_a = prompt.message.input) !== null && _a !== void 0 ? _a : []),
+        ...legacyPromptMessages(prompt),
+    ];
     const systemMessages = messages.filter((message) => message.role === 'system');
     const transcriptMessages = messages.filter((message) => message.role !== 'system' && !isGeneratedUserContextMessage(message));
     let systemPrompt;
@@ -204,10 +221,11 @@ function ensureRuntimePromptContext(prompt) {
     return (_a = getRuntimePromptContext(prompt)) !== null && _a !== void 0 ? _a : inferRuntimeContext(prompt);
 }
 function withRuntimePromptContext(prompt, runtimeContext) {
+    const baseMessage = stripChatStyleFields(prompt.message);
     return {
         ...prompt,
         message: {
-            ...prompt.message,
+            ...baseMessage,
             formatVersion: 'codebolt.llm.v2',
             input: flattenRuntimeMessages(runtimeContext),
         },
@@ -240,6 +258,7 @@ function reconcileRuntimePromptContext(prompt) {
         runtimeContext.userContextMessages.length;
     const normalizedTranscriptStartIndex = Math.min(transcriptStartIndex, flattenedMessages.length);
     const candidateTranscriptMessages = cloneMessages(flattenedMessages.slice(normalizedTranscriptStartIndex));
+    candidateTranscriptMessages.push(...legacyPromptMessages(prompt));
     const possibleCurrentUserContextMessageIndex = runtimeContext.currentUserMessageIndex;
     const possibleCurrentUserContextMessage = possibleCurrentUserContextMessageIndex === undefined
         ? undefined
@@ -383,8 +402,9 @@ function updateCurrentUserMessage(prompt, update) {
 }
 function buildInferenceParams(prompt) {
     const runtimeContext = ensureRuntimePromptContext(prompt);
+    const baseMessage = stripChatStyleFields(prompt.message);
     return {
-        ...prompt.message,
+        ...baseMessage,
         formatVersion: 'codebolt.llm.v2',
         input: flattenRuntimeMessages(runtimeContext),
     };

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

@@ -25,7 +25,7 @@ export declare class ResponseExecutor implements AgentResponseExecutor {
     private isMessageObject;
     private getMessagesAddedAfterInference;
     private executeTools;
-    private sendFinalMessageToChat;
+    private sendAssistantMessageToChat;
     private getPendingAsyncTasks;
     private extractCompletionMessage;
     private formatCompletionValue;

package/dist/unified/base/responseExecutor.js

@@ -347,7 +347,7 @@ class ResponseExecutor {
         const lastMessageContent = this.extractLastMessageContent(llmResponse);
         const toolCalls = this.getToolCalls(llmResponse);
         if (toolCalls.length === 0) {
-            await this.sendFinalMessageToChat(lastMessageContent);
+            await this.sendAssistantMessageToChat(lastMessageContent);
             return {
                 toolResults: [],
                 followUpMessages: [],
@@ -359,6 +359,9 @@ class ResponseExecutor {
         const parsedToolCalls = toolCalls.map((tool) => this.parseToolCall(tool));
         const completionToolCalls = parsedToolCalls.filter((toolCall) => toolCall.toolName.includes('attempt_completion'));
         const executionToolCalls = parsedToolCalls.filter((toolCall) => !toolCall.toolName.includes('attempt_completion'));
+        if (executionToolCalls.length > 0) {
+            await this.sendAssistantMessageToChat(lastMessageContent);
+        }
         if (this.loopDetectionService) {
             for (const toolCall of executionToolCalls) {
                 const loopDetected = this.loopDetectionService.checkToolCallLoop(toolCall.toolName, toolCall.toolInput);
@@ -398,7 +401,7 @@ class ResponseExecutor {
                 const completionArguments = completionToolCall.toolInput;
                 const [, completionResult] = await this.executeTool(completionToolCall.toolName, completionArguments, input);
                 this.finalMessage = (_a = this.extractCompletionMessage(completionArguments)) !== null && _a !== void 0 ? _a : lastMessageContent;
-                await this.sendFinalMessageToChat(this.finalMessage);
+                await this.sendAssistantMessageToChat(this.finalMessage);
                 const parsedCompletionResult = this.parseToolResult(completionToolCall.toolUseId, completionResult === '' ? 'The user is satisfied with the result.' : completionResult);
                 toolResults.push(parsedCompletionResult);
             }
@@ -411,7 +414,7 @@ class ResponseExecutor {
             hadToolCalls: true,
         };
     }
-    async sendFinalMessageToChat(message) {
+    async sendAssistantMessageToChat(message) {
         if (!message || message.trim().length === 0) {
             return;
         }
@@ -419,7 +422,7 @@ class ResponseExecutor {
             await Promise.resolve(codeboltjs_1.default.chat.sendMessage(message));
         }
         catch (error) {
-            console.error('[ResponseExecutor] Failed to send final chat message:', error);
+            console.error('[ResponseExecutor] Failed to send assistant chat message:', error);
         }
     }
     async getPendingAsyncTasks() {
@@ -496,7 +499,7 @@ class ResponseExecutor {
                 resultTuple = [false, 'tool result is successful'];
             }
             else {
-                resultTuple = await this.executeTool(toolCall.toolName, toolCall.toolInput, input);
+                resultTuple = await this.executeTool(toolCall.toolName, toolCall.toolInput, input, toolCall.toolUseId);
             }
             const [didUserReject, result] = resultTuple;
             const parsedResult = this.parseToolResult(toolCall.toolUseId, result);
@@ -521,11 +524,18 @@ class ResponseExecutor {
             };
         }
     }
-    async executeTool(toolName, toolInput, input) {
+    async executeTool(toolName, toolInput, input, toolUseId) {
         var _a, _b;
         const executionToolName = (0, agentToolLoader_1.resolveToolExecutionName)(toolName);
         const localTool = this.localToolsByExecutionName.get(executionToolName);
         if (localTool) {
+            const localToolUseId = toolUseId || `${executionToolName}-${Date.now()}`;
+            codeboltjs_1.default.chat.sendLocalToolExecutionUpdate({
+                toolUseId: localToolUseId,
+                toolName: executionToolName,
+                params: toolInput,
+                state: 'EXECUTING',
+            });
             const localResult = await localTool.execute(toolInput, {
                 initialUserMessage: input.initialUserMessage,
                 llmMessageSent: input.actualMessageSentToLLM,
@@ -533,6 +543,13 @@ class ResponseExecutor {
                 nextMessage: input.nextMessage,
                 toolName: executionToolName,
             });
+            codeboltjs_1.default.chat.sendLocalToolExecutionUpdate({
+                toolUseId: localToolUseId,
+                toolName: executionToolName,
+                params: toolInput,
+                state: localResult.success ? 'EXECUTION_SUCCESS' : 'EXECUTION_ERROR',
+                result: localResult.success ? localResult.result : localResult.error,
+            });
             if (!localResult.success) {
                 return [false, localResult.error || `Local tool "${executionToolName}" failed.`];
             }
@@ -540,7 +557,7 @@ class ResponseExecutor {
         }
         const toolGateway = codeboltjs_1.default.tools;
         if (typeof (toolGateway === null || toolGateway === void 0 ? void 0 : toolGateway.execute) === 'function') {
-            const response = await toolGateway.execute(executionToolName, toolInput);
+            const response = await toolGateway.execute(executionToolName, toolInput, toolUseId ? { toolUseId } : {});
             const data = (_b = response.data) !== null && _b !== void 0 ? _b : response.result;
             if (Array.isArray(data) && data.length >= 2) {
                 const [didUserReject, content] = data;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebolt/agent",
-  "version": "6.1.23",
+  "version": "6.1.26",
   "description": "CodeBolt Agent utilities for building and managing AI agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,7 +13,7 @@
     "build": "tsc",
     "clean": "rm -rf dist",
     "dev": "tsc --watch",
-    "test": "echo \"No tests yet, but build passes\" && exit 0",
+    "test": "npm run build && node --test tests/*.test.js",
     "lint": "eslint src/**/*.ts && tsc --noEmit",
     "lint:test": "npm run lint",
     "docs": "node script/gen-docusaurus-agent-types.js",