@codebolt/agent 5.0.7 → 5.0.8

package/dist/unified/agent/workflowSteps.js

@@ -7,8 +7,12 @@ class ParallelStep {
         this.id = config.id;
         this.description = config.description;
         this.type = config.type;
-        this.inputSchema = config.inputSchema;
-        this.outputSchema = config.outputSchema;
+        if (config.inputSchema !== undefined) {
+            this.inputSchema = config.inputSchema;
+        }
+        if (config.outputSchema !== undefined) {
+            this.outputSchema = config.outputSchema;
+        }
     }
     async execute(context) {
         try {
@@ -41,8 +45,12 @@ class ConditionStep {
         this.id = config.id;
         this.description = config.description;
         this.type = config.type;
-        this.inputSchema = config.inputSchema;
-        this.outputSchema = config.outputSchema;
+        if (config.inputSchema !== undefined) {
+            this.inputSchema = config.inputSchema;
+        }
+        if (config.outputSchema !== undefined) {
+            this.outputSchema = config.outputSchema;
+        }
     }
     async execute(context) {
         try {
@@ -51,6 +59,8 @@ class ConditionStep {
             const results = [];
             for (let i = 0; i < this.steps.length; i++) {
                 const step = this.steps[i];
+                if (!step)
+                    continue;
                 try {
                     const result = await step.execute(context);
                     results.push(result);
@@ -91,8 +101,12 @@ class LoopStep {
         this.id = config.id;
         this.description = config.description;
         this.type = config.type;
-        this.inputSchema = config.inputSchema;
-        this.outputSchema = config.outputSchema;
+        if (config.inputSchema !== undefined) {
+            this.inputSchema = config.inputSchema;
+        }
+        if (config.outputSchema !== undefined) {
+            this.outputSchema = config.outputSchema;
+        }
         this.maxIterations = maxIterations;
     }
     async execute(context) {
@@ -105,6 +119,8 @@ class LoopStep {
                 // Execute all steps in this iteration
                 for (let i = 0; i < this.steps.length; i++) {
                     const step = this.steps[i];
+                    if (!step)
+                        continue;
                     try {
                         const result = await step.execute(context);
                         result.stepId = `${result.stepId}_loop_${iteration}`;
@@ -153,8 +169,12 @@ class WorkFlowStep {
         this.id = config.id;
         this.description = config.description;
         this.type = config.type;
-        this.inputSchema = config.inputSchema;
-        this.outputSchema = config.outputSchema;
+        if (config.inputSchema !== undefined) {
+            this.inputSchema = config.inputSchema;
+        }
+        if (config.outputSchema !== undefined) {
+            this.outputSchema = config.outputSchema;
+        }
     }
     async execute(context) {
         try {
@@ -184,17 +204,24 @@ class AgentStep {
         this.id = config.id;
         this.description = config.description;
         this.type = config.type;
-        this.inputSchema = config.inputSchema;
-        this.outputSchema = config.outputSchema;
+        if (config.inputSchema !== undefined) {
+            this.inputSchema = config.inputSchema;
+        }
+        if (config.outputSchema !== undefined) {
+            this.outputSchema = config.outputSchema;
+        }
     }
     async execute(context) {
-        let { result, success, error } = await this.agent.execute(context);
-        return {
+        const { result, success, error } = await this.agent.execute(context);
+        const output = {
             stepId: this.id,
             success: success,
-            result: result,
-            error: error
+            result: result
         };
+        if (error !== undefined) {
+            output.error = error;
+        }
+        return output;
     }
 }
 exports.AgentStep = AgentStep;
@@ -203,28 +230,36 @@ class ToolStep {
         this.id = config.id;
         this.description = config.description;
         this.type = config.type;
-        this.inputSchema = config.inputSchema;
-        this.outputSchema = config.outputSchema;
+        if (config.inputSchema !== undefined) {
+            this.inputSchema = config.inputSchema;
+        }
+        if (config.outputSchema !== undefined) {
+            this.outputSchema = config.outputSchema;
+        }
         this.tool = tool;
     }
     async execute(context) {
         try {
-            let { result, success, error } = await this.tool.execute({}, context);
-            return {
+            const { result, success, error } = await this.tool.execute({}, context);
+            const output = {
                 stepId: this.id,
                 success: success,
-                result: result,
-                error: error
+                result: result
             };
+            if (error !== undefined) {
+                output.error = error;
+            }
+            return output;
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
+            const output = {
                 stepId: this.id,
                 success: false,
-                result: null,
-                error: errorMessage
+                result: null
             };
+            output.error = errorMessage;
+            return output;
         }
     }
 }

package/dist/unified/base/agentStep.js

@@ -63,8 +63,27 @@ class AgentStep {
         }
     }
     async generateResponse(messageForLLM) {
+        var _a, _b;
         const response = await codeboltjs_1.default.llm.inference(messageForLLM);
-        return response.completion;
+        const completion = response.completion;
+        // Add tokenLimit and maxOutputTokens to completion object if available in response
+        if (completion) {
+            // Check if tokenLimit exists at response level or in completion
+            if (response.tokenLimit !== undefined) {
+                completion.tokenLimit = response.tokenLimit;
+            }
+            if (response.maxOutputTokens !== undefined) {
+                completion.maxOutputTokens = response.maxOutputTokens;
+            }
+            // Also check inside completion object itself (from LLM provider response)
+            if (((_a = completion.completion) === null || _a === void 0 ? void 0 : _a.tokenLimit) !== undefined) {
+                completion.tokenLimit = completion.completion.tokenLimit;
+            }
+            if (((_b = completion.completion) === null || _b === void 0 ? void 0 : _b.maxOutputTokens) !== undefined) {
+                completion.maxOutputTokens = completion.completion.maxOutputTokens;
+            }
+        }
+        return completion;
     }
     /**
      * Update LLM configuration

package/dist/unified/base/initialPromptGenerator.js

@@ -17,7 +17,9 @@ class InitialPromptGenerator {
         this.processors = options.processors || [];
         this.metaData = options.metaData || {};
         this.enableLogging = options.enableLogging !== false;
-        this.baseSystemPrompt = options.baseSystemPrompt;
+        if (options.baseSystemPrompt !== undefined) {
+            this.baseSystemPrompt = options.baseSystemPrompt;
+        }
     }
     /**
      * Process and modify input messages using the message modifier pattern

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

@@ -1,4 +1,5 @@
 import { AgentResponseExecutor, PostToolCallProcessor, PreToolCallProcessor, ResponseInput, ResponseOutput } from '@codebolt/types/agent';
+import { LoopDetectionService } from '../services/LoopDetectionService';
 export declare class ResponseExecutor implements AgentResponseExecutor {
     private preToolCallProcessors;
     private postToolCallProcessors;
@@ -7,7 +8,9 @@ export declare class ResponseExecutor implements AgentResponseExecutor {
     constructor(options: {
         preToolCallProcessors: PreToolCallProcessor[];
         postToolCallProcessors: PostToolCallProcessor[];
+        loopDetectionService?: LoopDetectionService;
     });
+    private loopDetectionService?;
     executeResponse(input: ResponseInput): Promise<ResponseOutput>;
     /**
    * Extract tool details from tool call

package/dist/unified/base/responseExecutor.js

@@ -13,8 +13,12 @@ class ResponseExecutor {
         this.finalMessage = undefined;
         this.preToolCallProcessors = options.preToolCallProcessors;
         this.postToolCallProcessors = options.postToolCallProcessors;
+        if (options.loopDetectionService) {
+            this.loopDetectionService = options.loopDetectionService;
+        }
     }
     async executeResponse(input) {
+        var _a, _b;
         let nextMessage = input.nextMessage;
         for (const preToolCallProcessor of this.preToolCallProcessors) {
             try {
@@ -59,13 +63,17 @@ class ResponseExecutor {
         }
         for (const postToolCallProcessor of this.postToolCallProcessors) {
             try {
-                // TODO: Extract required properties from input for PreToolCallProcessorInput
+                // Pass current nextMessage (with tool results) to the processor
                 let { nextPrompt, shouldExit } = await postToolCallProcessor.modify({
                     llmMessageSent: input.actualMessageSentToLLM,
                     rawLLMResponseMessage: input.rawLLMOutput,
-                    nextPrompt: input.nextMessage,
-                    toolResults: []
+                    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
                 });
+                // Update nextMessage with the (potentially compressed) result
+                nextMessage = nextPrompt;
                 if (shouldExit) {
                     this.completed = true;
                     Promise.resolve({
@@ -75,16 +83,19 @@ class ResponseExecutor {
                 }
             }
             catch (error) {
-                console.error(`[InitialPromptGenerator] Error in message modifier:`, error);
-                // Continue with other modifiers
+                console.error(`[ResponseExecutor] Error in post tool call processor:`, error);
+                // Continue with other processors
             }
         }
-        return {
+        const output = {
             completed: this.completed,
             nextMessage: nextMessage,
-            toolResults: toolResults,
-            finalMessage: this.finalMessage
+            toolResults: toolResults
         };
+        if (this.finalMessage !== undefined) {
+            output.finalMessage = this.finalMessage;
+        }
+        return output;
     }
     /**
    * Extract tool details from tool call
@@ -142,6 +153,22 @@ class ResponseExecutor {
                             });
                         }
                     }
+                    // 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 {
@@ -149,7 +176,7 @@ class ResponseExecutor {
                                 let [serverName] = item.toolName.replace('--', ':').split(':');
                                 // codebolt.chat.sendMessage(`tool call ${serverName} ${item.toolName} ${item.toolInput}`, {});
                                 if (serverName == 'subagent') {
-                                    const agentResponse = await codeboltjs_1.default.agent.startAgent(item.toolName.replace("subagent--", ''), item.toolInput.task);
+                                    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)
@@ -169,14 +196,6 @@ class ResponseExecutor {
                                     });
                                 }
                                 else if (item.toolName == "codebolt--thread_management") {
-                                    codeboltjs_1.default.chat.sendMessage(JSON.stringify({
-                                        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,
-                                    }));
                                     const response = await codeboltjs_1.default.thread.createThreadInBackground({
                                         title: item.toolInput.title || item.toolInput.task || 'Background Thread',
                                         description: item.toolInput.description || item.toolInput.task || '',
@@ -282,9 +301,12 @@ class ResponseExecutor {
      * @returns Promise with tuple [userRejected, result]
      */
     async executeTool(toolName, toolInput) {
+        var _a, _b;
         //codebolttools--readfile
         // console.log("Executing tool: ", toolName, toolInput);
-        const [toolboxName, actualToolName] = toolName.split('--');
+        const parts = toolName.split('--');
+        const toolboxName = (_a = parts[0]) !== null && _a !== void 0 ? _a : '';
+        const actualToolName = (_b = parts[1]) !== null && _b !== void 0 ? _b : '';
         // 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);

package/dist/unified/index.d.ts

@@ -14,6 +14,7 @@ export { createDefaultMessageProcessor } from './base/create/createInitialPrompt
 export { InitialPromptGenerator } from './base/initialPromptGenerator';
 export { AgentStep } from './base/agentStep';
 export { ResponseExecutor } from './base/responseExecutor';
+export { LoopDetectionService, LoopType } from './services/LoopDetectionService';
 export { Agent } from './agent/agent';
 export { CodeboltAgent, createCodeboltAgent, type CodeboltAgentConfig } from './agent/codeboltAgent';
 export { Tool, createTool } from './agent/tools';

package/dist/unified/index.js

@@ -10,7 +10,7 @@
  * The framework is designed to be modular, extensible, and easy to use.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Workflow = exports.createTool = exports.Tool = exports.createCodeboltAgent = exports.CodeboltAgent = exports.Agent = exports.ResponseExecutor = exports.AgentStep = exports.InitialPromptGenerator = exports.createDefaultMessageProcessor = exports.UnifiedToolExecutionError = exports.UnifiedResponseExecutionError = exports.UnifiedStepExecutionError = exports.UnifiedMessageProcessingError = exports.UnifiedAgentError = void 0;
+exports.Workflow = exports.createTool = exports.Tool = exports.createCodeboltAgent = exports.CodeboltAgent = exports.Agent = exports.LoopType = exports.LoopDetectionService = exports.ResponseExecutor = exports.AgentStep = exports.InitialPromptGenerator = exports.createDefaultMessageProcessor = exports.UnifiedToolExecutionError = exports.UnifiedResponseExecutionError = exports.UnifiedStepExecutionError = exports.UnifiedMessageProcessingError = exports.UnifiedAgentError = void 0;
 // Error types
 var types_1 = require("./types/types");
 Object.defineProperty(exports, "UnifiedAgentError", { enumerable: true, get: function () { return types_1.UnifiedAgentError; } });
@@ -27,6 +27,9 @@ var agentStep_1 = require("./base/agentStep");
 Object.defineProperty(exports, "AgentStep", { enumerable: true, get: function () { return agentStep_1.AgentStep; } });
 var responseExecutor_1 = require("./base/responseExecutor");
 Object.defineProperty(exports, "ResponseExecutor", { enumerable: true, get: function () { return responseExecutor_1.ResponseExecutor; } });
+var LoopDetectionService_1 = require("./services/LoopDetectionService");
+Object.defineProperty(exports, "LoopDetectionService", { enumerable: true, get: function () { return LoopDetectionService_1.LoopDetectionService; } });
+Object.defineProperty(exports, "LoopType", { enumerable: true, get: function () { return LoopDetectionService_1.LoopType; } });
 // Agent framework components
 var agent_1 = require("./agent/agent");
 Object.defineProperty(exports, "Agent", { enumerable: true, get: function () { return agent_1.Agent; } });

package/dist/unified/services/LoopDetectionService.d.ts

@@ -0,0 +1,44 @@
+export declare enum LoopType {
+    CONSECUTIVE_IDENTICAL_TOOL_CALLS = "CONSECUTIVE_IDENTICAL_TOOL_CALLS",
+    CHANTING_IDENTICAL_SENTENCES = "CHANTING_IDENTICAL_SENTENCES"
+}
+export interface LoopDetectedEvent {
+    type: LoopType;
+    threshold: number;
+    count: number;
+}
+export interface LoopDetectionOptions {
+    toolCallLoopThreshold?: number;
+    contentLoopThreshold?: number;
+    debug?: boolean;
+}
+/**
+ * Service for detecting and preventing infinite loops in AI responses.
+ * Monitors tool call repetitions and content sentence repetitions.
+ *
+ * Ported from gemini-cli/packages/core/src/services/loopDetectionService.ts
+ */
+export declare class LoopDetectionService {
+    private readonly toolCallLoopThreshold;
+    private readonly debug;
+    private lastToolCallKey;
+    private toolCallRepetitionCount;
+    private loopDetected;
+    constructor(options?: LoopDetectionOptions);
+    /**
+     * Resets the loop detection state. Call this when a "fresh" start is needed
+     * or a user explicitly interrupts.
+     */
+    reset(): void;
+    /**
+     * Generates a unique hash for a tool call based on name and arguments.
+     */
+    private getToolCallKey;
+    /**
+     * Checks if the given tool call constitutes a loop.
+     * @param toolName Name of the tool
+     * @param toolArgs Arguments passed to the tool
+     * @returns LoopDetectedEvent if a loop is detected, null otherwise
+     */
+    checkToolCallLoop(toolName: string, toolArgs: any): LoopDetectedEvent | null;
+}

package/dist/unified/services/LoopDetectionService.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoopDetectionService = exports.LoopType = void 0;
+const node_crypto_1 = require("node:crypto");
+var LoopType;
+(function (LoopType) {
+    LoopType["CONSECUTIVE_IDENTICAL_TOOL_CALLS"] = "CONSECUTIVE_IDENTICAL_TOOL_CALLS";
+    LoopType["CHANTING_IDENTICAL_SENTENCES"] = "CHANTING_IDENTICAL_SENTENCES";
+})(LoopType || (exports.LoopType = LoopType = {}));
+/**
+ * Service for detecting and preventing infinite loops in AI responses.
+ * Monitors tool call repetitions and content sentence repetitions.
+ *
+ * Ported from gemini-cli/packages/core/src/services/loopDetectionService.ts
+ */
+class LoopDetectionService {
+    constructor(options = {}) {
+        // State
+        this.lastToolCallKey = null;
+        this.toolCallRepetitionCount = 0;
+        this.loopDetected = false;
+        this.toolCallLoopThreshold = options.toolCallLoopThreshold || 5;
+        this.debug = options.debug || false;
+    }
+    /**
+     * Resets the loop detection state. Call this when a "fresh" start is needed
+     * or a user explicitly interrupts.
+     */
+    reset() {
+        this.lastToolCallKey = null;
+        this.toolCallRepetitionCount = 0;
+        this.loopDetected = false;
+    }
+    /**
+     * Generates a unique hash for a tool call based on name and arguments.
+     */
+    getToolCallKey(toolName, toolArgs) {
+        const argsString = typeof toolArgs === 'string' ? toolArgs : JSON.stringify(toolArgs);
+        const keyString = `${toolName}:${argsString}`;
+        return (0, node_crypto_1.createHash)('sha256').update(keyString).digest('hex');
+    }
+    /**
+     * Checks if the given tool call constitutes a loop.
+     * @param toolName Name of the tool
+     * @param toolArgs Arguments passed to the tool
+     * @returns LoopDetectedEvent if a loop is detected, null otherwise
+     */
+    checkToolCallLoop(toolName, toolArgs) {
+        if (this.loopDetected) {
+            // Already caught a loop, stick to it until reset
+            return {
+                type: LoopType.CONSECUTIVE_IDENTICAL_TOOL_CALLS,
+                threshold: this.toolCallLoopThreshold,
+                count: this.toolCallRepetitionCount
+            };
+        }
+        const key = this.getToolCallKey(toolName, toolArgs);
+        if (this.lastToolCallKey === key) {
+            this.toolCallRepetitionCount++;
+        }
+        else {
+            this.lastToolCallKey = key;
+            this.toolCallRepetitionCount = 1;
+        }
+        if (this.toolCallRepetitionCount >= this.toolCallLoopThreshold) {
+            this.loopDetected = true;
+            if (this.debug) {
+                console.warn(`[LoopDetection] Detected consecutive identical tool calls: ${toolName} (${this.toolCallRepetitionCount})`);
+            }
+            return {
+                type: LoopType.CONSECUTIVE_IDENTICAL_TOOL_CALLS,
+                threshold: this.toolCallLoopThreshold,
+                count: this.toolCallRepetitionCount
+            };
+        }
+        return null;
+    }
+}
+exports.LoopDetectionService = LoopDetectionService;

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

@@ -1,4 +1,23 @@
-import type { UnifiedAgentConfig } from '../types/types';
+/**
+ * Configuration for unified agent - defined locally as it's not exported from types
+ */
+export interface UnifiedAgentConfig {
+    maxIterations?: number;
+    maxConversationLength?: number;
+    enableLogging?: boolean;
+    llmConfig?: {
+        llmname?: string;
+        model?: string;
+        temperature?: number;
+        maxTokens?: number;
+        apiKey?: string;
+        baseUrl?: string;
+    };
+    retryConfig?: {
+        maxRetries?: number;
+        retryDelay?: number;
+    };
+}
 /**
  * Advanced agent creation with full configuration
  */

package/dist/unified/utils/utils.js

@@ -1,4 +1,5 @@
 "use strict";
+// Utility exports for the unified agent framework
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateAgentConfig = validateAgentConfig;
 exports.benchmarkAgent = benchmarkAgent;
@@ -201,13 +202,16 @@ async function benchmarkAgent(agent, testCases) {
         }
         const duration = Date.now() - startTime;
         totalDuration += duration;
-        results.push({
+        const resultEntry = {
             name: testCase.name,
             success,
             duration,
-            output,
-            error
-        });
+            output
+        };
+        if (error !== undefined) {
+            resultEntry.error = error;
+        }
+        results.push(resultEntry);
     }
     const summary = {
         totalTests: testCases.length,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebolt/agent",
-  "version": "5.0.7",
+  "version": "5.0.8",
   "description": "CodeBolt Agent utilities for building and managing AI agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -30,10 +30,10 @@
   "dependencies": {
     "js-yaml": "^4.1.0",
     "zod": "^3.22.4",
-    "@codebolt/types": "5.0.7"
+    "@codebolt/types": "5.0.8"
   },
   "peerDependencies": {
-    "@codebolt/codeboltjs": "5.0.7"
+    "@codebolt/codeboltjs": "5.0.8"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
@@ -43,8 +43,8 @@
     "typedoc": "0.28.16",
     "typedoc-plugin-markdown": "4.9.0",
     "typescript": "^5.4.5",
-    "@codebolt/types": "5.0.7",
-    "@codebolt/codeboltjs": "5.0.7"
+    "@codebolt/codeboltjs": "5.0.8",
+    "@codebolt/types": "5.0.8"
   },
   "exports": {
     "./builder": {