feat: add LLM 429 rate-limit retry with exponential backoff

- Add llmRetryBackoffMs (5000ms default) and llmMaxRetries (3 default) to RetryConfig
- Add callPlannerWithRetry() method that wraps planner.generate() with retry logic
- Exponential backoff with Groq-specific retry-after hint extraction
- All config presets use spread from DEFAULT_CONFIG.retry for forward compatibility
- All 67 tests pass, type-check and build clean

Author: SentienceDEV

package-lock.json

@@ -72,6 +72,10 @@ export interface RetryConfig {
   executorRepairAttempts: number;
   /** Maximum replan attempts (default: 2) */
   maxReplans: number;
+  /** Base delay in ms for LLM 429 rate-limit retries (default: 5000) */
+  llmRetryBackoffMs: number;
+  /** Maximum retries for LLM 429 errors before giving up (default: 3) */
+  llmMaxRetries: number;
 }
 
 /**
@@ -153,6 +157,8 @@ export const DEFAULT_CONFIG: PlannerExecutorConfig = {
     verifyMaxAttempts: 4,
     executorRepairAttempts: 2,
     maxReplans: 2,
+    llmRetryBackoffMs: 5000,
+    llmMaxRetries: 3,
   },
   stepwise: {
     maxSteps: 20,
@@ -221,8 +227,8 @@ export function getConfigPreset(preset: ConfigPreset | string): PlannerExecutorC
           limitMax: 400, // Higher max for complex pages (was 200)
         },
         retry: {
+          ...DEFAULT_CONFIG.retry,
           verifyTimeoutMs: 15000,
-          verifyPollMs: 500,
           verifyMaxAttempts: 6,
           executorRepairAttempts: 3,
           maxReplans: 2,
@@ -246,8 +252,8 @@ export function getConfigPreset(preset: ConfigPreset | string): PlannerExecutorC
       return {
         ...DEFAULT_CONFIG,
         retry: {
+          ...DEFAULT_CONFIG.retry,
           verifyTimeoutMs: 10000,
-          verifyPollMs: 500,
           verifyMaxAttempts: 4,
           executorRepairAttempts: 2,
           maxReplans: 2,
@@ -265,8 +271,8 @@ export function getConfigPreset(preset: ConfigPreset | string): PlannerExecutorC
       return {
         ...DEFAULT_CONFIG,
         retry: {
+          ...DEFAULT_CONFIG.retry,
           verifyTimeoutMs: 5000,
-          verifyPollMs: 500,
           verifyMaxAttempts: 2,
           executorRepairAttempts: 1,
           maxReplans: 1,
@@ -285,8 +291,8 @@ export function getConfigPreset(preset: ConfigPreset | string): PlannerExecutorC
       return {
         ...DEFAULT_CONFIG,
         retry: {
+          ...DEFAULT_CONFIG.retry,
           verifyTimeoutMs: 20000,
-          verifyPollMs: 500,
           verifyMaxAttempts: 8,
           executorRepairAttempts: 3,
           maxReplans: 3,

src/agents/planner-executor/config.ts

@@ -831,7 +831,7 @@ export class PlannerExecutorAgent {
 
           let plannerResp: LLMResponse | null = null;
           try {
-            plannerResp = await this.planner.generate(systemPrompt, userPrompt, {
+            plannerResp = await this.callPlannerWithRetry(systemPrompt, userPrompt, {
               temperature: this.config.plannerTemperature,
               max_tokens: this.config.plannerMaxTokens,
             });
@@ -1214,6 +1214,54 @@ export class PlannerExecutorAgent {
     };
   }
 
+  /**
+   * Call the planner LLM with retry and exponential backoff for 429 rate-limit errors.
+   *
+   * Without this, a single 429 burns an entire step. With retry, we wait for the
+   * rate limit to reset (using the `retry-after` hint when available) and try again.
+   */
+  private async callPlannerWithRetry(
+    systemPrompt: string,
+    userPrompt: string,
+    options: { temperature: number; max_tokens: number }
+  ): Promise<LLMResponse> {
+    const { llmRetryBackoffMs, llmMaxRetries } = this.config.retry;
+
+    for (let attempt = 0; attempt <= llmMaxRetries; attempt++) {
+      try {
+        return await this.planner.generate(systemPrompt, userPrompt, options);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        const is429 =
+          msg.includes('429') ||
+          msg.toLowerCase().includes('rate_limit') ||
+          msg.toLowerCase().includes('rate limit');
+
+        if (!is429 || attempt >= llmMaxRetries) {
+          throw err;
+        }
+
+        // Try to extract retry-after from error message (Groq includes "try again in X.XXs")
+        const retryMatch = msg.match(/try again in ([\d.]+)\s*s/i);
+        let delayMs = llmRetryBackoffMs * Math.pow(2, attempt);
+        if (retryMatch) {
+          delayMs = Math.max(delayMs, Math.ceil(parseFloat(retryMatch[1]) * 1000) + 500);
+        }
+
+        if (this.config.verbose) {
+          console.log(
+            `[PLANNER RETRY] 429 rate limit hit (attempt ${attempt + 1}/${llmMaxRetries}), waiting ${Math.round(delayMs / 1000)}s...`
+          );
+        }
+
+        await new Promise(resolve => setTimeout(resolve, delayMs));
+      }
+    }
+
+    // Should never reach here, but TypeScript needs it
+    throw new Error('Planner retry exhausted');
+  }
+
   private shouldAbortOnPlannerFailure(message: string): boolean {
     const normalized = message.toLowerCase();
     return (