llmist 12.3.5 → 12.4.0

package/dist/index.cjs

@@ -1423,6 +1423,241 @@ var init_model_shortcuts = __esm({
   }
 });
 
+// src/core/rate-limit.ts
+function resolveRateLimitConfig(config) {
+  if (!config) {
+    return { safetyMargin: DEFAULT_RATE_LIMIT_CONFIG.safetyMargin, enabled: false };
+  }
+  const hasLimits = config.requestsPerMinute !== void 0 || config.tokensPerMinute !== void 0 || config.tokensPerDay !== void 0;
+  return {
+    requestsPerMinute: config.requestsPerMinute,
+    tokensPerMinute: config.tokensPerMinute,
+    tokensPerDay: config.tokensPerDay,
+    safetyMargin: config.safetyMargin ?? DEFAULT_RATE_LIMIT_CONFIG.safetyMargin,
+    enabled: config.enabled ?? (hasLimits && DEFAULT_RATE_LIMIT_CONFIG.enabled)
+  };
+}
+var DEFAULT_RATE_LIMIT_CONFIG, RateLimitTracker;
+var init_rate_limit = __esm({
+  "src/core/rate-limit.ts"() {
+    "use strict";
+    DEFAULT_RATE_LIMIT_CONFIG = {
+      safetyMargin: 0.9,
+      enabled: true
+    };
+    RateLimitTracker = class {
+      config;
+      /** Timestamps of requests in the current minute window */
+      requestTimestamps = [];
+      /** Token usage entries in the current minute window */
+      tokenUsage = [];
+      /** Daily token count */
+      dailyTokens = 0;
+      /** Date string (YYYY-MM-DD UTC) for daily reset tracking */
+      dailyResetDate;
+      constructor(config) {
+        this.config = resolveRateLimitConfig(config);
+        this.dailyResetDate = this.getCurrentDateUTC();
+      }
+      /**
+       * Record a completed request with its token usage.
+       *
+       * @param inputTokens - Number of input tokens used
+       * @param outputTokens - Number of output tokens generated
+       */
+      recordUsage(inputTokens, outputTokens) {
+        const now = Date.now();
+        const totalTokens = inputTokens + outputTokens;
+        this.requestTimestamps.push(now);
+        this.tokenUsage.push({ timestamp: now, tokens: totalTokens });
+        this.checkDailyReset();
+        this.dailyTokens += totalTokens;
+        this.pruneOldEntries(now);
+      }
+      /**
+       * Calculate the delay needed before the next request.
+       *
+       * Returns 0 if no delay is needed, otherwise returns the number of
+       * milliseconds to wait to stay within rate limits.
+       *
+       * @returns Delay in milliseconds (0 if none needed)
+       */
+      getRequiredDelayMs() {
+        if (!this.config.enabled) {
+          return 0;
+        }
+        const now = Date.now();
+        this.pruneOldEntries(now);
+        this.checkDailyReset();
+        let maxDelay = 0;
+        if (this.config.requestsPerMinute !== void 0) {
+          const delay = this.calculateRpmDelay(now);
+          maxDelay = Math.max(maxDelay, delay);
+        }
+        if (this.config.tokensPerMinute !== void 0) {
+          const delay = this.calculateTpmDelay(now);
+          maxDelay = Math.max(maxDelay, delay);
+        }
+        if (this.config.tokensPerDay !== void 0) {
+          const effectiveLimit = this.config.tokensPerDay * this.config.safetyMargin;
+          if (this.dailyTokens >= effectiveLimit) {
+            maxDelay = Math.max(maxDelay, this.getTimeUntilMidnightUTC());
+          }
+        }
+        return Math.ceil(maxDelay);
+      }
+      /**
+       * Check if we're approaching any configured limits.
+       *
+       * @returns true if any limit is at or above the safety margin threshold
+       */
+      isApproachingLimit() {
+        if (!this.config.enabled) {
+          return false;
+        }
+        const now = Date.now();
+        this.pruneOldEntries(now);
+        this.checkDailyReset();
+        if (this.config.requestsPerMinute !== void 0) {
+          const currentRpm = this.requestTimestamps.length;
+          const threshold = this.config.requestsPerMinute * this.config.safetyMargin;
+          if (currentRpm >= threshold) {
+            return true;
+          }
+        }
+        if (this.config.tokensPerMinute !== void 0) {
+          const currentTpm = this.tokenUsage.reduce((sum, entry) => sum + entry.tokens, 0);
+          const threshold = this.config.tokensPerMinute * this.config.safetyMargin;
+          if (currentTpm >= threshold) {
+            return true;
+          }
+        }
+        if (this.config.tokensPerDay !== void 0) {
+          const threshold = this.config.tokensPerDay * this.config.safetyMargin;
+          if (this.dailyTokens >= threshold) {
+            return true;
+          }
+        }
+        return false;
+      }
+      /**
+       * Get current usage statistics.
+       *
+       * @returns Current usage stats for monitoring/logging
+       */
+      getUsageStats() {
+        const now = Date.now();
+        this.pruneOldEntries(now);
+        this.checkDailyReset();
+        return {
+          rpm: this.requestTimestamps.length,
+          tpm: this.tokenUsage.reduce((sum, entry) => sum + entry.tokens, 0),
+          dailyTokens: this.dailyTokens,
+          isApproachingLimit: this.isApproachingLimit(),
+          requiredDelayMs: this.getRequiredDelayMs()
+        };
+      }
+      /**
+       * Reset all tracking state.
+       * Useful for testing or when switching API keys/tiers.
+       */
+      reset() {
+        this.requestTimestamps = [];
+        this.tokenUsage = [];
+        this.dailyTokens = 0;
+        this.dailyResetDate = this.getCurrentDateUTC();
+      }
+      /**
+       * Update configuration dynamically.
+       * Useful when API tier changes or for testing.
+       *
+       * @param config - New configuration to apply
+       */
+      updateConfig(config) {
+        this.config = resolveRateLimitConfig(config);
+      }
+      // ─────────────────────────────────────────────────────────────────────────
+      // Private methods
+      // ─────────────────────────────────────────────────────────────────────────
+      /**
+       * Calculate delay needed based on RPM limit.
+       */
+      calculateRpmDelay(now) {
+        const effectiveLimit = this.config.requestsPerMinute * this.config.safetyMargin;
+        const currentRpm = this.requestTimestamps.length;
+        if (currentRpm < effectiveLimit) {
+          return 0;
+        }
+        const oldestTimestamp = this.requestTimestamps[0];
+        if (oldestTimestamp === void 0) {
+          return 0;
+        }
+        const expiryTime = oldestTimestamp + 6e4;
+        return Math.max(0, expiryTime - now);
+      }
+      /**
+       * Calculate delay needed based on TPM limit.
+       */
+      calculateTpmDelay(now) {
+        const effectiveLimit = this.config.tokensPerMinute * this.config.safetyMargin;
+        const currentTpm = this.tokenUsage.reduce((sum, entry) => sum + entry.tokens, 0);
+        if (currentTpm < effectiveLimit) {
+          return 0;
+        }
+        const sorted = [...this.tokenUsage].sort((a, b) => a.timestamp - b.timestamp);
+        let tokensToFree = currentTpm - effectiveLimit;
+        let delay = 0;
+        for (const entry of sorted) {
+          tokensToFree -= entry.tokens;
+          if (tokensToFree <= 0) {
+            delay = entry.timestamp + 6e4 - now;
+            break;
+          }
+        }
+        return Math.max(0, delay);
+      }
+      /**
+       * Remove entries older than 1 minute from the sliding window.
+       */
+      pruneOldEntries(now) {
+        const cutoff = now - 6e4;
+        while (this.requestTimestamps.length > 0 && this.requestTimestamps[0] < cutoff) {
+          this.requestTimestamps.shift();
+        }
+        while (this.tokenUsage.length > 0 && this.tokenUsage[0].timestamp < cutoff) {
+          this.tokenUsage.shift();
+        }
+      }
+      /**
+       * Check if the day has changed (UTC) and reset daily counters.
+       */
+      checkDailyReset() {
+        const currentDate = this.getCurrentDateUTC();
+        if (currentDate !== this.dailyResetDate) {
+          this.dailyTokens = 0;
+          this.dailyResetDate = currentDate;
+        }
+      }
+      /**
+       * Get current date in YYYY-MM-DD format (UTC).
+       */
+      getCurrentDateUTC() {
+        return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      }
+      /**
+       * Calculate milliseconds until midnight UTC.
+       */
+      getTimeUntilMidnightUTC() {
+        const now = /* @__PURE__ */ new Date();
+        const midnight = new Date(
+          Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + 1)
+        );
+        return midnight.getTime() - now.getTime();
+      }
+    };
+  }
+});
+
 // src/core/retry.ts
 function resolveRetryConfig(config) {
   if (!config) {
@@ -1437,7 +1672,9 @@ function resolveRetryConfig(config) {
     randomize: config.randomize ?? DEFAULT_RETRY_CONFIG.randomize,
     onRetry: config.onRetry,
     onRetriesExhausted: config.onRetriesExhausted,
-    shouldRetry: config.shouldRetry
+    shouldRetry: config.shouldRetry,
+    respectRetryAfter: config.respectRetryAfter ?? DEFAULT_RETRY_CONFIG.respectRetryAfter,
+    maxRetryAfterMs: config.maxRetryAfterMs ?? DEFAULT_RETRY_CONFIG.maxRetryAfterMs
   };
 }
 function isRetryableError(error) {
@@ -1461,6 +1698,12 @@ function isRetryableError(error) {
   if (message.includes("overloaded") || message.includes("capacity")) {
     return true;
   }
+  if (message.includes("resource_exhausted") || message.includes("quota exceeded") || message.includes("unavailable") || message.includes("deadline_exceeded")) {
+    return true;
+  }
+  if (message.includes("overloaded_error") || message.includes("api_error")) {
+    return true;
+  }
   if (message.includes("401") || message.includes("403") || message.includes("400") || message.includes("404") || message.includes("authentication") || message.includes("unauthorized") || message.includes("forbidden") || message.includes("invalid") || message.includes("content policy") || name === "AuthenticationError" || name === "BadRequestError" || name === "NotFoundError" || name === "PermissionDeniedError") {
     return false;
   }
@@ -1535,10 +1778,54 @@ function formatLLMError(error) {
     if (firstPart && firstPart.length > 10 && firstPart.length < 150) {
       return firstPart.trim();
     }
-    return message.slice(0, 150).trim() + "...";
+    return `${message.slice(0, 150).trim()}...`;
   }
   return message;
 }
+function parseRetryAfterHeader(value) {
+  const seconds = Number.parseFloat(value);
+  if (!Number.isNaN(seconds) && seconds > 0) {
+    return Math.ceil(seconds * 1e3);
+  }
+  const date = Date.parse(value);
+  if (!Number.isNaN(date)) {
+    const delay = date - Date.now();
+    return delay > 0 ? delay : null;
+  }
+  return null;
+}
+function extractRetryAfterMs(error) {
+  const errorWithHeaders = error;
+  const headers = errorWithHeaders.headers || errorWithHeaders.response?.headers;
+  if (headers) {
+    const retryAfter = typeof headers.get === "function" ? headers.get("retry-after") : headers["retry-after"];
+    if (retryAfter) {
+      const parsed = parseRetryAfterHeader(retryAfter);
+      if (parsed !== null) {
+        return parsed;
+      }
+    }
+  }
+  const message = error.message;
+  const patterns = [
+    /retry\s+(?:in|after)\s+(\d+(?:\.\d+)?)\s*s(?:econds?)?/i,
+    /retry-after:\s*(\d+(?:\.\d+)?)/i,
+    /wait\s+(\d+(?:\.\d+)?)\s*s(?:econds?)?/i
+  ];
+  for (const pattern of patterns) {
+    const match = message.match(pattern);
+    if (match) {
+      const seconds = Number.parseFloat(match[1]);
+      if (!Number.isNaN(seconds) && seconds > 0) {
+        return Math.ceil(seconds * 1e3);
+      }
+    }
+  }
+  if (message.toLowerCase().includes("resource_exhausted") || message.toLowerCase().includes("quota exceeded")) {
+    return 6e4;
+  }
+  return null;
+}
 var DEFAULT_RETRY_CONFIG;
 var init_retry = __esm({
   "src/core/retry.ts"() {
@@ -1549,7 +1836,10 @@ var init_retry = __esm({
       minTimeout: 1e3,
       maxTimeout: 3e4,
       factor: 2,
-      randomize: true
+      randomize: true,
+      respectRetryAfter: true,
+      maxRetryAfterMs: 12e4
+      // 2 minutes cap
     };
   }
 });
@@ -3905,7 +4195,7 @@ function createProviderFromEnv(envVarName, ClientClass, ProviderClass, clientOpt
   if (!isNonEmpty(apiKey)) {
     return null;
   }
-  const client = new ClientClass({ apiKey: apiKey.trim(), ...clientOptions });
+  const client = new ClientClass({ apiKey: apiKey.trim(), maxRetries: 0, ...clientOptions });
   return new ProviderClass(client);
 }
 var init_utils = __esm({
@@ -5865,8 +6155,8 @@ function createHuggingFaceProviderFromEnv() {
     baseURL,
     timeout: 6e4,
     // 60s timeout - HF free tier can be slower than OpenAI
-    maxRetries: 3
-    // Retry failed requests
+    maxRetries: 0
+    // Disable SDK retries - llmist handles all retries at application level
   });
   return new HuggingFaceProvider(client, endpointType);
 }
@@ -8080,6 +8370,7 @@ var init_builder = __esm({
       gadgetOutputLimitPercent;
       compactionConfig;
       retryConfig;
+      rateLimitConfig;
       signal;
       trailingMessage;
       subagentConfig;
@@ -8587,6 +8878,42 @@ var init_builder = __esm({
         this.retryConfig = { enabled: false };
         return this;
       }
+      /**
+       * Configure proactive rate limiting to prevent rate limit errors.
+       *
+       * Set limits based on your API tier to automatically throttle requests
+       * before hitting provider limits. Works in conjunction with reactive
+       * retry/backoff for comprehensive rate limit handling.
+       *
+       * @param config - Rate limit configuration
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * // Gemini free tier limits
+       * .withRateLimits({
+       *   requestsPerMinute: 15,
+       *   tokensPerMinute: 1_000_000,
+       *   safetyMargin: 0.8,  // Start throttling at 80%
+       * })
+       *
+       * // OpenAI Tier 1 limits
+       * .withRateLimits({
+       *   requestsPerMinute: 500,
+       *   tokensPerMinute: 200_000,
+       * })
+       *
+       * // With daily limit (Gemini free tier)
+       * .withRateLimits({
+       *   requestsPerMinute: 15,
+       *   tokensPerDay: 1_500_000,
+       * })
+       * ```
+       */
+      withRateLimits(config) {
+        this.rateLimitConfig = config;
+        return this;
+      }
       /**
        * Set an abort signal for cancelling requests mid-flight.
        *
@@ -8885,6 +9212,7 @@ ${endPrefix}`
           gadgetOutputLimitPercent: this.gadgetOutputLimitPercent,
           compactionConfig: this.compactionConfig,
           retryConfig: this.retryConfig,
+          rateLimitConfig: this.rateLimitConfig,
           signal: this.signal,
           subagentConfig: this.subagentConfig,
           // Tree context for shared tree model (subagents share parent's tree)
@@ -9070,6 +9398,7 @@ ${endPrefix}`
           gadgetOutputLimitPercent: this.gadgetOutputLimitPercent,
           compactionConfig: this.compactionConfig,
           retryConfig: this.retryConfig,
+          rateLimitConfig: this.rateLimitConfig,
           signal: this.signal,
           subagentConfig: this.subagentConfig,
           // Tree context for shared tree model (subagents share parent's tree)
@@ -11576,6 +11905,7 @@ var init_agent = __esm({
     init_execution_tree();
     init_messages();
     init_model_shortcuts();
+    init_rate_limit();
     init_retry();
     init_media_store();
     init_output_viewer();
@@ -11618,6 +11948,8 @@ var init_agent = __esm({
       signal;
       // Retry configuration
       retryConfig;
+      // Rate limit tracker for proactive throttling
+      rateLimitTracker;
       // Subagent configuration
       agentContextConfig;
       subagentConfig;
@@ -11705,6 +12037,10 @@ var init_agent = __esm({
         }
         this.signal = options.signal;
         this.retryConfig = resolveRetryConfig(options.retryConfig);
+        const rateLimitConfig = resolveRateLimitConfig(options.rateLimitConfig);
+        if (rateLimitConfig.enabled) {
+          this.rateLimitTracker = new RateLimitTracker(options.rateLimitConfig);
+        }
         this.agentContextConfig = {
           model: this.model,
           temperature: this.temperature
@@ -11919,6 +12255,8 @@ var init_agent = __esm({
           model: this.model,
           maxIterations: this.maxIterations
         });
+        let currentLLMNodeId;
+        let llmOptions;
         try {
           while (currentIteration < this.maxIterations) {
             if (await this.checkAbortAndNotify(currentIteration)) {
@@ -11933,8 +12271,6 @@ var init_agent = __esm({
               });
             }
             this.logger.debug("Starting iteration", { iteration: currentIteration });
-            let currentLLMNodeId;
-            let llmOptions;
             try {
               const compactionEvent = await this.checkAndPerformCompaction(currentIteration);
               if (compactionEvent) {
@@ -12086,14 +12422,54 @@ var init_agent = __esm({
             reason: currentIteration >= this.maxIterations ? "max_iterations" : "natural_completion"
           });
         } finally {
+          if (currentLLMNodeId) {
+            const node = this.tree.getNode(currentLLMNodeId);
+            if (node && node.type === "llm_call" && !node.completedAt) {
+              await this.safeObserve(async () => {
+                if (this.hooks.observers?.onLLMCallComplete) {
+                  const subagentContext = getSubagentContextForNode(this.tree, currentLLMNodeId);
+                  const context = {
+                    iteration: currentIteration,
+                    options: llmOptions ?? {
+                      model: this.model,
+                      messages: this.conversation.getMessages(),
+                      temperature: this.temperature,
+                      maxTokens: this.defaultMaxTokens
+                    },
+                    finishReason: "interrupted",
+                    usage: void 0,
+                    rawResponse: "",
+                    // No response available for interrupted request
+                    finalMessage: "",
+                    // No final message for interrupted request
+                    logger: this.logger,
+                    subagentContext
+                  };
+                  await this.hooks.observers.onLLMCallComplete(context);
+                }
+              });
+              this.tree.completeLLMCall(currentLLMNodeId, {
+                finishReason: "interrupted"
+              });
+            }
+          }
           unsubscribeBridge();
         }
       }
       /**
-       * Create LLM stream with retry logic.
-       * Wraps the stream creation with exponential backoff for transient failures.
+       * Create LLM stream with two-layer rate limit protection:
+       *
+       * Layer 1 (Proactive): If rate limits are configured, delays requests to stay within limits.
+       * Layer 2 (Reactive): Exponential backoff with Retry-After header support for transient failures.
        */
       async createStreamWithRetry(llmOptions, iteration) {
+        if (this.rateLimitTracker) {
+          const throttleDelay = this.rateLimitTracker.getRequiredDelayMs();
+          if (throttleDelay > 0) {
+            this.logger.debug("Rate limit throttling", { delayMs: throttleDelay });
+            await this.sleep(throttleDelay);
+          }
+        }
         if (!this.retryConfig.enabled) {
           return this.client.stream(llmOptions);
         }
@@ -12105,11 +12481,23 @@ var init_agent = __esm({
           randomize,
           onRetry,
           onRetriesExhausted,
-          shouldRetry
+          shouldRetry,
+          respectRetryAfter,
+          maxRetryAfterMs
         } = this.retryConfig;
+        let retryAfterHintMs = null;
         try {
           return await (0, import_p_retry.default)(
             async (attemptNumber) => {
+              if (retryAfterHintMs !== null && respectRetryAfter) {
+                const cappedDelay = Math.min(retryAfterHintMs, maxRetryAfterMs);
+                this.logger.debug("Using Retry-After delay", {
+                  retryAfterMs: retryAfterHintMs,
+                  cappedDelay
+                });
+                await this.sleep(cappedDelay);
+                retryAfterHintMs = null;
+              }
               this.logger.debug("Creating LLM stream", {
                 attempt: attemptNumber,
                 maxAttempts: retries + 1
@@ -12125,9 +12513,21 @@ var init_agent = __esm({
               signal: this.signal,
               onFailedAttempt: (context) => {
                 const { error, attemptNumber, retriesLeft } = context;
+                if (respectRetryAfter) {
+                  retryAfterHintMs = extractRetryAfterMs(error);
+                  if (retryAfterHintMs !== null) {
+                    this.logger.debug("Retry-After header detected", {
+                      delayMs: retryAfterHintMs
+                    });
+                  }
+                }
                 this.logger.warn(
                   `LLM call failed (attempt ${attemptNumber}/${attemptNumber + retriesLeft}), retrying...`,
-                  { error: error.message, retriesLeft }
+                  {
+                    error: error.message,
+                    retriesLeft,
+                    retryAfterMs: retryAfterHintMs
+                  }
                 );
                 onRetry?.(error, attemptNumber);
               },
@@ -12148,6 +12548,12 @@ var init_agent = __esm({
           throw error;
         }
       }
+      /**
+       * Simple sleep utility for rate limit delays.
+       */
+      sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+      }
       /**
        * Handle LLM error through controller.
        */
@@ -12386,12 +12792,18 @@ var init_agent = __esm({
       }
       /**
        * Calculate cost and complete LLM call in execution tree.
+       * Also records usage to rate limit tracker for proactive throttling.
        */
       completeLLMCallInTree(nodeId, result) {
+        const inputTokens = result.usage?.inputTokens ?? 0;
+        const outputTokens = result.usage?.outputTokens ?? 0;
+        if (this.rateLimitTracker) {
+          this.rateLimitTracker.recordUsage(inputTokens, outputTokens);
+        }
         const llmCost = this.client.modelRegistry?.estimateCost?.(
           this.model,
-          result.usage?.inputTokens ?? 0,
-          result.usage?.outputTokens ?? 0,
+          inputTokens,
+          outputTokens,
           result.usage?.cachedInputTokens ?? 0,
           result.usage?.cacheCreationInputTokens ?? 0
         )?.totalCost;
@@ -12520,6 +12932,7 @@ __export(index_exports, {
   DEFAULT_COMPACTION_CONFIG: () => DEFAULT_COMPACTION_CONFIG,
   DEFAULT_HINTS: () => DEFAULT_HINTS,
   DEFAULT_PROMPTS: () => DEFAULT_PROMPTS,
+  DEFAULT_RATE_LIMIT_CONFIG: () => DEFAULT_RATE_LIMIT_CONFIG,
   DEFAULT_RETRY_CONFIG: () => DEFAULT_RETRY_CONFIG,
   DEFAULT_SUMMARIZATION_PROMPT: () => DEFAULT_SUMMARIZATION_PROMPT,
   ExecutionTree: () => ExecutionTree,
@@ -12544,6 +12957,7 @@ __export(index_exports, {
   ModelIdentifierParser: () => ModelIdentifierParser,
   ModelRegistry: () => ModelRegistry,
   OpenAIChatProvider: () => OpenAIChatProvider,
+  RateLimitTracker: () => RateLimitTracker,
   SimpleSessionManager: () => SimpleSessionManager,
   SlidingWindowStrategy: () => SlidingWindowStrategy,
   StreamProcessor: () => StreamProcessor,
@@ -12570,6 +12984,7 @@ __export(index_exports, {
   detectImageMimeType: () => detectImageMimeType,
   discoverProviderAdapters: () => discoverProviderAdapters,
   extractMessageText: () => extractMessageText,
+  extractRetryAfterMs: () => extractRetryAfterMs,
   filterByDepth: () => filterByDepth,
   filterByParent: () => filterByParent,
   filterRootEvents: () => filterRootEvents,
@@ -12612,11 +13027,13 @@ __export(index_exports, {
   parallelGadgetHint: () => parallelGadgetHint,
   parseDataUrl: () => parseDataUrl,
   parseManifest: () => parseManifest,
+  parseRetryAfterHeader: () => parseRetryAfterHeader,
   randomDelay: () => randomDelay,
   resolveConfig: () => resolveConfig,
   resolveHintTemplate: () => resolveHintTemplate,
   resolveModel: () => resolveModel,
   resolvePromptTemplate: () => resolvePromptTemplate,
+  resolveRateLimitConfig: () => resolveRateLimitConfig,
   resolveRetryConfig: () => resolveRetryConfig,
   resolveRulesTemplate: () => resolveRulesTemplate,
   resolveSubagentModel: () => resolveSubagentModel,
@@ -13592,6 +14009,7 @@ init_model_shortcuts();
 init_options();
 init_prompt_config();
 init_quick_methods();
+init_rate_limit();
 init_retry();
 init_create_gadget();
 init_exceptions();
@@ -14159,6 +14577,7 @@ function getHostExports2(ctx) {
   DEFAULT_COMPACTION_CONFIG,
   DEFAULT_HINTS,
   DEFAULT_PROMPTS,
+  DEFAULT_RATE_LIMIT_CONFIG,
   DEFAULT_RETRY_CONFIG,
   DEFAULT_SUMMARIZATION_PROMPT,
   ExecutionTree,
@@ -14183,6 +14602,7 @@ function getHostExports2(ctx) {
   ModelIdentifierParser,
   ModelRegistry,
   OpenAIChatProvider,
+  RateLimitTracker,
   SimpleSessionManager,
   SlidingWindowStrategy,
   StreamProcessor,
@@ -14209,6 +14629,7 @@ function getHostExports2(ctx) {
   detectImageMimeType,
   discoverProviderAdapters,
   extractMessageText,
+  extractRetryAfterMs,
   filterByDepth,
   filterByParent,
   filterRootEvents,
@@ -14251,11 +14672,13 @@ function getHostExports2(ctx) {
   parallelGadgetHint,
   parseDataUrl,
   parseManifest,
+  parseRetryAfterHeader,
   randomDelay,
   resolveConfig,
   resolveHintTemplate,
   resolveModel,
   resolvePromptTemplate,
+  resolveRateLimitConfig,
   resolveRetryConfig,
   resolveRulesTemplate,
   resolveSubagentModel,