opencode-rag-plugin 1.19.0 → 1.19.1

package/ReadMe.md

@@ -55,7 +55,7 @@ opencode-rag query "authentication middleware"
 
 A browser-based dashboard for exploring the indexed vector database - browse and inspect chunks and evaluate the OpenCode sessions in terms of retrieved chunks, consumed tokens and more.
 
-![OpenCodeRAG Web UI](doc/assets/eval.png)
+![OpenCodeRAG Web UI](doc/assets/webui-dashboard.png)
 
 Launch with `opencode-rag ui`. See [Web UI documentation](doc/webui.md) for details.
 

package/dist/core/config.js

@@ -114,7 +114,7 @@ export const DEFAULT_CONFIG = {
         minFileSizeBytes: 0,
         concurrency: 8,
         embedBatchSize: 100,
-        embedConcurrency: 6,
+        embedConcurrency: 3,
         ollamaMaxBatchSize: 500,
         descriptionConcurrency: 4,
         maxSvgSizeBytes: 1_048_576,

package/dist/embedder/factory.d.ts

@@ -16,12 +16,16 @@ import type { RagConfig } from "../core/config.js";
  */
 export declare function createEmbedder(config: RagConfig): EmbeddingProvider;
 /**
- * Embed a list of texts in batches with optional concurrency control.
+ * Embed a list of texts in batches with optional concurrency control and per-batch retry.
  *
  * Splits the input texts into chunks of `batchSize` and embeds them sequentially
  * (or concurrently when `concurrency > 1`). When concurrency is limited, uses
  * `p-limit` to cap the number of in-flight requests.
  *
+ * Each batch is retried up to `retryMax` times with exponential backoff. If all
+ * retries are exhausted, the batch is skipped and empty arrays are returned for
+ * those texts so the caller can still process successfully embedded batches.
+ *
  * @param embedder - The embedding provider to use
  * @param texts - Array of text strings to embed
  * @param batchSize - Number of texts per batch (default 10)
@@ -29,6 +33,9 @@ export declare function createEmbedder(config: RagConfig): EmbeddingProvider;
  * @param concurrency - Maximum number of concurrent batch requests (default 1)
  * @param onProgress - Optional callback invoked after each batch with the running
  *   completed count and total; per-text granularity when `concurrency <= 1`.
- * @returns A promise resolving to a flat array of embedding vectors (one per input text)
+ * @param retryMax - Maximum retry attempts per batch (default 3)
+ * @param retryBaseDelayMs - Base delay for exponential backoff (default 1000)
+ * @returns A promise resolving to a flat array of embedding vectors (one per input text);
+ *   failed batches return empty arrays
  */
-export declare function embedBatch(embedder: EmbeddingProvider, texts: string[], batchSize?: number, purpose?: "query" | "document", concurrency?: number, onProgress?: (completed: number, total: number) => void): Promise<number[][]>;
+export declare function embedBatch(embedder: EmbeddingProvider, texts: string[], batchSize?: number, purpose?: "query" | "document", concurrency?: number, onProgress?: (completed: number, total: number) => void, retryMax?: number, retryBaseDelayMs?: number): Promise<number[][]>;

package/dist/embedder/factory.js

@@ -35,12 +35,16 @@ export function createEmbedder(config) {
     throw new Error(`Unknown embedding provider: ${provider}`);
 }
 /**
- * Embed a list of texts in batches with optional concurrency control.
+ * Embed a list of texts in batches with optional concurrency control and per-batch retry.
  *
  * Splits the input texts into chunks of `batchSize` and embeds them sequentially
  * (or concurrently when `concurrency > 1`). When concurrency is limited, uses
  * `p-limit` to cap the number of in-flight requests.
  *
+ * Each batch is retried up to `retryMax` times with exponential backoff. If all
+ * retries are exhausted, the batch is skipped and empty arrays are returned for
+ * those texts so the caller can still process successfully embedded batches.
+ *
  * @param embedder - The embedding provider to use
  * @param texts - Array of text strings to embed
  * @param batchSize - Number of texts per batch (default 10)
@@ -48,31 +52,56 @@ export function createEmbedder(config) {
  * @param concurrency - Maximum number of concurrent batch requests (default 1)
  * @param onProgress - Optional callback invoked after each batch with the running
  *   completed count and total; per-text granularity when `concurrency <= 1`.
- * @returns A promise resolving to a flat array of embedding vectors (one per input text)
+ * @param retryMax - Maximum retry attempts per batch (default 3)
+ * @param retryBaseDelayMs - Base delay for exponential backoff (default 1000)
+ * @returns A promise resolving to a flat array of embedding vectors (one per input text);
+ *   failed batches return empty arrays
  */
-export async function embedBatch(embedder, texts, batchSize = 10, purpose, concurrency = 1, onProgress) {
+export async function embedBatch(embedder, texts, batchSize = 10, purpose, concurrency = 1, onProgress, retryMax = 3, retryBaseDelayMs = 1000) {
     if (texts.length === 0)
         return [];
     const batches = [];
     for (let i = 0; i < texts.length; i += batchSize) {
         batches.push({ index: i, texts: texts.slice(i, i + batchSize) });
     }
+    async function embedWithRetry(batchTexts) {
+        for (let attempt = 0; attempt <= retryMax; attempt++) {
+            try {
+                return await embedder.embed(batchTexts, purpose);
+            }
+            catch (err) {
+                if (attempt < retryMax) {
+                    const delay = retryBaseDelayMs * Math.pow(2, attempt);
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+            }
+        }
+        return null;
+    }
     if (concurrency <= 1 || batches.length <= 1) {
         const results = [];
         for (const batch of batches) {
-            const embeddings = await embedder.embed(batch.texts, purpose);
-            results.push(...embeddings);
+            const embeddings = await embedWithRetry(batch.texts);
+            if (embeddings) {
+                results.push(...embeddings);
+            }
+            else {
+                for (let i = 0; i < batch.texts.length; i++) {
+                    results.push([]);
+                }
+            }
             onProgress?.(results.length, texts.length);
         }
         return results;
     }
-    const limit = pLimit(concurrency);
     let completedCount = 0;
+    const limit = pLimit(concurrency);
     const batchResults = await Promise.all(batches.map((batch) => limit(async () => {
-        const embeddings = await embedder.embed(batch.texts, purpose);
-        completedCount += embeddings.length;
+        const embeddings = await embedWithRetry(batch.texts);
+        const flatResult = embeddings ?? batch.texts.map(() => []);
+        completedCount += embeddings?.length ?? 0;
         onProgress?.(completedCount, texts.length);
-        return { index: batch.index, embeddings };
+        return { index: batch.index, embeddings: flatResult };
     })));
     batchResults.sort((a, b) => a.index - b.index);
     const results = [];

package/dist/indexer/pipeline.js

@@ -590,7 +590,7 @@ async function runIndexPassInner(options, logger) {
                     hash: prepared[fileIdx].hash,
                     chunkCount: 0, fileLabel: prepared[fileIdx].fileLabel,
                     isNew: false, isModified: false, isUnchanged: false, isEmpty: false,
-                    isTooSmall: false, isRemoved: true, hadChunks: false,
+                    isTooSmall: false, isRemoved: false, hadChunks: false,
                     descriptionFailed: prepared[fileIdx].descriptionFailed,
                 });
             }
@@ -639,14 +639,14 @@ async function runIndexPassInner(options, logger) {
         const result = {
             normalizedPath: prep.normalizedPath,
             hash: prep.hash,
-            chunkCount: prep.chunks?.length ?? 0,
+            chunkCount: validChunks.length,
             fileLabel: prep.fileLabel,
             isNew: !prep.isModified,
             isModified: prep.isModified,
             isUnchanged: false,
             isEmpty: false,
             isTooSmall: false,
-            isRemoved: validChunks.length === 0,
+            isRemoved: (prep.chunks?.length ?? 0) > 0 && validChunks.length === 0 ? false : validChunks.length === 0,
             hadChunks: (prep.chunks?.length ?? 0) > 0,
             descriptionFailed: prep.descriptionFailed,
             descHash: prep.descHash,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-rag-plugin",
-  "version": "1.19.0",
+  "version": "1.19.1",
   "description": "OpenCode plugin for local-first RAG-based semantic code search",
   "type": "module",
   "main": "./dist/plugin-entry.js",