viberag 0.3.2 → 0.4.0

package/dist/rag/embeddings/api-utils.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Shared utilities for API-based embedding providers.
+ * Provides common retry logic, rate limiting, and concurrency patterns.
+ *
+ * Slot progress is dispatched directly to the Redux store, eliminating
+ * the callback chain and providing a single source of truth for UI state.
+ */
+import type { Logger } from '../logger/index.js';
+import { CONCURRENCY } from '../constants.js';
+export { CONCURRENCY };
+/** Delay (ms) between batch completion and next batch start (per slot) */
+export declare const BATCH_DELAY_MS = 200;
+/** Max retry attempts on rate limit */
+export declare const MAX_RETRIES = 12;
+/** Initial backoff (ms) */
+export declare const INITIAL_BACKOFF_MS = 1000;
+/** Maximum backoff (ms) */
+export declare const MAX_BACKOFF_MS = 60000;
+/**
+ * Sleep for a specified duration.
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Check if an error is a rate limit error (429 or quota exceeded).
+ */
+export declare function isRateLimitError(error: unknown): boolean;
+/**
+ * Check if an error is a known transient API error that should be retried.
+ *
+ * GEMINI TRANSIENT BUG:
+ * The Gemini API has a known server-side bug where it intermittently returns
+ * a 400 "API key expired" error even when the key is valid. This is NOT an
+ * actual authentication failure - it's a transient error that resolves on retry.
+ *
+ * Evidence:
+ * - Users report: "if I try the same request again a few times, it usually works fine"
+ * - New API keys don't fix it
+ * - Same key works in curl but fails randomly via API clients
+ * - Google has acknowledged this as a P1/P2 bug
+ *
+ * GitHub issues documenting this bug:
+ * - https://github.com/google-gemini/gemini-cli/issues/4430
+ * - https://github.com/google-gemini/gemini-cli/issues/1712
+ * - https://github.com/google-gemini/gemini-cli/issues/8675
+ *
+ * We detect this specific error and retry it rather than failing immediately.
+ */
+export declare function isTransientApiError(error: unknown): boolean;
+/**
+ * Check if an error should trigger a retry (rate limit OR transient error).
+ */
+export declare function isRetriableError(error: unknown): boolean;
+/**
+ * Callbacks for rate limiting and progress reporting.
+ *
+ * Note: Slot progress is now handled via Redux store dispatch,
+ * not callbacks. Only throttle and batch progress use callbacks.
+ */
+export interface ApiProviderCallbacks {
+    onThrottle?: (message: string | null) => void;
+    onBatchProgress?: (processed: number, total: number) => void;
+    /**
+     * When set to true, callbacks will be skipped.
+     * Used to prevent stale progress updates after an error occurs
+     * while other concurrent batches are still completing.
+     */
+    aborted?: boolean;
+}
+/**
+ * Metadata for a batch of chunks, used for detailed failure logging.
+ */
+export interface BatchMetadata {
+    /** File paths for chunks in this batch */
+    filepaths: string[];
+    /** Start/end lines per chunk */
+    lineRanges: Array<{
+        start: number;
+        end: number;
+    }>;
+    /** Text sizes per chunk (in characters) */
+    sizes: number[];
+}
+/**
+ * Execute an async function with exponential backoff retry on retriable errors.
+ *
+ * Retries on:
+ * - Rate limit errors (429, quota exceeded)
+ * - Transient API errors (e.g., Gemini's spurious "API key expired" bug)
+ *
+ * @param fn - The async function to execute
+ * @param callbacks - Optional callbacks for throttle notifications
+ * @param onRetrying - Optional callback when entering retry state
+ * @returns The result of the function
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, callbacks?: ApiProviderCallbacks, onRetrying?: (retryInfo: string | null) => void): Promise<T>;
+/**
+ * Process batches with p-limit sliding window concurrency and inter-batch delay.
+ * Reports progress per-batch (more granular than group-based).
+ *
+ * Slot progress is dispatched directly to the Redux store, providing a single
+ * source of truth for UI state. Each slot index (0 to CONCURRENCY-1) is reused
+ * as batches complete.
+ *
+ * When an error occurs, sets callbacks.aborted = true to prevent stale progress
+ * updates from concurrent batches that are still completing. Failures are logged
+ * with detailed chunk metadata if provided.
+ *
+ * @param batches - Array of batches to process
+ * @param processBatch - Function to process a single batch
+ * @param callbacks - Optional callbacks for progress reporting
+ * @param batchSize - Optional batch size for calculating chunk indices
+ * @param batchMetadata - Optional metadata per batch for detailed failure logging
+ * @param logger - Optional logger for debug output
+ * @param chunkOffset - Optional offset for cumulative chunk numbering (default: 0)
+ * @returns Flattened array of results
+ */
+export declare function processBatchesWithLimit<T>(batches: T[][], processBatch: (batch: T[], onRetrying?: (retryInfo: string | null) => void) => Promise<number[][]>, callbacks?: ApiProviderCallbacks, batchSize?: number, batchMetadata?: BatchMetadata[], logger?: Logger, chunkOffset?: number): Promise<number[][]>;
+/**
+ * Split an array into batches of a specified size.
+ */
+export declare function chunk<T>(array: T[], size: number): T[][];

package/dist/rag/embeddings/api-utils.js

@@ -0,0 +1,259 @@
+/**
+ * Shared utilities for API-based embedding providers.
+ * Provides common retry logic, rate limiting, and concurrency patterns.
+ *
+ * Slot progress is dispatched directly to the Redux store, eliminating
+ * the callback chain and providing a single source of truth for UI state.
+ */
+import pLimit from 'p-limit';
+import { store, SlotProgressActions } from '../../store/index.js';
+import { CONCURRENCY } from '../constants.js';
+// Re-export for backward compatibility
+export { CONCURRENCY };
+// ============================================================================
+// Constants
+// ============================================================================
+/** Delay (ms) between batch completion and next batch start (per slot) */
+export const BATCH_DELAY_MS = 200;
+/** Max retry attempts on rate limit */
+export const MAX_RETRIES = 12;
+/** Initial backoff (ms) */
+export const INITIAL_BACKOFF_MS = 1000;
+/** Maximum backoff (ms) */
+export const MAX_BACKOFF_MS = 60000;
+// ============================================================================
+// Utility Functions
+// ============================================================================
+/**
+ * Sleep for a specified duration.
+ */
+export function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Check if an error is a rate limit error (429 or quota exceeded).
+ */
+export function isRateLimitError(error) {
+    if (error instanceof Error) {
+        const msg = error.message.toLowerCase();
+        return msg.includes('429') || msg.includes('rate') || msg.includes('quota');
+    }
+    return false;
+}
+/**
+ * Check if an error is a known transient API error that should be retried.
+ *
+ * GEMINI TRANSIENT BUG:
+ * The Gemini API has a known server-side bug where it intermittently returns
+ * a 400 "API key expired" error even when the key is valid. This is NOT an
+ * actual authentication failure - it's a transient error that resolves on retry.
+ *
+ * Evidence:
+ * - Users report: "if I try the same request again a few times, it usually works fine"
+ * - New API keys don't fix it
+ * - Same key works in curl but fails randomly via API clients
+ * - Google has acknowledged this as a P1/P2 bug
+ *
+ * GitHub issues documenting this bug:
+ * - https://github.com/google-gemini/gemini-cli/issues/4430
+ * - https://github.com/google-gemini/gemini-cli/issues/1712
+ * - https://github.com/google-gemini/gemini-cli/issues/8675
+ *
+ * We detect this specific error and retry it rather than failing immediately.
+ */
+export function isTransientApiError(error) {
+    if (error instanceof Error) {
+        const msg = error.message.toLowerCase();
+        // Gemini transient "API key expired" bug (400 status)
+        // The specific message is: "API key expired. Please renew the API key."
+        // We check for this specific pattern to avoid retrying actual auth failures
+        if (msg.includes('api key expired') &&
+            (msg.includes('400') || msg.includes('invalid_argument'))) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check if an error should trigger a retry (rate limit OR transient error).
+ */
+export function isRetriableError(error) {
+    return isRateLimitError(error) || isTransientApiError(error);
+}
+/**
+ * Execute an async function with exponential backoff retry on retriable errors.
+ *
+ * Retries on:
+ * - Rate limit errors (429, quota exceeded)
+ * - Transient API errors (e.g., Gemini's spurious "API key expired" bug)
+ *
+ * @param fn - The async function to execute
+ * @param callbacks - Optional callbacks for throttle notifications
+ * @param onRetrying - Optional callback when entering retry state
+ * @returns The result of the function
+ */
+export async function withRetry(fn, callbacks, onRetrying) {
+    let attempt = 0;
+    let backoffMs = INITIAL_BACKOFF_MS;
+    while (true) {
+        try {
+            const result = await fn();
+            // Clear throttle message on success (if was throttling)
+            // Skip if aborted (another batch failed)
+            if (attempt > 0 && !callbacks?.aborted) {
+                callbacks?.onThrottle?.(null);
+                onRetrying?.(null);
+            }
+            return result;
+        }
+        catch (error) {
+            if (isRetriableError(error) && attempt < MAX_RETRIES) {
+                attempt++;
+                const secs = Math.round(backoffMs / 1000);
+                const retryInfo = `retry ${attempt}/${MAX_RETRIES} in ${secs}s`;
+                // Provide context-appropriate message
+                // Skip if aborted (another batch failed)
+                if (!callbacks?.aborted) {
+                    const isTransient = isTransientApiError(error);
+                    const reason = isTransient ? 'Transient API error' : 'Rate limited';
+                    callbacks?.onThrottle?.(`${reason} - ${retryInfo}`);
+                    onRetrying?.(retryInfo);
+                }
+                await sleep(backoffMs);
+                backoffMs = Math.min(backoffMs * 2, MAX_BACKOFF_MS);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+}
+/**
+ * Process batches with p-limit sliding window concurrency and inter-batch delay.
+ * Reports progress per-batch (more granular than group-based).
+ *
+ * Slot progress is dispatched directly to the Redux store, providing a single
+ * source of truth for UI state. Each slot index (0 to CONCURRENCY-1) is reused
+ * as batches complete.
+ *
+ * When an error occurs, sets callbacks.aborted = true to prevent stale progress
+ * updates from concurrent batches that are still completing. Failures are logged
+ * with detailed chunk metadata if provided.
+ *
+ * @param batches - Array of batches to process
+ * @param processBatch - Function to process a single batch
+ * @param callbacks - Optional callbacks for progress reporting
+ * @param batchSize - Optional batch size for calculating chunk indices
+ * @param batchMetadata - Optional metadata per batch for detailed failure logging
+ * @param logger - Optional logger for debug output
+ * @param chunkOffset - Optional offset for cumulative chunk numbering (default: 0)
+ * @returns Flattened array of results
+ */
+export async function processBatchesWithLimit(batches, processBatch, callbacks, batchSize, batchMetadata, logger, chunkOffset = 0) {
+    const limit = pLimit(CONCURRENCY);
+    let processedItems = 0;
+    const totalItems = batches.reduce((sum, batch) => sum + batch.length, 0);
+    // Track which slot index to assign next (wraps around CONCURRENCY)
+    let nextSlotIndex = 0;
+    try {
+        const batchResults = await Promise.all(batches.map((batch, batchIndex) => limit(async () => {
+            // Assign slot index (reuse slots as batches complete)
+            const slotIndex = nextSlotIndex++ % CONCURRENCY;
+            // Calculate cumulative chunk positions (with offset from prior batches)
+            const startChunk = chunkOffset + batchIndex * (batchSize ?? batch.length) + 1;
+            const endChunk = startChunk + batch.length - 1;
+            const batchInfo = `chunks ${startChunk}-${endChunk}`;
+            // Dispatch to Redux: mark slot as processing
+            if (!callbacks?.aborted) {
+                store.dispatch(SlotProgressActions.setSlotProcessing({
+                    index: slotIndex,
+                    batchInfo,
+                }));
+            }
+            // Callback for when this slot enters retry state
+            const onRetrying = (retryInfo) => {
+                if (callbacks?.aborted)
+                    return;
+                if (retryInfo) {
+                    store.dispatch(SlotProgressActions.setSlotRateLimited({
+                        index: slotIndex,
+                        batchInfo,
+                        retryInfo,
+                    }));
+                }
+                else {
+                    // Cleared - back to processing
+                    store.dispatch(SlotProgressActions.setSlotProcessing({
+                        index: slotIndex,
+                        batchInfo,
+                    }));
+                }
+            };
+            let result;
+            try {
+                result = await processBatch(batch, onRetrying);
+            }
+            catch (error) {
+                // Log detailed failure info before re-throwing
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                const batchMeta = batchMetadata?.[batchIndex];
+                // Log to debug.log with full chunk context
+                if (logger) {
+                    logger.error('api-utils', 'Batch failed after retries', {
+                        batchIndex,
+                        batchInfo,
+                        chunkCount: batch.length,
+                        files: batchMeta?.filepaths ?? [],
+                        lineRanges: batchMeta?.lineRanges ?? [],
+                        sizes: batchMeta?.sizes ?? [],
+                        error: errorMsg,
+                    });
+                }
+                // Dispatch failure to Redux for UI visibility
+                store.dispatch(SlotProgressActions.addFailure({
+                    batchInfo,
+                    error: errorMsg,
+                    timestamp: new Date().toISOString(),
+                }));
+                // Re-throw to trigger outer catch (abort and cleanup)
+                throw error;
+            }
+            // Skip updates if aborted (another batch failed)
+            if (callbacks?.aborted) {
+                store.dispatch(SlotProgressActions.setSlotIdle(slotIndex));
+                return result;
+            }
+            // Delay before releasing the slot (rate limit protection)
+            await sleep(BATCH_DELAY_MS);
+            // Dispatch to Redux: mark slot as idle
+            store.dispatch(SlotProgressActions.setSlotIdle(slotIndex));
+            // Report progress per-batch
+            processedItems += batch.length;
+            callbacks?.onBatchProgress?.(processedItems, totalItems);
+            return result;
+        })));
+        // Reset all slots when complete
+        store.dispatch(SlotProgressActions.resetSlots());
+        return batchResults.flat();
+    }
+    catch (error) {
+        // Set aborted flag to stop progress updates from other concurrent batches
+        // that are still completing in the background
+        if (callbacks) {
+            callbacks.aborted = true;
+        }
+        // Reset slots on error
+        store.dispatch(SlotProgressActions.resetSlots());
+        throw error;
+    }
+}
+/**
+ * Split an array into batches of a specified size.
+ */
+export function chunk(array, size) {
+    const batches = [];
+    for (let i = 0; i < array.length; i += size) {
+        batches.push(array.slice(i, i + size));
+    }
+    return batches;
+}

package/dist/rag/embeddings/gemini.d.ts

@@ -8,7 +8,7 @@
  *
  * Free tier available with generous limits.
  */
-import type { EmbeddingProvider, ModelProgressCallback } from './types.js';
+import type { EmbeddingProvider, ModelProgressCallback, EmbedOptions } from './types.js';
 /**
  * Gemini embedding provider.
  * Uses gemini-embedding-001 model via Google's Generative AI API.
@@ -17,19 +17,11 @@ export declare class GeminiEmbeddingProvider implements EmbeddingProvider {
     readonly dimensions = 1536;
     private apiKey;
     private initialized;
-    onThrottle?: (message: string | null) => void;
-    onBatchProgress?: (processed: number, total: number) => void;
+    onThrottle: ((message: string | null) => void) | undefined;
+    onBatchProgress: ((processed: number, total: number) => void) | undefined;
     constructor(apiKey?: string);
     initialize(_onProgress?: ModelProgressCallback): Promise<void>;
-    embed(texts: string[]): Promise<number[][]>;
-    /**
-     * Embed a batch with exponential backoff retry on rate limit errors.
-     */
-    private embedBatchWithRetry;
-    /**
-     * Check if an error is a rate limit error (429 or quota exceeded).
-     */
-    private isRateLimitError;
+    embed(texts: string[], options?: EmbedOptions): Promise<number[][]>;
     private embedBatch;
     embedSingle(text: string): Promise<number[]>;
     close(): void;

package/dist/rag/embeddings/gemini.js

@@ -8,19 +8,13 @@
  *
  * Free tier available with generous limits.
  */
+import { chunk, processBatchesWithLimit, withRetry, } from './api-utils.js';
 const GEMINI_API_BASE = 'https://generativelanguage.googleapis.com/v1beta/models';
 const MODEL = 'gemini-embedding-001';
 // Gemini limits: 2,048 tokens/text, 20,000 tokens/batch, 100-250 texts/batch
-// With avg ~1000 tokens/chunk, safe limit is 20 texts.
-const BATCH_SIZE = 20;
-// Concurrency and rate limiting
-const CONCURRENCY = 5; // Max concurrent API requests
-const MAX_RETRIES = 12; // Max retry attempts on rate limit
-const INITIAL_BACKOFF_MS = 1000; // Start at 1s
-const MAX_BACKOFF_MS = 60000; // Cap at 60s (1 min)
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
+// Chunks are ~2000 chars + context header ≈ 800-1000 tokens each
+// 16 chunks × 1000 tokens = 16,000 tokens (safe margin under 20k limit)
+const BATCH_SIZE = 16;
 /**
  * Gemini embedding provider.
  * Uses gemini-embedding-001 model via Google's Generative AI API.
@@ -50,14 +44,14 @@ export class GeminiEmbeddingProvider {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: undefined
         });
         // Callback for batch progress - (processed, total) chunks
         Object.defineProperty(this, "onBatchProgress", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: undefined
         });
         // Trim the key to remove any accidental whitespace
         this.apiKey = (apiKey ?? '').trim();
@@ -68,73 +62,29 @@ export class GeminiEmbeddingProvider {
         }
         this.initialized = true;
     }
-    async embed(texts) {
+    async embed(texts, options) {
         if (!this.initialized) {
             await this.initialize();
         }
         if (texts.length === 0) {
             return [];
         }
-        // Split into batches
-        const batches = [];
-        for (let i = 0; i < texts.length; i += BATCH_SIZE) {
-            batches.push(texts.slice(i, i + BATCH_SIZE));
-        }
-        // Process batches with limited concurrency
-        const results = [];
-        let completed = 0;
-        for (let i = 0; i < batches.length; i += CONCURRENCY) {
-            const concurrentBatches = batches.slice(i, i + CONCURRENCY);
-            // Fire concurrent requests
-            const batchResults = await Promise.all(concurrentBatches.map(batch => this.embedBatchWithRetry(batch)));
-            // Flatten and collect results (Promise.all preserves order)
-            for (const result of batchResults) {
-                results.push(...result);
-            }
-            // Report progress after concurrent group completes
-            completed += concurrentBatches.length;
-            const processed = Math.min(completed * BATCH_SIZE, texts.length);
-            this.onBatchProgress?.(processed, texts.length);
-        }
-        return results;
-    }
-    /**
-     * Embed a batch with exponential backoff retry on rate limit errors.
-     */
-    async embedBatchWithRetry(batch) {
-        let attempt = 0;
-        let backoffMs = INITIAL_BACKOFF_MS;
-        while (true) {
-            try {
-                const result = await this.embedBatch(batch);
-                // Clear throttle message on success (if was throttling)
-                if (attempt > 0)
-                    this.onThrottle?.(null);
-                return result;
-            }
-            catch (error) {
-                if (this.isRateLimitError(error) && attempt < MAX_RETRIES) {
-                    attempt++;
-                    const secs = Math.round(backoffMs / 1000);
-                    this.onThrottle?.(`Rate limited - retry ${attempt}/${MAX_RETRIES} in ${secs}s`);
-                    await sleep(backoffMs);
-                    backoffMs = Math.min(backoffMs * 2, MAX_BACKOFF_MS);
-                }
-                else {
-                    throw error;
-                }
-            }
-        }
-    }
-    /**
-     * Check if an error is a rate limit error (429 or quota exceeded).
-     */
-    isRateLimitError(error) {
-        if (error instanceof Error) {
-            const msg = error.message.toLowerCase();
-            return (msg.includes('429') || msg.includes('rate') || msg.includes('quota'));
+        const batches = chunk(texts, BATCH_SIZE);
+        const callbacks = {
+            onThrottle: this.onThrottle,
+            onBatchProgress: this.onBatchProgress,
+        };
+        // Convert chunk metadata to batch metadata if provided
+        let batchMetadata;
+        if (options?.chunkMetadata) {
+            const metaBatches = chunk(options.chunkMetadata, BATCH_SIZE);
+            batchMetadata = metaBatches.map(metaBatch => ({
+                filepaths: metaBatch.map(m => m.filepath),
+                lineRanges: metaBatch.map(m => ({ start: m.startLine, end: m.endLine })),
+                sizes: metaBatch.map(m => m.size),
+            }));
         }
-        return false;
+        return processBatchesWithLimit(batches, (batch, onRetrying) => withRetry(() => this.embedBatch(batch), callbacks, onRetrying), callbacks, BATCH_SIZE, batchMetadata, options?.logger, options?.chunkOffset ?? 0);
     }
     async embedBatch(texts) {
         const url = `${GEMINI_API_BASE}/${MODEL}:batchEmbedContents`;

package/dist/rag/embeddings/index.d.ts

@@ -4,8 +4,10 @@
  */
 export { GeminiEmbeddingProvider } from './gemini.js';
 export { Local4BEmbeddingProvider } from './local-4b.js';
-export { LocalEmbeddingProvider } from './local.js';
+export { LocalEmbeddingProvider, clearCachedPipeline } from './local.js';
 export { MistralEmbeddingProvider } from './mistral.js';
+export { MockEmbeddingProvider } from './mock.js';
 export { OpenAIEmbeddingProvider } from './openai.js';
-export { validateApiKey, type ValidationResult } from './validate.js';
-export type { EmbeddingProvider, ModelProgressCallback } from './types.js';
+export { validateApiKey, type ValidationResult, type ValidateApiKeyOptions, } from './validate.js';
+export type { EmbeddingProvider, ModelProgressCallback, ChunkMetadata, EmbedOptions, } from './types.js';
+export { CONCURRENCY, BATCH_DELAY_MS, MAX_RETRIES, INITIAL_BACKOFF_MS, MAX_BACKOFF_MS, sleep, isRateLimitError, isTransientApiError, isRetriableError, withRetry, processBatchesWithLimit, chunk, type ApiProviderCallbacks, type BatchMetadata, } from './api-utils.js';

package/dist/rag/embeddings/index.js

@@ -4,7 +4,10 @@
  */
 export { GeminiEmbeddingProvider } from './gemini.js';
 export { Local4BEmbeddingProvider } from './local-4b.js';
-export { LocalEmbeddingProvider } from './local.js';
+export { LocalEmbeddingProvider, clearCachedPipeline } from './local.js';
 export { MistralEmbeddingProvider } from './mistral.js';
+export { MockEmbeddingProvider } from './mock.js';
 export { OpenAIEmbeddingProvider } from './openai.js';
-export { validateApiKey } from './validate.js';
+export { validateApiKey, } from './validate.js';
+// Shared utilities for API-based providers
+export { CONCURRENCY, BATCH_DELAY_MS, MAX_RETRIES, INITIAL_BACKOFF_MS, MAX_BACKOFF_MS, sleep, isRateLimitError, isTransientApiError, isRetriableError, withRetry, processBatchesWithLimit, chunk, } from './api-utils.js';

package/dist/rag/embeddings/local-4b.d.ts

@@ -14,7 +14,7 @@
  * - 32K context window
  * - +5 MTEB points over 0.6B (69.45 vs 64.33)
  */
-import type { EmbeddingProvider, ModelProgressCallback } from './types.js';
+import type { EmbeddingProvider, ModelProgressCallback, EmbedOptions } from './types.js';
 /**
  * Local embedding provider using Qwen3-Embedding-4B FP32.
  * Currently throws an error - no compatible ONNX model available.
@@ -22,7 +22,7 @@ import type { EmbeddingProvider, ModelProgressCallback } from './types.js';
 export declare class Local4BEmbeddingProvider implements EmbeddingProvider {
     readonly dimensions = 2560;
     initialize(_onProgress?: ModelProgressCallback): Promise<void>;
-    embed(_texts: string[]): Promise<number[][]>;
+    embed(_texts: string[], _options?: EmbedOptions): Promise<number[][]>;
     embedSingle(_text: string): Promise<number[]>;
     close(): void;
 }

package/dist/rag/embeddings/local-4b.js

@@ -39,7 +39,7 @@ export class Local4BEmbeddingProvider {
     async initialize(_onProgress) {
         throw new Error(NOT_AVAILABLE_ERROR);
     }
-    async embed(_texts) {
+    async embed(_texts, _options) {
         throw new Error(NOT_AVAILABLE_ERROR);
     }
     async embedSingle(_text) {

package/dist/rag/embeddings/local.d.ts

@@ -13,16 +13,23 @@
  * - No per-token costs
  * - Data never leaves your machine
  */
-import type { EmbeddingProvider, ModelProgressCallback } from './types.js';
+import type { EmbeddingProvider, ModelProgressCallback, EmbedOptions } from './types.js';
+/**
+ * Clear the cached pipeline.
+ * Useful for tests that need to reset state between runs.
+ */
+export declare function clearCachedPipeline(): void;
 /**
  * Local embedding provider using Qwen3-Embedding-0.6B Q8.
  */
 export declare class LocalEmbeddingProvider implements EmbeddingProvider {
     readonly dimensions = 1024;
-    private extractor;
     private initialized;
+    /** Progress callback for per-chunk updates during embedding */
+    onBatchProgress: ((processed: number, total: number) => void) | undefined;
     initialize(onProgress?: ModelProgressCallback): Promise<void>;
-    embed(texts: string[]): Promise<number[][]>;
+    private loadModel;
+    embed(texts: string[], _options?: EmbedOptions): Promise<number[][]>;
     private embedBatch;
     embedSingle(text: string): Promise<number[]>;
     close(): void;