@link-assistant/agent 0.10.1 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.10.1",
+  "version": "0.12.0",
   "description": "A minimal, public domain AI CLI agent compatible with OpenCode's JSON interface. Bun-only runtime.",
   "main": "src/index.js",
   "type": "module",

package/src/flag/flag.ts

@@ -63,6 +63,41 @@ export namespace Flag {
     'OPENCODE_DRY_RUN'
   );
 
+  // Title generation configuration
+  // When disabled, sessions will use default "New session - {timestamp}" titles
+  // This saves tokens and prevents rate limit issues with free tier models
+  // See: https://github.com/link-assistant/agent/issues/157
+  export let GENERATE_TITLE = truthyCompat(
+    'LINK_ASSISTANT_AGENT_GENERATE_TITLE',
+    'AGENT_GENERATE_TITLE'
+  );
+
+  // Allow setting title generation mode programmatically (e.g., from CLI --generate-title flag)
+  export function setGenerateTitle(value: boolean) {
+    GENERATE_TITLE = value;
+  }
+
+  // Retry timeout configuration
+  // Maximum total time to keep retrying for the same error type (default: 7 days in seconds)
+  // For different error types, the timer resets
+  // See: https://github.com/link-assistant/agent/issues/157
+  export function RETRY_TIMEOUT(): number {
+    const val = getEnv(
+      'LINK_ASSISTANT_AGENT_RETRY_TIMEOUT',
+      'AGENT_RETRY_TIMEOUT'
+    );
+    return val ? parseInt(val, 10) : 604800; // 7 days in seconds
+  }
+
+  // Maximum delay for a single retry attempt (default: 20 minutes in milliseconds)
+  export function MAX_RETRY_DELAY(): number {
+    const val = getEnv(
+      'LINK_ASSISTANT_AGENT_MAX_RETRY_DELAY',
+      'AGENT_MAX_RETRY_DELAY'
+    );
+    return val ? parseInt(val, 10) * 1000 : 1200000; // 20 minutes in ms
+  }
+
   // Stream timeout configuration
   // chunkMs: timeout between stream chunks - detects stalled streams (default: 2 minutes)
   // stepMs: timeout for each individual LLM step (default: 10 minutes)

package/src/index.js

@@ -684,6 +684,17 @@ async function main() {
               description:
                 'When used with --resume or --continue, continue in the same session without forking to a new UUID.',
               default: false,
+            })
+            .option('generate-title', {
+              type: 'boolean',
+              description:
+                'Generate session titles using AI (default: false). Disabling saves tokens and prevents rate limit issues.',
+              default: false,
+            })
+            .option('retry-timeout', {
+              type: 'number',
+              description:
+                'Maximum total retry time in seconds for rate limit errors (default: 604800 = 7 days)',
             }),
         handler: async (argv) => {
           // Check both CLI flag and environment variable for compact JSON mode
@@ -866,6 +877,13 @@ async function main() {
           Flag.setDryRun(true);
         }
 
+        // Set generate-title flag if explicitly enabled
+        // Default is false to save tokens and prevent rate limit issues
+        // See: https://github.com/link-assistant/agent/issues/157
+        if (argv['generate-title'] === true) {
+          Flag.setGenerateTitle(true);
+        }
+
         // Initialize logging system
         // - Print logs to stdout only when verbose for clean CLI output
         // - Use verbose flag to enable DEBUG level logging

package/src/provider/provider.ts

@@ -321,6 +321,48 @@ export namespace Provider {
         options: {},
       };
     },
+    /**
+     * Kilo provider - access to 500+ AI models through Kilo Gateway
+     * Uses OpenAI-compatible API at https://api.kilo.ai/api/gateway
+     *
+     * Free models available without API key (using 'public' key):
+     * - GLM-5 (z-ai/glm-5) - Free limited time, flagship Z.AI model
+     * - GLM 4.7 (z-ai/glm-4.7:free) - Free, agent-centric model
+     * - Kimi K2.5 (moonshot/kimi-k2.5:free) - Free, agentic capabilities
+     * - MiniMax M2.1 (minimax/m2.1:free) - Free, general-purpose
+     * - Giga Potato (giga-potato:free) - Free evaluation model
+     *
+     * For paid models, set KILO_API_KEY environment variable
+     *
+     * @see https://kilo.ai/docs/gateway
+     * @see https://kilo.ai/docs/advanced-usage/free-and-budget-models
+     */
+    kilo: async (input) => {
+      const hasKey = await (async () => {
+        if (input.env.some((item) => process.env[item])) return true;
+        if (await Auth.get(input.id)) return true;
+        return false;
+      })();
+
+      // For free models, we can use 'public' as the API key
+      // For paid models, user needs to set KILO_API_KEY
+      if (!hasKey) {
+        for (const [key, value] of Object.entries(input.models)) {
+          // Keep only free models (cost.input === 0) when no API key
+          if (value.cost.input === 0) continue;
+          delete input.models[key];
+        }
+      }
+
+      return {
+        autoload: Object.keys(input.models).length > 0,
+        options: hasKey
+          ? {}
+          : {
+              apiKey: 'public',
+            },
+      };
+    },
     /**
      * Qwen Coder OAuth provider for Qwen subscription users
      * Uses OAuth credentials from agent auth login (Qwen Coder Subscription)
@@ -719,6 +761,170 @@ export namespace Provider {
       models: {}, // Models are dynamically created based on the provider/model syntax
     };
 
+    // Add Kilo provider for access to 500+ AI models through Kilo Gateway
+    // Free models available: GLM-5, GLM 4.7, Kimi K2.5, MiniMax M2.1, Giga Potato
+    // @see https://kilo.ai/docs/gateway
+    // @see https://github.com/link-assistant/agent/issues/159
+    database['kilo'] = {
+      id: 'kilo',
+      name: 'Kilo Gateway',
+      npm: '@ai-sdk/openai-compatible',
+      api: 'https://api.kilo.ai/api/gateway',
+      env: ['KILO_API_KEY'],
+      models: {
+        // GLM-5 - Flagship Z.AI model, free for limited time
+        'glm-5-free': {
+          id: 'z-ai/glm-5',
+          name: 'GLM-5 (Free)',
+          release_date: '2026-02-11',
+          attachment: false,
+          reasoning: true,
+          temperature: true,
+          tool_call: true,
+          cost: {
+            input: 0,
+            output: 0,
+            cache_read: 0,
+            cache_write: 0,
+          },
+          limit: {
+            context: 202752,
+            output: 131072,
+          },
+          modalities: {
+            input: ['text'],
+            output: ['text'],
+          },
+          options: {},
+        },
+        // GLM 4.7 - Agent-centric model, free
+        'glm-4.7-free': {
+          id: 'z-ai/glm-4.7:free',
+          name: 'GLM 4.7 (Free)',
+          release_date: '2026-01-15',
+          attachment: false,
+          reasoning: true,
+          temperature: true,
+          tool_call: true,
+          cost: {
+            input: 0,
+            output: 0,
+            cache_read: 0,
+            cache_write: 0,
+          },
+          limit: {
+            context: 131072,
+            output: 65536,
+          },
+          modalities: {
+            input: ['text'],
+            output: ['text'],
+          },
+          options: {},
+        },
+        // Kimi K2.5 - Agentic capabilities, free
+        'kimi-k2.5-free': {
+          id: 'moonshot/kimi-k2.5:free',
+          name: 'Kimi K2.5 (Free)',
+          release_date: '2025-12-01',
+          attachment: false,
+          reasoning: false,
+          temperature: true,
+          tool_call: true,
+          cost: {
+            input: 0,
+            output: 0,
+            cache_read: 0,
+            cache_write: 0,
+          },
+          limit: {
+            context: 131072,
+            output: 65536,
+          },
+          modalities: {
+            input: ['text'],
+            output: ['text'],
+          },
+          options: {},
+        },
+        // MiniMax M2.1 - General-purpose, free
+        'minimax-m2.1-free': {
+          id: 'minimax/m2.1:free',
+          name: 'MiniMax M2.1 (Free)',
+          release_date: '2025-11-01',
+          attachment: false,
+          reasoning: false,
+          temperature: true,
+          tool_call: true,
+          cost: {
+            input: 0,
+            output: 0,
+            cache_read: 0,
+            cache_write: 0,
+          },
+          limit: {
+            context: 131072,
+            output: 65536,
+          },
+          modalities: {
+            input: ['text'],
+            output: ['text'],
+          },
+          options: {},
+        },
+        // Giga Potato - Free evaluation model
+        'giga-potato-free': {
+          id: 'giga-potato:free',
+          name: 'Giga Potato (Free)',
+          release_date: '2026-01-01',
+          attachment: false,
+          reasoning: false,
+          temperature: true,
+          tool_call: true,
+          cost: {
+            input: 0,
+            output: 0,
+            cache_read: 0,
+            cache_write: 0,
+          },
+          limit: {
+            context: 65536,
+            output: 32768,
+          },
+          modalities: {
+            input: ['text'],
+            output: ['text'],
+          },
+          options: {},
+        },
+        // Trinity Large Preview - Preview model from Arcee AI
+        'trinity-large-preview': {
+          id: 'arcee/trinity-large-preview',
+          name: 'Trinity Large Preview (Free)',
+          release_date: '2026-01-01',
+          attachment: false,
+          reasoning: false,
+          temperature: true,
+          tool_call: true,
+          cost: {
+            input: 0,
+            output: 0,
+            cache_read: 0,
+            cache_write: 0,
+          },
+          limit: {
+            context: 65536,
+            output: 32768,
+          },
+          modalities: {
+            input: ['text'],
+            output: ['text'],
+          },
+          options: {},
+        },
+      },
+    };
+
     for (const [providerID, provider] of configProviders) {
       const existing = database[providerID];
       const parsed: ModelsDev.Provider = {
@@ -1073,6 +1279,15 @@ export namespace Provider {
         'big-pickle',
       ];
     }
+    if (providerID === 'kilo') {
+      priority = [
+        'glm-5-free',
+        'glm-4.7-free',
+        'kimi-k2.5-free',
+        'minimax-m2.1-free',
+        'giga-potato-free',
+      ];
+    }
     for (const item of priority) {
       for (const model of Object.keys(provider.info.models)) {
         if (model.includes(item)) return getModel(providerID, model);
@@ -1081,6 +1296,7 @@ export namespace Provider {
   }
 
   const priority = [
+    'glm-5-free',
     'kimi-k2.5-free',
     'minimax-m2.1-free',
     'gpt-5-nano',

package/src/session/processor.ts

@@ -321,6 +321,8 @@ export namespace SessionProcessor {
                 case 'finish':
                   input.assistantMessage.time.completed = Date.now();
                   await Session.updateMessage(input.assistantMessage);
+                  // Clear retry state on successful completion
+                  SessionRetry.clearRetryState(input.sessionID);
                   break;
 
                 default:
@@ -374,24 +376,67 @@ export namespace SessionProcessor {
               error.data.isRetryable &&
               attempt < SessionRetry.TIMEOUT_MAX_RETRIES;
 
+            // For API errors (rate limits), check if we're within the retry timeout
+            // See: https://github.com/link-assistant/agent/issues/157
+            const retryCheck = isRetryableAPIError
+              ? SessionRetry.shouldRetry(
+                  input.sessionID,
+                  error.data.statusCode?.toString() ?? 'unknown'
+                )
+              : { shouldRetry: true, elapsedTime: 0, maxTime: 0 };
+
             if (
-              isRetryableAPIError ||
+              (isRetryableAPIError && retryCheck.shouldRetry) ||
               isRetryableSocketError ||
               isRetryableTimeoutError
             ) {
               attempt++;
               // Use error-specific delay calculation
-              const delay =
-                error?.name === 'SocketConnectionError'
-                  ? SessionRetry.socketErrorDelay(attempt)
-                  : error?.name === 'TimeoutError'
-                    ? SessionRetry.timeoutDelay(attempt)
-                    : SessionRetry.delay(error, attempt);
+              // SessionRetry.delay may throw RetryTimeoutExceededError if retry-after exceeds timeout
+              let delay: number;
+              try {
+                delay =
+                  error?.name === 'SocketConnectionError'
+                    ? SessionRetry.socketErrorDelay(attempt)
+                    : error?.name === 'TimeoutError'
+                      ? SessionRetry.timeoutDelay(attempt)
+                      : SessionRetry.delay(error, attempt);
+              } catch (delayError) {
+                // If retry-after exceeds AGENT_RETRY_TIMEOUT, fail immediately
+                if (
+                  delayError instanceof SessionRetry.RetryTimeoutExceededError
+                ) {
+                  log.error(() => ({
+                    message: 'retry-after exceeds timeout, failing immediately',
+                    retryAfterMs: delayError.retryAfterMs,
+                    maxTimeoutMs: delayError.maxTimeoutMs,
+                  }));
+                  SessionRetry.clearRetryState(input.sessionID);
+                  // Create a specific error for this case
+                  input.assistantMessage.error = {
+                    name: 'RetryTimeoutExceededError',
+                    data: {
+                      message: delayError.message,
+                      isRetryable: false,
+                      retryAfterMs: delayError.retryAfterMs,
+                      maxTimeoutMs: delayError.maxTimeoutMs,
+                    },
+                  } as MessageV2.Error;
+                  Bus.publish(Session.Event.Error, {
+                    sessionID: input.assistantMessage.sessionID,
+                    error: input.assistantMessage.error,
+                  });
+                  break;
+                }
+                throw delayError;
+              }
               log.info(() => ({
                 message: 'retrying',
                 errorType: error?.name,
                 attempt,
                 delay,
+                elapsedRetryTime: retryCheck.elapsedTime,
+                maxRetryTime: retryCheck.maxTime,
               }));
               SessionStatus.set(input.sessionID, {
                 type: 'retry',
@@ -399,9 +444,14 @@ export namespace SessionProcessor {
                 message: error.data.message,
                 next: Date.now() + delay,
               });
+              // Update retry state to track total time
+              SessionRetry.updateRetryState(input.sessionID, delay);
               await SessionRetry.sleep(delay, input.abort).catch(() => {});
               continue;
             }
+
+            // Clear retry state on non-retryable error
+            SessionRetry.clearRetryState(input.sessionID);
             input.assistantMessage.error = error;
             Bus.publish(Session.Event.Error, {
               sessionID: input.assistantMessage.sessionID,

package/src/session/prompt.ts

@@ -1530,7 +1530,9 @@ export namespace SessionPrompt {
     return result;
   }
 
-  // TODO: wire this back up
+  // Title generation is optional and disabled by default to save tokens
+  // Enable via --generate-title flag or AGENT_GENERATE_TITLE=true env var
+  // See: https://github.com/link-assistant/agent/issues/157
   async function ensureTitle(input: {
     session: Session.Info;
     message: MessageV2.WithParts;
@@ -1538,6 +1540,14 @@ export namespace SessionPrompt {
     providerID: string;
     modelID: string;
   }) {
+    // Skip title generation if disabled (default)
+    if (!Flag.GENERATE_TITLE) {
+      log.info(() => ({
+        message: 'title generation disabled',
+        hint: 'Enable with --generate-title flag or AGENT_GENERATE_TITLE=true',
+      }));
+      return;
+    }
     if (input.session.parentID) return;
     if (!Session.isDefaultTitle(input.session.title)) return;
     const isFirst =

package/src/session/retry.ts

@@ -1,11 +1,47 @@
-import { iife } from '../util/iife';
 import { MessageV2 } from './message-v2';
+import { Flag } from '../flag/flag';
+import { Log } from '../util/log';
 
 export namespace SessionRetry {
+  const log = Log.create({ service: 'session.retry' });
+
   export const RETRY_INITIAL_DELAY = 2000;
   export const RETRY_BACKOFF_FACTOR = 2;
   export const RETRY_MAX_DELAY_NO_HEADERS = 30_000; // 30 seconds
 
+  // Maximum delay for a single retry attempt when NO retry-after header (default: 20 minutes)
+  // This caps exponential backoff when headers are not available
+  // Can be configured via AGENT_MAX_RETRY_DELAY env var
+  export function getMaxRetryDelay(): number {
+    return Flag.MAX_RETRY_DELAY();
+  }
+
+  // Get retry timeout in milliseconds
+  export function getRetryTimeout(): number {
+    return Flag.RETRY_TIMEOUT() * 1000;
+  }
+
+  /**
+   * Error thrown when retry-after exceeds AGENT_RETRY_TIMEOUT
+   * This indicates the wait time is too long and we should fail immediately
+   */
+  export class RetryTimeoutExceededError extends Error {
+    public readonly retryAfterMs: number;
+    public readonly maxTimeoutMs: number;
+
+    constructor(retryAfterMs: number, maxTimeoutMs: number) {
+      const retryAfterHours = (retryAfterMs / 1000 / 3600).toFixed(2);
+      const maxTimeoutHours = (maxTimeoutMs / 1000 / 3600).toFixed(2);
+      super(
+        `API returned retry-after of ${retryAfterHours} hours, which exceeds the maximum retry timeout of ${maxTimeoutHours} hours. ` +
+          `Failing immediately instead of waiting. You can adjust AGENT_RETRY_TIMEOUT env var to increase the limit.`
+      );
+      this.name = 'RetryTimeoutExceededError';
+      this.retryAfterMs = retryAfterMs;
+      this.maxTimeoutMs = maxTimeoutMs;
+    }
+  }
+
   // Socket connection error retry configuration
   // Bun's fetch() has a known 10-second idle timeout issue
   // See: https://github.com/oven-sh/bun/issues/14439
@@ -19,6 +55,71 @@ export namespace SessionRetry {
   export const TIMEOUT_MAX_RETRIES = 3;
   export const TIMEOUT_DELAYS = [30_000, 60_000, 120_000]; // 30s, 60s, 120s
 
+  // Rate limit retry state tracking
+  // Tracks total time spent retrying for each error type
+  // See: https://github.com/link-assistant/agent/issues/157
+  interface RetryState {
+    errorType: string;
+    startTime: number;
+    totalRetryTime: number;
+  }
+
+  const retryStates: Map<string, RetryState> = new Map();
+
+  /**
+   * Check if we should continue retrying for a given session and error type.
+   * Returns true if within retry timeout, false if exceeded.
+   * The timeout resets when the error type changes.
+   */
+  export function shouldRetry(
+    sessionID: string,
+    errorType: string
+  ): { shouldRetry: boolean; elapsedTime: number; maxTime: number } {
+    const maxTime = Flag.RETRY_TIMEOUT() * 1000; // Convert to ms
+    const state = retryStates.get(sessionID);
+
+    if (!state || state.errorType !== errorType) {
+      // New error type or first error - reset state
+      retryStates.set(sessionID, {
+        errorType,
+        startTime: Date.now(),
+        totalRetryTime: 0,
+      });
+      return { shouldRetry: true, elapsedTime: 0, maxTime };
+    }
+
+    const elapsedTime = Date.now() - state.startTime;
+    if (elapsedTime >= maxTime) {
+      log.info(() => ({
+        message: 'retry timeout exceeded',
+        sessionID,
+        errorType,
+        elapsedTime,
+        maxTime,
+      }));
+      return { shouldRetry: false, elapsedTime, maxTime };
+    }
+
+    return { shouldRetry: true, elapsedTime, maxTime };
+  }
+
+  /**
+   * Update retry state after a retry attempt.
+   */
+  export function updateRetryState(sessionID: string, delayMs: number): void {
+    const state = retryStates.get(sessionID);
+    if (state) {
+      state.totalRetryTime += delayMs;
+    }
+  }
+
+  /**
+   * Clear retry state for a session (e.g., on success).
+   */
+  export function clearRetryState(sessionID: string): void {
+    retryStates.delete(sessionID);
+  }
+
   export async function sleep(ms: number, signal: AbortSignal): Promise<void> {
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(resolve, ms);
@@ -33,38 +134,136 @@ export namespace SessionRetry {
     });
   }
 
-  export function delay(error: MessageV2.APIError, attempt: number) {
+  /**
+   * Add jitter to a delay value to prevent thundering herd.
+   * Adds 0-10% random variation to the delay.
+   */
+  function addJitter(delay: number): number {
+    const jitter = Math.random() * 0.1 * delay;
+    return Math.round(delay + jitter);
+  }
+
+  /**
+   * Parse retry-after value from headers and return delay in milliseconds.
+   * Returns null if no valid retry-after header is found.
+   */
+  function parseRetryAfterHeader(
+    headers: Record<string, string>
+  ): number | null {
+    // Check for retry-after-ms header first (milliseconds)
+    const retryAfterMs = headers['retry-after-ms'];
+    if (retryAfterMs) {
+      const parsedMs = Number.parseFloat(retryAfterMs);
+      if (!Number.isNaN(parsedMs) && parsedMs > 0) {
+        log.info(() => ({
+          message: 'parsed retry-after-ms header',
+          headerValue: parsedMs,
+        }));
+        return parsedMs;
+      }
+    }
+
+    // Check for retry-after header (seconds or HTTP date)
+    const retryAfter = headers['retry-after'];
+    if (retryAfter) {
+      const parsedSeconds = Number.parseFloat(retryAfter);
+      if (!Number.isNaN(parsedSeconds) && parsedSeconds > 0) {
+        const delayMs = Math.ceil(parsedSeconds * 1000);
+        log.info(() => ({
+          message: 'parsed retry-after header (seconds)',
+          headerValue: parsedSeconds,
+          delayMs,
+        }));
+        return delayMs;
+      }
+      // Try parsing as HTTP date format
+      const parsed = Date.parse(retryAfter) - Date.now();
+      if (!Number.isNaN(parsed) && parsed > 0) {
+        log.info(() => ({
+          message: 'parsed retry-after header (date)',
+          headerValue: retryAfter,
+          delayMs: parsed,
+        }));
+        return Math.ceil(parsed);
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Calculate retry delay based on error response headers and attempt number.
+   *
+   * RETRY LOGIC (per issue #157 requirements):
+   * 1. If retry-after header is available:
+   *    - If retry-after <= AGENT_RETRY_TIMEOUT: use it directly (exact time)
+   *    - If retry-after > AGENT_RETRY_TIMEOUT: throw RetryTimeoutExceededError (fail immediately)
+   * 2. If no retry-after header:
+   *    - Use exponential backoff up to AGENT_MAX_RETRY_DELAY
+   *
+   * Adds jitter to prevent thundering herd when multiple requests retry.
+   * See: https://github.com/link-assistant/agent/issues/157
+   *
+   * @throws {RetryTimeoutExceededError} When retry-after exceeds AGENT_RETRY_TIMEOUT
+   */
+  export function delay(error: MessageV2.APIError, attempt: number): number {
+    const maxRetryTimeout = getRetryTimeout();
+    const maxBackoffDelay = getMaxRetryDelay();
     const headers = error.data.responseHeaders;
+
     if (headers) {
-      const retryAfterMs = headers['retry-after-ms'];
-      if (retryAfterMs) {
-        const parsedMs = Number.parseFloat(retryAfterMs);
-        if (!Number.isNaN(parsedMs)) {
-          return parsedMs;
-        }
-      }
+      const retryAfterMs = parseRetryAfterHeader(headers);
 
-      const retryAfter = headers['retry-after'];
-      if (retryAfter) {
-        const parsedSeconds = Number.parseFloat(retryAfter);
-        if (!Number.isNaN(parsedSeconds)) {
-          // convert seconds to milliseconds
-          return Math.ceil(parsedSeconds * 1000);
-        }
-        // Try parsing as HTTP date format
-        const parsed = Date.parse(retryAfter) - Date.now();
-        if (!Number.isNaN(parsed) && parsed > 0) {
-          return Math.ceil(parsed);
+      if (retryAfterMs !== null) {
+        // Check if retry-after exceeds the maximum retry timeout
+        if (retryAfterMs > maxRetryTimeout) {
+          log.error(() => ({
+            message:
+              'retry-after exceeds maximum retry timeout, failing immediately',
+            retryAfterMs,
+            maxRetryTimeout,
+            retryAfterHours: (retryAfterMs / 1000 / 3600).toFixed(2),
+            maxRetryTimeoutHours: (maxRetryTimeout / 1000 / 3600).toFixed(2),
+          }));
+          throw new RetryTimeoutExceededError(retryAfterMs, maxRetryTimeout);
         }
+
+        // Use exact retry-after time (within timeout limit)
+        log.info(() => ({
+          message: 'using exact retry-after value',
+          retryAfterMs,
+          maxRetryTimeout,
+        }));
+        return addJitter(retryAfterMs);
       }
 
-      return RETRY_INITIAL_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, attempt - 1);
+      // Headers present but no retry-after - use exponential backoff with max delay cap
+      const backoffDelay = Math.min(
+        RETRY_INITIAL_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, attempt - 1),
+        maxBackoffDelay
+      );
+      log.info(() => ({
+        message: 'no retry-after header, using exponential backoff',
+        attempt,
+        backoffDelay,
+        maxBackoffDelay,
+      }));
+      return addJitter(backoffDelay);
     }
 
-    return Math.min(
+    // No headers at all - use exponential backoff with lower cap
+    const backoffDelay = Math.min(
       RETRY_INITIAL_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, attempt - 1),
       RETRY_MAX_DELAY_NO_HEADERS
     );
+    log.info(() => ({
+      message:
+        'no response headers, using exponential backoff with conservative cap',
+      attempt,
+      backoffDelay,
+      maxCap: RETRY_MAX_DELAY_NO_HEADERS,
+    }));
+    return addJitter(backoffDelay);
   }
 
   /**