feat: provider-specific rate limiting (Ollama has no limits)

Author: Helweg

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-codebase-index",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "Semantic codebase indexing and search for OpenCode - find code by meaning, not just keywords",
   "type": "module",
   "main": "dist/index.js",

package.json

@@ -177,6 +177,26 @@ export class Indexer {
     this.saveFailedBatches(existing);
   }
 
+  private getProviderRateLimits(provider: string): { 
+    concurrency: number; 
+    intervalMs: number; 
+    minRetryMs: number; 
+    maxRetryMs: number; 
+  } {
+    switch (provider) {
+      case "github-copilot":
+        return { concurrency: 1, intervalMs: 4000, minRetryMs: 5000, maxRetryMs: 60000 };
+      case "openai":
+        return { concurrency: 3, intervalMs: 500, minRetryMs: 1000, maxRetryMs: 30000 };
+      case "google":
+        return { concurrency: 5, intervalMs: 200, minRetryMs: 1000, maxRetryMs: 30000 };
+      case "ollama":
+        return { concurrency: 5, intervalMs: 0, minRetryMs: 500, maxRetryMs: 5000 };
+      default:
+        return { concurrency: 3, intervalMs: 1000, minRetryMs: 1000, maxRetryMs: 30000 };
+    }
+  }
+
   async initialize(): Promise<void> {
     this.detectedProvider = await detectEmbeddingProvider(this.config.embeddingProvider);
     if (!this.detectedProvider) {
@@ -498,15 +518,17 @@ export class Indexer {
       }
     }
 
-    // GitHub Models API rate limit: 15 requests/minute for embeddings
-    // Use concurrency 1 with 4-second delay to stay under limit (15 req/min = 1 req per 4 sec)
-    const queue = new PQueue({ concurrency: 1, interval: 4000, intervalCap: 1 });
+    const providerRateLimits = this.getProviderRateLimits(detectedProvider.provider);
+    const queue = new PQueue({ 
+      concurrency: providerRateLimits.concurrency, 
+      interval: providerRateLimits.intervalMs, 
+      intervalCap: providerRateLimits.concurrency 
+    });
     const dynamicBatches = createDynamicBatches(chunksNeedingEmbedding);
     let rateLimitBackoffMs = 0;
 
     for (const batch of dynamicBatches) {
       queue.add(async () => {
-        // Additional backoff if we've been rate limited
         if (rateLimitBackoffMs > 0) {
           await new Promise(resolve => setTimeout(resolve, rateLimitBackoffMs));
         }
@@ -519,14 +541,13 @@ export class Indexer {
             },
             {
               retries: this.config.indexing.retries,
-              minTimeout: Math.max(this.config.indexing.retryDelayMs, 5000), // Minimum 5s between retries
-              maxTimeout: 60000, // Max 60s backoff
+              minTimeout: Math.max(this.config.indexing.retryDelayMs, providerRateLimits.minRetryMs),
+              maxTimeout: providerRateLimits.maxRetryMs,
               factor: 2,
               onFailedAttempt: (error) => {
                 const message = getErrorMessage(error);
                 if (isRateLimitError(error)) {
-                  // Exponential backoff: 10s, 20s, 40s...
-                  rateLimitBackoffMs = Math.min(60000, (rateLimitBackoffMs || 5000) * 2);
+                  rateLimitBackoffMs = Math.min(providerRateLimits.maxRetryMs, (rateLimitBackoffMs || providerRateLimits.minRetryMs) * 2);
                   console.error(
                     `Rate limited (attempt ${error.attemptNumber}/${error.retriesLeft + error.attemptNumber}): waiting ${rateLimitBackoffMs / 1000}s before retry...`
                   );
@@ -539,7 +560,6 @@ export class Indexer {
             }
           );
 
-          // Success - gradually reduce backoff
           if (rateLimitBackoffMs > 0) {
             rateLimitBackoffMs = Math.max(0, rateLimitBackoffMs - 2000);
           }