Tool repetition detection

Author: mrubens

src/core/Cline.ts

@@ -40,6 +40,7 @@ import { ToolParamName, ToolResponse, DiffStrategy } from "../shared/tools"
 import { UrlContentFetcher } from "../services/browser/UrlContentFetcher"
 import { BrowserSession } from "../services/browser/BrowserSession"
 import { McpHub } from "../services/mcp/McpHub"
+import { ToolRepetitionDetector } from "./ToolRepetitionDetector"
 import { McpServerManager } from "../services/mcp/McpServerManager"
 import { telemetryService } from "../services/telemetry/TelemetryService"
 import { CheckpointServiceOptions, RepoPerTaskCheckpointService } from "../services/checkpoints"
@@ -165,6 +166,9 @@ export class Cline extends EventEmitter<ClineEvents> {
 	consecutiveMistakeLimit: number
 	consecutiveMistakeCountForApplyDiff: Map<string, number> = new Map()
 
+	// For tracking identical consecutive tool calls
+	private toolRepetitionDetector: ToolRepetitionDetector
+
 	// Not private since it needs to be accessible by tools.
 	providerRef: WeakRef<ClineProvider>
 	private readonly globalStoragePath: string
@@ -263,6 +267,7 @@ export class Cline extends EventEmitter<ClineEvents> {
 		}
 
 		this.diffStrategy = new MultiSearchReplaceDiffStrategy(this.fuzzyMatchThreshold)
+		this.toolRepetitionDetector = new ToolRepetitionDetector(this.consecutiveMistakeLimit)
 
 		onCreated?.(this)
 
@@ -1857,6 +1862,46 @@ export class Cline extends EventEmitter<ClineEvents> {
 					break
 				}
 
+				// Check for identical consecutive tool calls
+				if (!block.partial) {
+					// Use the detector to check for repetition, passing the ToolUse block directly
+					const repetitionCheck = this.toolRepetitionDetector.check(block)
+
+					// If execution is not allowed, notify user and break
+					if (!repetitionCheck.allowExecution && repetitionCheck.askUser) {
+						// Handle repetition similar to mistake_limit_reached pattern
+						const { response, text, images } = await this.ask(
+							repetitionCheck.askUser.messageKey as ClineAsk,
+							repetitionCheck.askUser.messageDetail.replace("{toolName}", block.name),
+						)
+
+						if (response === "messageResponse") {
+							// Add user feedback to userContent
+							this.userMessageContent.push(
+								{
+									type: "text" as const,
+									text: `Tool repetition limit reached. User feedback: ${text}`,
+								},
+								...formatResponse.imageBlocks(images),
+							)
+
+							// Add user feedback to chat
+							await this.say("user_feedback", text, images)
+
+							// Track tool repetition in telemetry
+							telemetryService.captureConsecutiveMistakeError(this.taskId) // Using existing telemetry method
+						}
+
+						// Return tool result message about the repetition
+						pushToolResult(
+							formatResponse.toolError(
+								`Tool call repetition limit reached for ${block.name}. Please try a different approach.`,
+							),
+						)
+						break
+					}
+				}
+
 				switch (block.name) {
 					case "write_to_file":
 						await writeToFileTool(this, block, askApproval, handleError, pushToolResult, removeClosingTag)

src/core/ToolRepetitionDetector.ts

@@ -0,0 +1,95 @@
+import { ToolUse } from "../shared/tools"
+import { t } from "../i18n"
+
+/**
+ * Class for detecting consecutive identical tool calls
+ * to prevent the AI from getting stuck in a loop.
+ */
+export class ToolRepetitionDetector {
+	private previousToolCallJson: string | null = null
+	private consecutiveIdenticalToolCallCount: number = 0
+	private readonly consecutiveIdenticalToolCallLimit: number
+
+	/**
+	 * Creates a new ToolRepetitionDetector
+	 * @param limit The maximum number of identical consecutive tool calls allowed
+	 */
+	constructor(limit: number = 3) {
+		this.consecutiveIdenticalToolCallLimit = limit
+	}
+
+	/**
+	 * Checks if the current tool call is identical to the previous one
+	 * and determines if execution should be allowed
+	 *
+	 * @param currentToolCallBlock ToolUse object representing the current tool call
+	 * @returns Object indicating if execution is allowed and a message to show if not
+	 */
+	public check(currentToolCallBlock: ToolUse): {
+		allowExecution: boolean
+		askUser?: {
+			messageKey: string
+			messageDetail: string
+		}
+	} {
+		// Serialize the block to a canonical JSON string for comparison
+		const currentToolCallJson = this.serializeToolUse(currentToolCallBlock)
+
+		// Compare with previous tool call
+		if (this.previousToolCallJson === currentToolCallJson) {
+			this.consecutiveIdenticalToolCallCount++
+		} else {
+			this.consecutiveIdenticalToolCallCount = 1 // Start with 1 for the first occurrence
+			this.previousToolCallJson = currentToolCallJson
+		}
+
+		// Check if limit is reached
+		if (this.consecutiveIdenticalToolCallCount >= this.consecutiveIdenticalToolCallLimit) {
+			// Reset counters to allow recovery if user guides the AI past this point
+			this.consecutiveIdenticalToolCallCount = 0
+			this.previousToolCallJson = null
+
+			// Return result indicating execution should not be allowed
+			return {
+				allowExecution: false,
+				askUser: {
+					messageKey: "mistake_limit_reached",
+					messageDetail: t("tools:toolRepetitionLimitReached", { toolName: currentToolCallBlock.name }),
+				},
+			}
+		}
+
+		// Execution is allowed
+		return { allowExecution: true }
+	}
+
+	/**
+	 * Serializes a ToolUse object into a canonical JSON string for comparison
+	 *
+	 * @param toolUse The ToolUse object to serialize
+	 * @returns JSON string representation of the tool use with sorted parameter keys
+	 */
+	private serializeToolUse(toolUse: ToolUse): string {
+		// Create a new parameters object with alphabetically sorted keys
+		const sortedParams: Record<string, unknown> = {}
+
+		// Get parameter keys and sort them alphabetically
+		const sortedKeys = Object.keys(toolUse.params).sort()
+
+		// Populate the sorted parameters object in a type-safe way
+		for (const key of sortedKeys) {
+			if (Object.prototype.hasOwnProperty.call(toolUse.params, key)) {
+				sortedParams[key] = toolUse.params[key as keyof typeof toolUse.params]
+			}
+		}
+
+		// Create the object with the tool name and sorted parameters
+		const toolObject = {
+			name: toolUse.name,
+			parameters: sortedParams,
+		}
+
+		// Convert to a canonical JSON string
+		return JSON.stringify(toolObject)
+	}
+}