chore(pinecone): continue vector store refinements

Author: jddunn

src/rag/vector_stores/PineconeVectorStore.ts

@@ -88,7 +88,7 @@ export class PineconeVectorStore implements IVectorStore {
     if (this.isInitialized) return;
 
     // Ping the index to verify API key and host are correct.
-    const res = await this._fetch('/describe_index_stats', { method: 'POST', body: '{}' });
+    const res = await this._fetchWithRetry('/describe_index_stats', { method: 'POST', body: '{}' });
     if (!res.ok) {
       const body = await res.text().catch(() => 'unknown error');
       throw new Error(`Pinecone initialization failed (${res.status}): ${body}`);
@@ -110,7 +110,7 @@ export class PineconeVectorStore implements IVectorStore {
   /** Health check — verify index is reachable (legacy). */
   async healthCheck(): Promise<boolean> {
     try {
-      const res = await this._fetch('/describe_index_stats', { method: 'POST', body: '{}' });
+      const res = await this._fetchWithRetry('/describe_index_stats', { method: 'POST', body: '{}' });
       return res.ok;
     } catch {
       return false;
@@ -145,11 +145,7 @@ export class PineconeVectorStore implements IVectorStore {
    */
   async dropCollection(name: string): Promise<void> {
     await this._ensureInit();
-    const ns = name || this.config.namespace || '';
-    await this._fetch('/vectors/delete', {
-      method: 'POST',
-      body: JSON.stringify({ deleteAll: true, namespace: ns }),
-    });
+    await this.delete(name, undefined, { deleteAll: true });
   }
 
   // =========================================================================
@@ -464,7 +460,7 @@ export class PineconeVectorStore implements IVectorStore {
     }
 
     if (hasDeleteAll) {
-      await this._fetch('/vectors/delete', {
+      await this._fetchWithRetry('/vectors/delete', {
         method: 'POST',
         body: JSON.stringify({ deleteAll: true, namespace: ns }),
       });
@@ -477,7 +473,7 @@ export class PineconeVectorStore implements IVectorStore {
       let deleted = 0;
       for (let i = 0; i < ids.length; i += batchSize) {
         const batch = ids.slice(i, i + batchSize);
-        const res = await this._fetch('/vectors/delete', {
+        const res = await this._fetchWithRetry('/vectors/delete', {
           method: 'POST',
           body: JSON.stringify({ ids: batch, namespace: ns }),
         });
@@ -537,9 +533,6 @@ export class PineconeVectorStore implements IVectorStore {
 
   /**
    * Retry transient Pinecone failures with exponential backoff.
-   *
-   * This is intentionally scoped to metadata-heavy operations in this adapter,
-   * where Pinecone documents lower request-per-second limits.
    */
   private async _fetchWithRetry(
     path: string,

src/rag/vector_stores/__tests__/PineconeVectorStore.test.ts

@@ -145,6 +145,21 @@ describe('PineconeVectorStore', () => {
       await store.initialize();
       expect(fetchCalls.length).toBe(count);
     });
+
+    it('retries throttled initialization checks with exponential backoff', async () => {
+      vi.useFakeTimers();
+      fetchResponseQueue.push(errResponse(429, 'rate limited'));
+      fetchResponseQueue.push(okJson({ namespaces: {}, totalVectorCount: 0 }));
+      store = new PineconeVectorStore(makeConfig());
+
+      const initPromise = store.initialize();
+      await vi.runAllTimersAsync();
+      await initPromise;
+
+      expect(fetchCalls).toHaveLength(2);
+      expect(fetchCalls[0].url).toContain('/describe_index_stats');
+      expect(fetchCalls[1].url).toContain('/describe_index_stats');
+    });
   });
 
   // =========================================================================
@@ -550,6 +565,27 @@ describe('PineconeVectorStore', () => {
       expect(result.deletedCount).toBe(3);
     });
 
+    it('retries throttled ID deletes with exponential backoff', async () => {
+      fetchResponseQueue.push(okJson({})); // init
+      store = new PineconeVectorStore(makeConfig());
+      await store.initialize();
+      resetMocks();
+      vi.useFakeTimers();
+
+      fetchResponseQueue.push(errResponse(429, 'rate limited'));
+      fetchResponseQueue.push(okJson({}));
+
+      const resultPromise = store.delete('ns', ['a', 'b']);
+
+      await vi.runAllTimersAsync();
+      const result = await resultPromise;
+
+      expect(fetchCalls).toHaveLength(2);
+      expect(parseFetchBody(fetchCalls[0]).ids).toEqual(['a', 'b']);
+      expect(parseFetchBody(fetchCalls[1]).ids).toEqual(['a', 'b']);
+      expect(result.deletedCount).toBe(2);
+    });
+
     it('deleteAll sends deleteAll=true', async () => {
       fetchResponseQueue.push(okJson({})); // init
       store = new PineconeVectorStore(makeConfig());
@@ -564,6 +600,27 @@ describe('PineconeVectorStore', () => {
       expect(result.deletedCount).toBe(-1); // Pinecone doesn't return count.
     });
 
+    it('retries throttled deleteAll requests with exponential backoff', async () => {
+      fetchResponseQueue.push(okJson({})); // init
+      store = new PineconeVectorStore(makeConfig());
+      await store.initialize();
+      resetMocks();
+      vi.useFakeTimers();
+
+      fetchResponseQueue.push(errResponse(429, 'rate limited'));
+      fetchResponseQueue.push(okJson({}));
+
+      const resultPromise = store.delete('ns', undefined, { deleteAll: true });
+
+      await vi.runAllTimersAsync();
+      const result = await resultPromise;
+
+      expect(fetchCalls).toHaveLength(2);
+      expect(parseFetchBody(fetchCalls[0]).deleteAll).toBe(true);
+      expect(parseFetchBody(fetchCalls[1]).deleteAll).toBe(true);
+      expect(result.deletedCount).toBe(-1);
+    });
+
     it('deletes by metadata filter through /vectors/delete', async () => {
       fetchResponseQueue.push(okJson({})); // init
       store = new PineconeVectorStore(makeConfig());
@@ -711,9 +768,37 @@ describe('PineconeVectorStore', () => {
       store = new PineconeVectorStore(makeConfig());
       await store.initialize();
       resetMocks();
+      vi.useFakeTimers();
+
+      mockFetch
+        .mockRejectedValueOnce(new Error('network error'))
+        .mockRejectedValueOnce(new Error('network error'))
+        .mockRejectedValueOnce(new Error('network error'))
+        .mockRejectedValueOnce(new Error('network error'));
+
+      const healthPromise = store.healthCheck();
+      await vi.runAllTimersAsync();
 
-      mockFetch.mockRejectedValueOnce(new Error('network error'));
-      expect(await store.healthCheck()).toBe(false);
+      expect(await healthPromise).toBe(false);
+    });
+
+    it('retries throttled health checks with exponential backoff', async () => {
+      fetchResponseQueue.push(okJson({})); // init
+      store = new PineconeVectorStore(makeConfig());
+      await store.initialize();
+      resetMocks();
+      vi.useFakeTimers();
+
+      fetchResponseQueue.push(errResponse(429, 'rate limited'));
+      fetchResponseQueue.push(okJson({ namespaces: {}, totalVectorCount: 0 }));
+
+      const healthPromise = store.healthCheck();
+      await vi.runAllTimersAsync();
+
+      expect(await healthPromise).toBe(true);
+      expect(fetchCalls).toHaveLength(2);
+      expect(fetchCalls[0].url).toContain('/describe_index_stats');
+      expect(fetchCalls[1].url).toContain('/describe_index_stats');
     });
   });