feat(auto-retry): add configurable strategies and max retries

- Introduce `autoRetryMax` and `autoRetryStrategy` settings for auto-approval retry.
- Implement constant, linear, and exponential backoff strategies.
- Allow configuration of maximum retry attempts (0 for unlimited).
- Integrate new settings into core task retry logic.
- Add UI controls for max retries and retry strategy in Auto-Approve settings.
- Update configuration types, mapping, and extension state.
- Enhance `ChatRow` to correctly remove all `retry_timer` tags.

Author: dannycreations

.changeset/curvy-needles-rule.md

@@ -0,0 +1,5 @@
+---
+"kilo-code": minor
+---
+
+qol auto retry

cli/src/config/__tests__/mapper.test.ts

@@ -181,14 +181,21 @@ describe("mapConfigToExtensionState", () => {
 				...baseConfig,
 				autoApproval: {
 					enabled: true,
-					retry: { enabled: true, delay: 15 },
+					retry: {
+						enabled: true,
+						delay: 15,
+						retries: 0,
+						strategy: "exponential",
+					},
 				},
 			}
 
 			const state = mapConfigToExtensionState(config)
 
 			expect(state.alwaysApproveResubmit).toBe(true)
 			expect(state.requestDelaySeconds).toBe(15)
+			expect(state.autoRetryMax).toBe(0)
+			expect(state.autoRetryStrategy).toBe("exponential")
 		})
 
 		it("should set question settings correctly", () => {

cli/src/config/mapper.ts

@@ -60,6 +60,8 @@ export function mapConfigToExtensionState(
 			alwaysAllowBrowser: autoApprovalEnabled && (autoApproval?.browser?.enabled ?? false),
 			alwaysApproveResubmit: autoApprovalEnabled && (autoApproval?.retry?.enabled ?? false),
 			requestDelaySeconds: autoApproval?.retry?.delay ?? 10,
+			autoRetryMax: autoApproval?.retry?.retries ?? 0,
+			autoRetryStrategy: autoApproval?.retry?.strategy ?? "exponential",
 			alwaysAllowMcp: autoApprovalEnabled && (autoApproval?.mcp?.enabled ?? false),
 			alwaysAllowModeSwitch: autoApprovalEnabled && (autoApproval?.mode?.enabled ?? false),
 			alwaysAllowSubtasks: autoApprovalEnabled && (autoApproval?.subtasks?.enabled ?? false),

cli/src/config/types.ts

@@ -30,6 +30,8 @@ export interface AutoApprovalBrowserConfig {
 export interface AutoApprovalRetryConfig {
 	enabled?: boolean
 	delay?: number
+	retries?: number
+	strategy?: "constant" | "linear" | "exponential"
 }
 
 /**

packages/types/src/global-settings.ts

@@ -81,6 +81,8 @@ export const globalSettingsSchema = z.object({
 	alwaysAllowBrowser: z.boolean().optional(),
 	alwaysApproveResubmit: z.boolean().optional(),
 	requestDelaySeconds: z.number().optional(),
+	autoRetryMax: z.number().optional(),
+	autoRetryStrategy: z.enum(["constant", "linear", "exponential"]).optional(),
 	alwaysAllowMcp: z.boolean().optional(),
 	alwaysAllowModeSwitch: z.boolean().optional(),
 	alwaysAllowSubtasks: z.boolean().optional(),
@@ -358,6 +360,8 @@ export const EVALS_SETTINGS: RooCodeSettings = {
 	alwaysAllowBrowser: true,
 	alwaysApproveResubmit: true,
 	requestDelaySeconds: 10,
+	autoRetryMax: 0,
+	autoRetryStrategy: "exponential",
 	alwaysAllowMcp: true,
 	alwaysAllowModeSwitch: true,
 	alwaysAllowSubtasks: true,

src/core/task/Task.ts

@@ -3243,12 +3243,15 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 
 							// Apply exponential backoff similar to first-chunk errors when auto-resubmit is enabled
 							const stateForBackoff = await this.providerRef.deref()?.getState()
-							if (stateForBackoff?.autoApprovalEnabled && stateForBackoff?.alwaysApproveResubmit) {
-								await this.backoffAndAnnounce(
-									currentItem.retryAttempt ?? 0,
-									error,
-									streamingFailedMessage,
-								)
+							const currentAttempt = currentItem.retryAttempt ?? 0
+							const maxRetries = stateForBackoff?.autoRetryMax ?? 0
+
+							if (
+								stateForBackoff?.autoApprovalEnabled &&
+								stateForBackoff?.alwaysApproveResubmit &&
+								(maxRetries === 0 || currentAttempt < maxRetries)
+							) {
+								await this.backoffAndAnnounce(currentAttempt, error, streamingFailedMessage)
 
 								// Check if task was aborted during the backoff
 								if (this.abort) {
@@ -3260,17 +3263,17 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 									await this.abortTask()
 									break
 								}
-							}
 
-							// Push the same content back onto the stack to retry, incrementing the retry attempt counter
-							stack.push({
-								userContent: currentUserContent,
-								includeFileDetails: false,
-								retryAttempt: (currentItem.retryAttempt ?? 0) + 1,
-							})
+								// Push the same content back onto the stack to retry, incrementing the retry attempt counter
+								stack.push({
+									userContent: currentUserContent,
+									includeFileDetails: false,
+									retryAttempt: currentAttempt + 1,
+								})
 
-							// Continue to retry the request
-							continue
+								// Continue to retry the request
+								continue
+							}
 						}
 					}
 				} finally {
@@ -3510,13 +3513,20 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 
 					// Check if we should auto-retry or prompt the user
 					// Reuse the state variable from above
-					if (state?.autoApprovalEnabled && state?.alwaysApproveResubmit) {
+					const currentAttemptEmpty = currentItem.retryAttempt ?? 0
+					const maxRetriesEmpty = state?.autoRetryMax ?? 0
+
+					if (
+						state?.autoApprovalEnabled &&
+						state?.alwaysApproveResubmit &&
+						(maxRetriesEmpty === 0 || currentAttemptEmpty < maxRetriesEmpty)
+					) {
 						// Auto-retry with backoff - don't persist failure message when retrying
 						const errorMsg =
 							"Unexpected API Response: The language model did not provide any assistant messages. This may indicate an issue with the API or the model's output."
 
 						await this.backoffAndAnnounce(
-							currentItem.retryAttempt ?? 0,
+							currentAttemptEmpty,
 							new Error("Empty assistant response"),
 							errorMsg,
 						)
@@ -3534,7 +3544,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 						stack.push({
 							userContent: currentUserContent,
 							includeFileDetails: false,
-							retryAttempt: (currentItem.retryAttempt ?? 0) + 1,
+							retryAttempt: currentAttemptEmpty + 1,
 							userMessageWasRemoved: true,
 						})
 
@@ -3888,7 +3898,6 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 			apiConfiguration,
 			autoApprovalEnabled,
 			alwaysApproveResubmit,
-			requestDelaySeconds,
 			mode,
 			autoCondenseContext = true,
 			autoCondenseContextPercent = 100,
@@ -4229,34 +4238,41 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 			// kilocode_change end
 			// note that this api_req_failed ask is unique in that we only present this option if the api hasn't streamed any content yet (ie it fails on the first chunk due), as it would allow them to hit a retry button. However if the api failed mid-stream, it could be in any arbitrary state where some tools may have executed, so that error is handled differently and requires cancelling the task entirely.
 			if (autoApprovalEnabled && alwaysApproveResubmit) {
-				let errorMsg
-
-				if (error.error?.metadata?.raw) {
-					errorMsg = JSON.stringify(error.error.metadata.raw, null, 2)
-				} else if (error.message) {
-					errorMsg = error.message
+				const maxRetries = state?.autoRetryMax || 0
+				if (maxRetries > 0 && retryAttempt >= maxRetries) {
+					// Max retries reached, fall through to user prompt
 				} else {
-					errorMsg = "Unknown error"
-				}
+					let errorMsg
 
-				// Apply shared exponential backoff and countdown UX
-				await this.backoffAndAnnounce(retryAttempt, error, errorMsg)
+					if (error.error?.metadata?.raw) {
+						errorMsg = JSON.stringify(error.error.metadata.raw, null, 2)
+					} else if (error.message) {
+						errorMsg = error.message
+					} else {
+						errorMsg = "Unknown error"
+					}
 
-				// CRITICAL: Check if task was aborted during the backoff countdown
-				// This prevents infinite loops when users cancel during auto-retry
-				// Without this check, the recursive call below would continue even after abort
-				if (this.abort) {
-					throw new Error(
-						`[Task#attemptApiRequest] task ${this.taskId}.${this.instanceId} aborted during retry`,
-					)
-				}
+					// Apply shared exponential backoff and countdown UX
+					await this.backoffAndAnnounce(retryAttempt, error, errorMsg)
 
-				// Delegate generator output from the recursive call with
-				// incremented retry count.
-				yield* this.attemptApiRequest(retryAttempt + 1)
+					// CRITICAL: Check if task was aborted during the backoff countdown
+					// This prevents infinite loops when users cancel during auto-retry
+					// Without this check, the recursive call below would continue even after abort
+					if (this.abort) {
+						throw new Error(
+							`[Task#attemptApiRequest] task ${this.taskId}.${this.instanceId} aborted during retry`,
+						)
+					}
 
-				return
-			} else {
+					// Delegate generator output from the recursive call with
+					// incremented retry count.
+					yield* this.attemptApiRequest(retryAttempt + 1)
+
+					return
+				}
+			}
+
+			{
 				const { response } = await this.ask(
 					"api_req_failed",
 					error.message ?? JSON.stringify(serializeError(error), null, 2),
@@ -4304,11 +4320,14 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		try {
 			const state = await this.providerRef.deref()?.getState()
 			const baseDelay = state?.requestDelaySeconds || 5
+			const strategy = state?.autoRetryStrategy || "exponential"
 
-			let exponentialDelay = Math.min(
-				Math.ceil(baseDelay * Math.pow(2, retryAttempt)),
-				MAX_EXPONENTIAL_BACKOFF_SECONDS,
-			)
+			let retryDelay = baseDelay
+			if (strategy === "linear") {
+				retryDelay = baseDelay * (retryAttempt + 1)
+			} else if (strategy === "exponential") {
+				retryDelay = Math.min(Math.ceil(baseDelay * Math.pow(2, retryAttempt)), MAX_EXPONENTIAL_BACKOFF_SECONDS)
+			}
 
 			// Respect provider rate limit window
 			let rateLimitDelay = 0
@@ -4325,11 +4344,11 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 				)
 				const match = retryInfo?.retryDelay?.match?.(/^(\d+)s$/)
 				if (match) {
-					exponentialDelay = Number(match[1]) + 1
+					retryDelay = Number(match[1]) + 1
 				}
 			}
 
-			const finalDelay = Math.max(exponentialDelay, rateLimitDelay)
+			const finalDelay = Math.max(retryDelay, rateLimitDelay)
 			if (finalDelay <= 0) return
 
 			// Build header text; fall back to error message if none provided

src/core/task/__tests__/Task.spec.ts

@@ -717,6 +717,8 @@ describe("Cline", () => {
 				mockProvider.getState = vi.fn().mockResolvedValue({
 					alwaysApproveResubmit: true,
 					requestDelaySeconds: 3,
+					autoRetryMax: 0,
+					autoRetryStrategy: "exponential",
 				})
 
 				// Mock previous API request message
@@ -842,6 +844,8 @@ describe("Cline", () => {
 				mockProvider.getState = vi.fn().mockResolvedValue({
 					alwaysApproveResubmit: true,
 					requestDelaySeconds: 3,
+					autoRetryMax: 0,
+					autoRetryStrategy: "exponential",
 				})
 
 				// Mock previous API request message

src/core/webview/ClineProvider.ts

@@ -2112,6 +2112,8 @@ export class ClineProvider
 			enableMcpServerCreation,
 			alwaysApproveResubmit,
 			requestDelaySeconds,
+			autoRetryMax,
+			autoRetryStrategy,
 			currentApiConfigName,
 			listApiConfigMeta,
 			pinnedApiConfigs,
@@ -2295,6 +2297,8 @@ export class ClineProvider
 			enableMcpServerCreation: enableMcpServerCreation ?? true,
 			alwaysApproveResubmit: alwaysApproveResubmit ?? false,
 			requestDelaySeconds: requestDelaySeconds ?? 10,
+			autoRetryMax: autoRetryMax ?? 0,
+			autoRetryStrategy: autoRetryStrategy ?? "exponential",
 			currentApiConfigName: currentApiConfigName ?? "default",
 			listApiConfigMeta: listApiConfigMeta ?? [],
 			pinnedApiConfigs: pinnedApiConfigs ?? {},
@@ -2584,6 +2588,8 @@ export class ClineProvider
 			mcpServers: this.mcpHub?.getAllServers() ?? [],
 			alwaysApproveResubmit: stateValues.alwaysApproveResubmit ?? false,
 			requestDelaySeconds: Math.max(5, stateValues.requestDelaySeconds ?? 10),
+			autoRetryMax: stateValues.autoRetryMax ?? 0,
+			autoRetryStrategy: stateValues.autoRetryStrategy ?? "exponential",
 			currentApiConfigName: stateValues.currentApiConfigName ?? "default",
 			listApiConfigMeta: stateValues.listApiConfigMeta ?? [],
 			pinnedApiConfigs: stateValues.pinnedApiConfigs ?? {},

src/core/webview/__tests__/ClineProvider.spec.ts

@@ -594,6 +594,8 @@ describe("ClineProvider", () => {
 			mcpEnabled: true,
 			enableMcpServerCreation: false,
 			requestDelaySeconds: 5,
+			autoRetryMax: 0,
+			autoRetryStrategy: "exponential",
 			mode: defaultModeSlug,
 			customModes: [],
 			experiments: experimentDefault,

src/shared/ExtensionMessage.ts

@@ -479,6 +479,8 @@ export type ExtensionState = Pick<
 
 	writeDelayMs: number
 	requestDelaySeconds: number
+	autoRetryMax: number
+	autoRetryStrategy: "constant" | "linear" | "exponential"
 
 	enableCheckpoints: boolean
 	checkpointTimeout: number // Timeout for checkpoint initialization in seconds (default: 15)