@codebolt/agent 6.0.0 → 6.1.2

package/dist/unified/base/responseExecutor.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResponseExecutor = void 0;
 const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const promptContext_1 = require("./promptContext");
 class ResponseExecutor {
     constructor(options) {
         this.preToolCallProcessors = [];
@@ -13,340 +14,301 @@ class ResponseExecutor {
         this.finalMessage = undefined;
         this.preToolCallProcessors = options.preToolCallProcessors;
         this.postToolCallProcessors = options.postToolCallProcessors;
-        if (options.loopDetectionService) {
-            this.loopDetectionService = options.loopDetectionService;
-        }
+        this.loopDetectionService = options.loopDetectionService;
     }
     async executeResponse(input) {
-        var _a, _b;
-        let nextMessage = input.nextMessage;
+        var _a, _b, _c;
+        this.completed = false;
+        this.finalMessage = undefined;
+        let nextMessage = (0, promptContext_1.reconcileRuntimePromptContext)(input.nextMessage);
         for (const preToolCallProcessor of this.preToolCallProcessors) {
             try {
-                // TODO: Extract required properties from input for PreToolCallProcessorInput
-                let { nextPrompt, shouldExit } = await preToolCallProcessor.modify({ llmMessageSent: input.actualMessageSentToLLM, rawLLMResponseMessage: input.rawLLMOutput, nextPrompt: input.nextMessage });
-                nextMessage = nextPrompt;
+                const { nextPrompt, shouldExit } = await preToolCallProcessor.modify({
+                    llmMessageSent: input.actualMessageSentToLLM,
+                    rawLLMResponseMessage: input.rawLLMOutput,
+                    nextPrompt: nextMessage,
+                });
+                nextMessage = (0, promptContext_1.reconcileRuntimePromptContext)(nextPrompt);
                 if (shouldExit) {
                     this.completed = true;
-                    Promise.resolve({
-                        nextPrompt,
-                        completed: this.completed
-                    });
+                    break;
                 }
             }
             catch (error) {
-                console.error(`[InitialPromptGenerator] Error in message modifier:`, error);
-                // Continue with other modifiers
+                console.error(`[ResponseExecutor] Error in pre tool call processor:`, error);
             }
         }
-        //ToolCall here
-        let toolResults = await this.executeTools(input.rawLLMOutput);
-        // INSERT_YOUR_CODE
-        if (nextMessage && toolResults && toolResults.length > 0 && nextMessage && nextMessage.message && Array.isArray(nextMessage.message.messages)) {
-            for (const toolResult of toolResults) {
-                const messageObject = {
+        const toolExecution = await this.executeTools(input.rawLLMOutput);
+        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);
+        if (toolExecution.toolResults.length > 0 || toolExecution.followUpMessages.length > 0) {
+            nextMessage = (0, promptContext_1.appendTranscriptMessages)(nextMessage, [
+                ...toolExecution.toolResults.map((toolResult) => ({
                     role: toolResult.role,
-                    content: typeof toolResult.content === 'string' ? toolResult.content : JSON.stringify(toolResult.content),
-                    tool_call_id: toolResult.tool_call_id
-                };
-                nextMessage.message.messages.push(messageObject);
-            }
-        }
-        else {
-            // this.completed=true;
-            nextMessage.message.messages.push({
-                role: "user",
-                content: [{
-                        type: "text",
-                        text: "If you have completed the user's task, use the attempt_completion tool. if you have not completed the task and do not need additional information, then proceed with the next step of the task. (This is an automated message, so do not respond to it conversationally.)"
-                    }]
-            });
+                    content: typeof toolResult.content === 'string'
+                        ? toolResult.content
+                        : JSON.stringify(toolResult.content),
+                    tool_call_id: toolResult.tool_call_id,
+                })),
+                ...toolExecution.followUpMessages,
+            ]);
         }
+        const transcriptLengthBeforePostToolProcessors = (0, promptContext_1.getTranscriptMessages)(nextMessage).length;
         for (const postToolCallProcessor of this.postToolCallProcessors) {
             try {
-                // Pass current nextMessage (with tool results) to the processor
-                let { nextPrompt, shouldExit } = await postToolCallProcessor.modify({
+                const { nextPrompt, shouldExit } = await postToolCallProcessor.modify({
                     llmMessageSent: input.actualMessageSentToLLM,
                     rawLLMResponseMessage: input.rawLLMOutput,
                     nextPrompt: nextMessage,
-                    toolResults: toolResults,
-                    tokenLimit: (_a = input.rawLLMOutput) === null || _a === void 0 ? void 0 : _a.tokenLimit,
-                    maxOutputTokens: (_b = input.rawLLMOutput) === null || _b === void 0 ? void 0 : _b.maxOutputTokens
+                    toolResults: toolExecution.toolResults,
+                    tokenLimit: (_b = input.rawLLMOutput) === null || _b === void 0 ? void 0 : _b.tokenLimit,
+                    maxOutputTokens: (_c = input.rawLLMOutput) === null || _c === void 0 ? void 0 : _c.maxOutputTokens
                 });
-                // Update nextMessage with the (potentially compressed) result
-                nextMessage = nextPrompt;
+                nextMessage = (0, promptContext_1.reconcileRuntimePromptContext)(nextPrompt);
                 if (shouldExit) {
                     this.completed = true;
-                    Promise.resolve({
-                        nextPrompt,
-                        completed: this.completed
-                    });
+                    break;
                 }
             }
             catch (error) {
                 console.error(`[ResponseExecutor] Error in post tool call processor:`, error);
-                // Continue with other processors
             }
         }
+        const transcriptLengthAfterPostToolProcessors = (0, promptContext_1.getTranscriptMessages)(nextMessage).length;
+        if (!toolExecution.hadToolCalls &&
+            transcriptLengthAfterPostToolProcessors > transcriptLengthBeforePostToolProcessors) {
+            this.completed = false;
+            this.finalMessage = undefined;
+        }
         const output = {
             completed: this.completed,
-            nextMessage: nextMessage,
-            toolResults: toolResults
+            nextMessage,
+            toolResults: toolExecution.toolResults,
         };
         if (this.finalMessage !== undefined) {
             output.finalMessage = this.finalMessage;
         }
         return output;
     }
-    /**
-   * Extract tool details from tool call
-   */
-    getToolDetail(tool) {
+    parseToolCall(tool) {
         let toolInput = {};
         if (tool.function.arguments) {
             try {
-                toolInput = JSON.parse(tool.function.arguments);
+                const parsedArguments = JSON.parse(tool.function.arguments);
+                if (parsedArguments && typeof parsedArguments === 'object' && !Array.isArray(parsedArguments)) {
+                    toolInput = parsedArguments;
+                }
             }
             catch (parseError) {
                 throw new Error(`Failed to parse tool arguments: ${parseError}`);
             }
         }
         return {
+            tool,
+            toolInput,
             toolName: tool.function.name,
-            toolInput: toolInput,
-            toolUseId: tool.id
+            toolUseId: tool.id,
+            waitForPrevious: toolInput['waitForPreviousTools'] === true,
         };
     }
-    async executeTools(llmResponse) {
-        var _a, _b;
-        try {
-            let fallBackMessages = [];
-            let lastMessageContent;
-            for (const contentBlock of llmResponse.choices || []) {
-                if (contentBlock.message) {
-                    if (contentBlock.message.content != null) {
-                        lastMessageContent = contentBlock.message.content;
-                        // await codebolt.chat.sendMessage(contentBlock.message.content, {});
-                    }
-                    if (contentBlock.message["reasoning_content"] != null && (!lastMessageContent || lastMessageContent.trim() === '')) {
-                        lastMessageContent = contentBlock.message["reasoning_content"];
-                        // await codebolt.chat.sendMessage((contentBlock.message as any)["reasoning_content"], {});
-                    }
-                }
+    extractLastMessageContent(llmResponse) {
+        var _a, _b, _c;
+        for (const choice of (_a = llmResponse.choices) !== null && _a !== void 0 ? _a : []) {
+            if ((_b = choice.message) === null || _b === void 0 ? void 0 : _b.content) {
+                return choice.message.content;
             }
-            try {
-                let toolResults = [];
-                let taskCompletedBlock;
-                let userRejectedToolUse = false;
-                const contentBlock = (_a = llmResponse.choices) === null || _a === void 0 ? void 0 : _a[0];
-                if (contentBlock && ((_b = contentBlock.message) === null || _b === void 0 ? void 0 : _b.tool_calls)) {
-                    const toolsToExecute = [];
-                    // First pass: Parse all tools and identify "attempt_completion"
-                    for (const tool of contentBlock.message.tool_calls) {
-                        const { toolInput, toolName, toolUseId } = this.getToolDetail(tool);
-                        if (toolName.includes("attempt_completion")) {
-                            taskCompletedBlock = tool;
-                            this.completed = true;
-                        }
-                        else {
-                            toolsToExecute.push({
-                                tool,
-                                toolInput,
-                                toolName,
-                                toolUseId,
-                                waitForPrevious: (toolInput === null || toolInput === void 0 ? void 0 : toolInput.waitForPreviousTools) === true
-                            });
-                        }
-                    }
-                    // Check for loops before execution
-                    if (this.loopDetectionService) {
-                        const toolCallsToCheck = toolsToExecute.map(t => ({ name: t.toolName, args: t.toolInput }));
-                        for (const toolCall of toolCallsToCheck) {
-                            const loopDetected = this.loopDetectionService.checkToolCallLoop(toolCall.name, toolCall.args);
-                            if (loopDetected) {
-                                this.completed = true;
-                                this.finalMessage = `Loop Detected: The agent is stuck in a loop of identical tool calls (${toolCall.name}). Execution stopped to prevent infinite recurrence.`;
-                                return [{
-                                        role: 'tool',
-                                        tool_call_id: 'system-loop-detection', // Virtual ID
-                                        content: JSON.stringify({ error: this.finalMessage })
-                                    }];
-                            }
-                        }
-                    }
-                    // Second pass: Execute tools sequentially (one by one)
-                    for (const item of toolsToExecute) {
-                        try {
-                            if (!userRejectedToolUse) {
-                                let [serverName] = item.toolName.replace('--', ':').split(':');
-                                // codebolt.chat.sendMessage(`tool call ${serverName} ${item.toolName} ${item.toolInput}`, {});
-                                if (serverName == 'subagent') {
-                                    await codeboltjs_1.default.agent.startAgent(item.toolName.replace("subagent--", ''), item.toolInput.task);
-                                    const [didUserReject, result] = [false, "tool result is successful"];
-                                    let toolResult = this.parseToolResult(item.toolUseId, result);
-                                    // Handle side effects (fallback messages)
-                                    if (toolResult.userMessage) {
-                                        fallBackMessages.push({
-                                            role: "user",
-                                            content: toolResult.userMessage.toString()
-                                        });
-                                    }
-                                    if (didUserReject) {
-                                        userRejectedToolUse = true;
-                                    }
-                                    toolResults.push({
-                                        role: "tool",
-                                        tool_call_id: toolResult.tool_call_id,
-                                        content: toolResult.content,
-                                    });
-                                }
-                                else if (item.toolName == "codebolt--thread_management") {
-                                    const response = await codeboltjs_1.default.thread.createThreadInBackground({
-                                        title: item.toolInput.title || item.toolInput.task || 'Background Thread',
-                                        description: item.toolInput.description || item.toolInput.task || '',
-                                        userMessage: item.toolInput.task || item.toolInput.userMessage || '',
-                                        selectedAgent: item.toolInput.selectedAgent,
-                                        isGrouped: item.toolInput.isGrouped,
-                                        groupId: item.toolInput.groupId,
-                                    });
-                                    toolResults.push({
-                                        role: "tool",
-                                        tool_call_id: item.toolUseId,
-                                        content: JSON.stringify(response),
-                                    });
-                                }
-                                else {
-                                    const [didUserReject, result] = await this.executeTool(item.toolName, item.toolInput);
-                                    let toolResult = this.parseToolResult(item.toolUseId, result);
-                                    if (toolResult.userMessage) {
-                                        fallBackMessages.push({
-                                            role: "user",
-                                            content: toolResult.userMessage.toString()
-                                        });
-                                    }
-                                    if (didUserReject) {
-                                        userRejectedToolUse = true;
-                                    }
-                                    toolResults.push({
-                                        role: "tool",
-                                        tool_call_id: toolResult.tool_call_id,
-                                        content: toolResult.content,
-                                    });
-                                }
-                            }
-                            else {
-                                let toolResult = this.parseToolResult(item.toolUseId, "Skipping tool execution due to previous tool user rejection.");
-                                if (toolResult.userMessage) {
-                                    fallBackMessages.push({
-                                        role: "user",
-                                        content: toolResult.userMessage.toString()
-                                    });
-                                }
-                                toolResults.push({
-                                    role: "tool",
-                                    tool_call_id: toolResult.tool_call_id,
-                                    content: toolResult.content,
-                                });
-                            }
-                        }
-                        catch (error) {
-                            toolResults.push({
-                                role: "tool",
-                                tool_call_id: item.tool.id,
-                                content: String(error),
-                            });
-                        }
-                    }
-                }
-                else {
-                    this.completed = true;
-                    // Set final message from agent's last text response when completing without tool calls
-                    if (lastMessageContent) {
-                        this.finalMessage = lastMessageContent;
-                    }
+            const reasoningContent = (_c = choice.message) === null || _c === void 0 ? void 0 : _c.reasoning_content;
+            if (reasoningContent) {
+                return reasoningContent;
+            }
+        }
+        return undefined;
+    }
+    getToolCalls(llmResponse) {
+        var _a, _b, _c, _d;
+        const toolCallsById = new Map();
+        for (const toolCall of (_a = llmResponse.tool_calls) !== null && _a !== void 0 ? _a : []) {
+            if (toolCall === null || toolCall === void 0 ? void 0 : toolCall.id) {
+                toolCallsById.set(toolCall.id, toolCall);
+            }
+        }
+        for (const choice of (_b = llmResponse.choices) !== null && _b !== void 0 ? _b : []) {
+            for (const toolCall of (_d = (_c = choice.message) === null || _c === void 0 ? void 0 : _c.tool_calls) !== null && _d !== void 0 ? _d : []) {
+                if ((toolCall === null || toolCall === void 0 ? void 0 : toolCall.id) && !toolCallsById.has(toolCall.id)) {
+                    toolCallsById.set(toolCall.id, toolCall);
                 }
-                if (taskCompletedBlock) {
-                    const completionArgs = JSON.parse(taskCompletedBlock.function.arguments || "{}");
-                    // Capture the final message from attempt_completion
-                    if (completionArgs) {
-                        this.finalMessage = JSON.stringify(completionArgs);
-                    }
-                    let [_, result] = await this.executeTool(taskCompletedBlock.function.name, completionArgs);
-                    if (result === "") {
-                        // this.completed = true;
-                        result = "The user is satisfied with the result.";
-                    }
-                    let toolResult = this.parseToolResult(taskCompletedBlock.id, result);
-                    toolResults.push({
-                        role: "tool",
-                        tool_call_id: toolResult.tool_call_id,
-                        content: toolResult.content,
-                    });
-                    if (toolResult.userMessage) {
-                        fallBackMessages.push({
-                            role: "user",
-                            content: toolResult.userMessage.toString()
-                        });
-                    }
+            }
+        }
+        return Array.from(toolCallsById.values());
+    }
+    async executeTools(llmResponse) {
+        const lastMessageContent = this.extractLastMessageContent(llmResponse);
+        const toolCalls = this.getToolCalls(llmResponse);
+        if (toolCalls.length === 0) {
+            await this.sendFinalMessageToChat(lastMessageContent);
+            return {
+                toolResults: [],
+                followUpMessages: [],
+                completed: true,
+                finalMessage: lastMessageContent,
+                hadToolCalls: false,
+            };
+        }
+        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 (this.loopDetectionService) {
+            for (const toolCall of executionToolCalls) {
+                const loopDetected = this.loopDetectionService.checkToolCallLoop(toolCall.toolName, toolCall.toolInput);
+                if (loopDetected) {
+                    const loopMessage = `Loop detected while calling "${toolCall.toolName}". Execution stopped to prevent infinite recurrence.`;
+                    return {
+                        toolResults: [{
+                                role: 'tool',
+                                tool_call_id: 'system-loop-detection',
+                                content: JSON.stringify({ error: loopMessage }),
+                            }],
+                        followUpMessages: [],
+                        completed: true,
+                        finalMessage: loopMessage,
+                        hadToolCalls: true,
+                    };
                 }
-                return toolResults;
             }
-            catch (error) {
+        }
+        const toolResults = [];
+        const followUpMessages = [];
+        let userRejectedToolUse = false;
+        for (const currentToolCall of executionToolCalls) {
+            if (userRejectedToolUse) {
+                const skippedResult = this.parseToolResult(currentToolCall.toolUseId, 'Skipping tool execution due to previous tool user rejection.');
+                toolResults.push(skippedResult);
+                continue;
             }
+            const executionResult = await this.executeSingleToolCall(currentToolCall);
+            toolResults.push(executionResult.toolResult);
+            followUpMessages.push(...executionResult.followUpMessages);
+            userRejectedToolUse = executionResult.didUserReject;
+        }
+        if (completionToolCalls.length > 0) {
+            const completionToolCall = completionToolCalls.at(-1);
+            if (completionToolCall) {
+                const completionArguments = completionToolCall.toolInput;
+                this.finalMessage = JSON.stringify(completionArguments);
+                const [, completionResult] = await this.executeTool(completionToolCall.toolName, completionArguments);
+                const parsedCompletionResult = this.parseToolResult(completionToolCall.toolUseId, completionResult === '' ? 'The user is satisfied with the result.' : completionResult);
+                toolResults.push(parsedCompletionResult);
+            }
+        }
+        return {
+            toolResults,
+            followUpMessages,
+            completed: completionToolCalls.length > 0,
+            finalMessage: this.finalMessage,
+            hadToolCalls: true,
+        };
+    }
+    async sendFinalMessageToChat(message) {
+        if (!message || message.trim().length === 0) {
+            return;
+        }
+        try {
+            await Promise.resolve(codeboltjs_1.default.chat.sendMessage(message));
         }
         catch (error) {
+            console.error('[ResponseExecutor] Failed to send final chat message:', error);
+        }
+    }
+    async executeSingleToolCall(toolCall) {
+        try {
+            let resultTuple;
+            if (toolCall.toolName === 'codebolt--thread_management') {
+                resultTuple = [
+                    false,
+                    await codeboltjs_1.default.thread.createThreadInBackground({
+                        title: String(toolCall.toolInput['title'] || toolCall.toolInput['task'] || 'Background Thread'),
+                        description: String(toolCall.toolInput['description'] || toolCall.toolInput['task'] || ''),
+                        userMessage: String(toolCall.toolInput['task'] || toolCall.toolInput['userMessage'] || ''),
+                        selectedAgent: toolCall.toolInput['selectedAgent'],
+                        isGrouped: Boolean(toolCall.toolInput['isGrouped']),
+                        ...(typeof toolCall.toolInput['groupId'] === 'string'
+                            ? { groupId: toolCall.toolInput['groupId'] }
+                            : {}),
+                    })
+                ];
+            }
+            else if (toolCall.toolName.startsWith('subagent--')) {
+                const task = toolCall.toolInput['task'];
+                await codeboltjs_1.default.agent.startAgent(toolCall.toolName.replace('subagent--', ''), typeof task === 'string' ? task : JSON.stringify(task));
+                resultTuple = [false, 'tool result is successful'];
+            }
+            else {
+                resultTuple = await this.executeTool(toolCall.toolName, toolCall.toolInput);
+            }
+            const [didUserReject, result] = resultTuple;
+            const parsedResult = this.parseToolResult(toolCall.toolUseId, result);
+            return {
+                toolResult: parsedResult,
+                followUpMessages: parsedResult.userMessage ? [{
+                        role: 'user',
+                        content: parsedResult.userMessage.toString(),
+                    }] : [],
+                didUserReject,
+            };
+        }
+        catch (error) {
+            return {
+                toolResult: {
+                    role: 'tool',
+                    tool_call_id: toolCall.toolUseId,
+                    content: String(error),
+                },
+                followUpMessages: [],
+                didUserReject: false,
+            };
         }
-        return [];
     }
-    /**
-     * Executes a tool with given name and input.
-     *
-     * @param toolName - The name of the tool to execute
-     * @param toolInput - The input parameters for the tool
-     * @returns Promise with tuple [userRejected, result]
-     */
     async executeTool(toolName, toolInput) {
         var _a, _b, _c;
-        //codebolttools--readfile
-        // console.log("Executing tool: ", toolName, toolInput);
         const parts = toolName.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 : '');
-        // console.log("Toolbox name: ", toolboxName, "Actual tool name: ", actualToolName);
         const { data } = await codeboltjs_1.default.mcp.executeTool(toolboxName, actualToolName, toolInput);
-        // console.log("Tool result: ", data);
-        // Handle the case where data is an array [didUserReject, content]
         if (Array.isArray(data) && data.length >= 2) {
             const [didUserReject, content] = data;
             return [Boolean(didUserReject), content];
         }
-        // If data is not in the expected array format, return it as-is
         return [false, data];
     }
-    /**
-     * Creates a tool result object from the tool execution response.
-     *
-     * @param tool_call_id - The ID of the tool call
-     * @param content - The content returned by the tool
-     * @returns ToolResult object
-     */
     parseToolResult(tool_call_id, content) {
-        let userMessage = undefined;
+        let serializedContent = typeof content === 'string'
+            ? content
+            : JSON.stringify(content);
+        let userMessage;
         try {
-            let parsed = JSON.parse(content);
-            // console.log("Parsed Content: ", parsed);
-            if (parsed.payload && parsed.payload.content) {
-                content = `The browser action has been executed. The  screenshot have been captured for your analysis. The tool response is provided in the next user message`;
-                // this.apiConversationHistory.push()
-                userMessage = parsed.payload.content;
+            const parsedContent = typeof serializedContent === 'string'
+                ? JSON.parse(serializedContent)
+                : serializedContent;
+            if (parsedContent &&
+                typeof parsedContent === 'object' &&
+                'payload' in parsedContent &&
+                parsedContent.payload &&
+                typeof parsedContent.payload === 'object' &&
+                'content' in parsedContent.payload &&
+                typeof parsedContent.payload.content === 'string') {
+                serializedContent = 'The browser action has been executed. The screenshot has been captured for your analysis. The tool response is provided in the next user message.';
+                userMessage = parsedContent.payload.content;
             }
         }
-        catch (error) {
+        catch {
+            // Preserve the raw tool result when it is not JSON.
         }
         return {
-            role: "tool",
+            role: 'tool',
             tool_call_id,
-            content,
-            userMessage
+            content: serializedContent,
+            userMessage,
         };
     }
     setPreToolCallProcessors(processors) {
@@ -361,5 +323,64 @@ class ResponseExecutor {
     getPostToolCallProcessors() {
         return this.postToolCallProcessors;
     }
+    injectDiscoveredTools(llmResponse, toolResults, nextMessage) {
+        var _a, _b;
+        try {
+            const toolCalls = this.getToolCalls(llmResponse);
+            if (!toolCalls || !((_a = nextMessage === null || nextMessage === void 0 ? void 0 : nextMessage.message) === null || _a === void 0 ? void 0 : _a.tools))
+                return;
+            for (const toolCall of toolCalls) {
+                if (!toolCall)
+                    continue;
+                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');
+                if (!isToolSearch)
+                    continue;
+                const toolCallId = toolCall.id;
+                const toolResult = toolResults.find(r => r.tool_call_id === toolCallId);
+                if (!(toolResult === null || toolResult === void 0 ? void 0 : toolResult.content))
+                    continue;
+                const content = typeof toolResult.content === 'string'
+                    ? toolResult.content
+                    : JSON.stringify(toolResult.content);
+                const jsonMatch = content.match(/\[[\s\S]*\]/);
+                if (!jsonMatch)
+                    continue;
+                let discoveredSchemas;
+                try {
+                    discoveredSchemas = JSON.parse(jsonMatch[0]);
+                }
+                catch {
+                    continue;
+                }
+                if (!Array.isArray(discoveredSchemas))
+                    continue;
+                const existingToolNames = new Set(nextMessage.message.tools.map((tool) => { var _a; return (_a = tool.function) === null || _a === void 0 ? void 0 : _a.name; }));
+                for (const schema of discoveredSchemas) {
+                    const schemaFunction = schema['function'];
+                    const rawName = schemaFunction === null || schemaFunction === void 0 ? void 0 : schemaFunction.name;
+                    if (!rawName)
+                        continue;
+                    const prefixedName = rawName.startsWith('codebolt--') ? rawName : `codebolt--${rawName}`;
+                    if (existingToolNames.has(prefixedName))
+                        continue;
+                    const prefixedSchema = {
+                        ...schema,
+                        function: {
+                            ...schemaFunction,
+                            name: prefixedName
+                        }
+                    };
+                    nextMessage.message.tools.push(prefixedSchema);
+                    existingToolNames.add(prefixedName);
+                }
+            }
+        }
+        catch (error) {
+            console.error('[ResponseExecutor] Error injecting discovered tools:', error);
+        }
+    }
 }
 exports.ResponseExecutor = ResponseExecutor;

package/dist/unified/index.d.ts

@@ -15,9 +15,18 @@ export { InitialPromptGenerator } from './base/initialPromptGenerator';
 export { AgentStep } from './base/agentStep';
 export { ResponseExecutor } from './base/responseExecutor';
 export { LoopDetectionService, LoopType } from './services/LoopDetectionService';
+export { CompressionCoordinator, type CompressionCoordinatorOptions, type CompressionDecision, type CompressionMetadata, type CompressionRecoveryResult, type CompressionStage, } from './services/CompressionCoordinator';
 export { Agent } from './agent/agent';
 export { CodeboltAgent, createCodeboltAgent, type CodeboltAgentConfig } from './agent/codeboltAgent';
 export { Tool, createTool } from './agent/tools';
 export { Workflow } from './agent/workflow';
 export { type OpenAIMessage, type OpenAITool, type ToolResult, type CodeboltAPI, type AgentExecutionResult, type StreamChunk, type StreamCallback } from './types/libTypes';
 export { type LLMConfig } from './types/libTypes';
+export { CompactionOrchestrator, type CompactionPipelineResult, } from './services/compaction/compactionOrchestrator';
+export { SnipCompact, type SnipCompactOptions } from './services/compaction/snipCompact';
+export { MicroCompact, type MicroCompactOptions } from './services/compaction/microCompact';
+export { ContextCollapse, type ContextCollapseOptions } from './services/compaction/contextCollapse';
+export { AutoCompact, type AutoCompactOptions, type AutoCompactTracking } from './services/compaction/autoCompact';
+export { ReactiveCompact, type ReactiveCompactOptions, type ReactiveRecoveryResult } from './services/compaction/reactiveCompact';
+export { PostCompactCleanup, type PostCompactCleanupOptions } from './services/compaction/postCompactCleanup';
+export { TokenEstimator, type CompactionContext, type CompactionLayer, type CompactionLayerKind, type CompactionBoundary, type CompactionOrchestratorOptions, } from './services/compaction/types';