@mastra/pinecone 0.2.11 → 0.2.12-alpha.1

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/pinecone@0.2.11-alpha.6 build /home/runner/work/mastra/mastra/stores/pinecone
+> @mastra/pinecone@0.2.12-alpha.1 build /home/runner/work/mastra/mastra/stores/pinecone
 > tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.4.0
 TSC Build start
-TSC ⚡️ Build success in 6549ms
+TSC ⚡️ Build success in 6837ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/pinecone/dist/_tsup-dts-rollup.d.ts
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/pinecone/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 9935ms
+DTS ⚡️ Build success in 8906ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.cjs 10.41 KB
-CJS ⚡️ Build success in 636ms
-ESM dist/index.js 10.35 KB
-ESM ⚡️ Build success in 859ms
+CJS dist/index.cjs 11.02 KB
+CJS ⚡️ Build success in 655ms
+ESM dist/index.js 10.96 KB
+ESM ⚡️ Build success in 655ms

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @mastra/pinecone
 
+## 0.2.12-alpha.1
+
+### Patch Changes
+
+- 9cd1a46: [MASTRA-3338] update naming scheme for embedding index based on vector store rules and added duplicate index checks
+- Updated dependencies [e450778]
+- Updated dependencies [8902157]
+- Updated dependencies [ca0dc88]
+- Updated dependencies [9cd1a46]
+- Updated dependencies [70dbf51]
+  - @mastra/core@0.9.3-alpha.1
+
+## 0.2.12-alpha.0
+
+### Patch Changes
+
+- Updated dependencies [526c570]
+- Updated dependencies [b5d2de0]
+- Updated dependencies [644f8ad]
+  - @mastra/core@0.9.3-alpha.0
+
 ## 0.2.11
 
 ### Patch Changes

package/dist/_tsup-dts-rollup.d.cts

@@ -49,6 +49,7 @@ declare interface PineconeUpsertVectorParams extends UpsertVectorParams {
 declare class PineconeVector extends MastraVector {
     private client;
     constructor(apiKey: string, environment?: string);
+    get indexSeparator(): string;
     createIndex(...args: ParamsToArgs<CreateIndexParams>): Promise<void>;
     upsert(...args: ParamsToArgs<PineconeUpsertVectorParams> | PineconeUpsertVectorArgs): Promise<string[]>;
     transformFilter(filter?: VectorFilter): VectorFilter;

package/dist/_tsup-dts-rollup.d.ts

@@ -49,6 +49,7 @@ declare interface PineconeUpsertVectorParams extends UpsertVectorParams {
 declare class PineconeVector extends MastraVector {
     private client;
     constructor(apiKey: string, environment?: string);
+    get indexSeparator(): string;
     createIndex(...args: ParamsToArgs<CreateIndexParams>): Promise<void>;
     upsert(...args: ParamsToArgs<PineconeUpsertVectorParams> | PineconeUpsertVectorArgs): Promise<string[]>;
     transformFilter(filter?: VectorFilter): VectorFilter;

package/dist/index.cjs

@@ -100,23 +100,38 @@ var PineconeVector = class extends vector.MastraVector {
       }
     }) ?? baseClient;
   }
+  get indexSeparator() {
+    return "-";
+  }
   async createIndex(...args) {
     const params = this.normalizeArgs("createIndex", args);
     const { indexName, dimension, metric = "cosine" } = params;
     if (!Number.isInteger(dimension) || dimension <= 0) {
       throw new Error("Dimension must be a positive integer");
     }
-    await this.client.createIndex({
-      name: indexName,
-      dimension,
-      metric,
-      spec: {
-        serverless: {
-          cloud: "aws",
-          region: "us-east-1"
+    if (metric && !["cosine", "euclidean", "dotproduct"].includes(metric)) {
+      throw new Error("Metric must be one of: cosine, euclidean, dotproduct");
+    }
+    try {
+      await this.client.createIndex({
+        name: indexName,
+        dimension,
+        metric,
+        spec: {
+          serverless: {
+            cloud: "aws",
+            region: "us-east-1"
+          }
         }
+      });
+    } catch (error) {
+      const message = error?.errors?.[0]?.message || error?.message;
+      if (error.status === 409 || typeof message === "string" && (message.toLowerCase().includes("already exists") || message.toLowerCase().includes("duplicate"))) {
+        await this.validateExistingIndex(indexName, dimension, metric);
+        return;
       }
-    });
+      throw error;
+    }
   }
   async upsert(...args) {
     const params = this.normalizeArgs("upsert", args, [

package/dist/index.js

@@ -98,23 +98,38 @@ var PineconeVector = class extends MastraVector {
       }
     }) ?? baseClient;
   }
+  get indexSeparator() {
+    return "-";
+  }
   async createIndex(...args) {
     const params = this.normalizeArgs("createIndex", args);
     const { indexName, dimension, metric = "cosine" } = params;
     if (!Number.isInteger(dimension) || dimension <= 0) {
       throw new Error("Dimension must be a positive integer");
     }
-    await this.client.createIndex({
-      name: indexName,
-      dimension,
-      metric,
-      spec: {
-        serverless: {
-          cloud: "aws",
-          region: "us-east-1"
+    if (metric && !["cosine", "euclidean", "dotproduct"].includes(metric)) {
+      throw new Error("Metric must be one of: cosine, euclidean, dotproduct");
+    }
+    try {
+      await this.client.createIndex({
+        name: indexName,
+        dimension,
+        metric,
+        spec: {
+          serverless: {
+            cloud: "aws",
+            region: "us-east-1"
+          }
         }
+      });
+    } catch (error) {
+      const message = error?.errors?.[0]?.message || error?.message;
+      if (error.status === 409 || typeof message === "string" && (message.toLowerCase().includes("already exists") || message.toLowerCase().includes("duplicate"))) {
+        await this.validateExistingIndex(indexName, dimension, metric);
+        return;
       }
-    });
+      throw error;
+    }
   }
   async upsert(...args) {
     const params = this.normalizeArgs("upsert", args, [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/pinecone",
-  "version": "0.2.11",
+  "version": "0.2.12-alpha.1",
   "description": "Pinecone vector store provider for Mastra",
   "type": "module",
   "main": "dist/index.js",
@@ -21,7 +21,7 @@
   "license": "MIT",
   "dependencies": {
     "@pinecone-database/pinecone": "^3.0.3",
-    "@mastra/core": "^0.9.2"
+    "@mastra/core": "^0.9.3-alpha.1"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.52.5",

package/src/vector/index.test.ts

@@ -555,6 +555,14 @@ describe.skip('PineconeVector Integration Tests', () => {
   });
 
   describe('Error Handling', () => {
+    const testIndexName = 'test-index-error';
+    beforeAll(async () => {
+      await vectorDB.createIndex({ indexName: testIndexName, dimension: 3 });
+    });
+
+    afterAll(async () => {
+      await vectorDB.deleteIndex(testIndexName);
+    });
     it('should handle non-existent index query gracefully', async () => {
       const nonExistentIndex = 'non-existent-index';
       await expect(vectorDB.query({ indexName: nonExistentIndex, queryVector: [1, 0, 0] })).rejects.toThrow();
@@ -564,6 +572,60 @@ describe.skip('PineconeVector Integration Tests', () => {
       const wrongDimVector = [[1, 0]]; // 2D vector for 3D index
       await expect(vectorDB.upsert({ indexName: testIndexName, vectors: wrongDimVector })).rejects.toThrow();
     }, 500000);
+
+    it('should handle duplicate index creation gracefully', async () => {
+      const duplicateIndexName = `duplicate-test`;
+      const dimension = 768;
+      const infoSpy = vi.spyOn(vectorDB['logger'], 'info');
+      const warnSpy = vi.spyOn(vectorDB['logger'], 'warn');
+
+      try {
+        // Create index first time
+        await vectorDB.createIndex({
+          indexName: duplicateIndexName,
+          dimension,
+          metric: 'cosine',
+        });
+
+        // Try to create with same dimensions - should not throw
+        await expect(
+          vectorDB.createIndex({
+            indexName: duplicateIndexName,
+            dimension,
+            metric: 'cosine',
+          }),
+        ).resolves.not.toThrow();
+
+        expect(infoSpy).toHaveBeenCalledWith(expect.stringContaining('already exists with'));
+
+        // Try to create with same dimensions and different metric - should not throw
+        await expect(
+          vectorDB.createIndex({
+            indexName: duplicateIndexName,
+            dimension,
+            metric: 'euclidean',
+          }),
+        ).resolves.not.toThrow();
+
+        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Attempted to create index with metric'));
+
+        // Try to create with different dimensions - should throw
+        await expect(
+          vectorDB.createIndex({
+            indexName: duplicateIndexName,
+            dimension: dimension + 1,
+            metric: 'cosine',
+          }),
+        ).rejects.toThrow(
+          `Index "${duplicateIndexName}" already exists with ${dimension} dimensions, but ${dimension + 1} dimensions were requested`,
+        );
+      } finally {
+        infoSpy.mockRestore();
+        warnSpy.mockRestore();
+        // Cleanup
+        await vectorDB.deleteIndex(duplicateIndexName);
+      }
+    });
   });
 
   describe('Performance Tests', () => {

package/src/vector/index.ts

@@ -61,6 +61,10 @@ export class PineconeVector extends MastraVector {
       }) ?? baseClient;
   }
 
+  get indexSeparator(): string {
+    return '-';
+  }
+
   async createIndex(...args: ParamsToArgs<CreateIndexParams>): Promise<void> {
     const params = this.normalizeArgs<CreateIndexParams>('createIndex', args);
 
@@ -69,17 +73,36 @@ export class PineconeVector extends MastraVector {
     if (!Number.isInteger(dimension) || dimension <= 0) {
       throw new Error('Dimension must be a positive integer');
     }
-    await this.client.createIndex({
-      name: indexName,
-      dimension: dimension,
-      metric: metric,
-      spec: {
-        serverless: {
-          cloud: 'aws',
-          region: 'us-east-1',
+    if (metric && !['cosine', 'euclidean', 'dotproduct'].includes(metric)) {
+      throw new Error('Metric must be one of: cosine, euclidean, dotproduct');
+    }
+    try {
+      await this.client.createIndex({
+        name: indexName,
+        dimension: dimension,
+        metric: metric,
+        spec: {
+          serverless: {
+            cloud: 'aws',
+            region: 'us-east-1',
+          },
         },
-      },
-    });
+      });
+    } catch (error: any) {
+      // Check for 'already exists' error
+      const message = error?.errors?.[0]?.message || error?.message;
+      if (
+        error.status === 409 ||
+        (typeof message === 'string' &&
+          (message.toLowerCase().includes('already exists') || message.toLowerCase().includes('duplicate')))
+      ) {
+        // Fetch index info and check dimensions
+        await this.validateExistingIndex(indexName, dimension, metric);
+        return;
+      }
+      // For any other errors, propagate
+      throw error;
+    }
   }
 
   async upsert(...args: ParamsToArgs<PineconeUpsertVectorParams> | PineconeUpsertVectorArgs): Promise<string[]> {