@mastra/pinecone 0.10.2-alpha.0 → 0.10.3-alpha.0

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/pinecone@0.10.2-alpha.0 build /home/runner/work/mastra/mastra/stores/pinecone
+> @mastra/pinecone@0.10.3-alpha.0 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.5.0
 TSC Build start
-TSC ⚡️ Build success in 5970ms
+TSC ⚡️ Build success in 6576ms
 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 9417ms
+DTS ⚡️ Build success in 9619ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.cjs 12.45 KB
-CJS ⚡️ Build success in 599ms
-ESM dist/index.js 12.38 KB
-ESM ⚡️ Build success in 599ms
+ESM dist/index.js 14.87 KB
+ESM ⚡️ Build success in 922ms
+CJS dist/index.cjs 15.11 KB
+CJS ⚡️ Build success in 923ms

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # @mastra/pinecone
 
+## 0.10.3-alpha.0
+
+### Patch Changes
+
+- 0e17048: Throw mastra errors in storage packages
+- Updated dependencies [d1baedb]
+- Updated dependencies [4d21bf2]
+- Updated dependencies [2097952]
+- Updated dependencies [4fb0cc2]
+- Updated dependencies [d2a7a31]
+- Updated dependencies [0e17048]
+  - @mastra/core@0.10.7-alpha.1
+
+## 0.10.2
+
+### Patch Changes
+
+- 66f4424: Update peerdeps
+- Updated dependencies [d1ed912]
+- Updated dependencies [f6fd25f]
+- Updated dependencies [dffb67b]
+- Updated dependencies [f1f1f1b]
+- Updated dependencies [925ab94]
+- Updated dependencies [f9816ae]
+- Updated dependencies [82090c1]
+- Updated dependencies [1b443fd]
+- Updated dependencies [ce97900]
+- Updated dependencies [f1309d3]
+- Updated dependencies [14a2566]
+- Updated dependencies [f7f8293]
+- Updated dependencies [48eddb9]
+  - @mastra/core@0.10.4
+
 ## 0.10.2-alpha.0
 
 ### Patch Changes

package/dist/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var error = require('@mastra/core/error');
 var vector = require('@mastra/core/vector');
 var pinecone = require('@pinecone-database/pinecone');
 var filter = require('@mastra/core/vector/filter');
@@ -109,11 +110,23 @@ var PineconeVector = class extends vector.MastraVector {
     return "-";
   }
   async createIndex({ indexName, dimension, metric = "cosine" }) {
-    if (!Number.isInteger(dimension) || dimension <= 0) {
-      throw new Error("Dimension must be a positive integer");
-    }
-    if (metric && !["cosine", "euclidean", "dotproduct"].includes(metric)) {
-      throw new Error("Metric must be one of: cosine, euclidean, dotproduct");
+    try {
+      if (!Number.isInteger(dimension) || dimension <= 0) {
+        throw new Error("Dimension must be a positive integer");
+      }
+      if (metric && !["cosine", "euclidean", "dotproduct"].includes(metric)) {
+        throw new Error("Metric must be one of: cosine, euclidean, dotproduct");
+      }
+    } catch (validationError) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_PINECONE_VECTOR_CREATE_INDEX_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { indexName, dimension, metric }
+        },
+        validationError
+      );
     }
     try {
       await this.client.createIndex({
@@ -127,13 +140,21 @@ var PineconeVector = class extends vector.MastraVector {
           }
         }
       });
-    } 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"))) {
+    } catch (error$1) {
+      const message = error$1?.errors?.[0]?.message || error$1?.message;
+      if (error$1.status === 409 || typeof message === "string" && (message.toLowerCase().includes("already exists") || message.toLowerCase().includes("duplicate"))) {
         await this.validateExistingIndex(indexName, dimension, metric);
         return;
       }
-      throw error;
+      throw new error.MastraError(
+        {
+          id: "STORAGE_PINECONE_VECTOR_CREATE_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName, dimension, metric }
+        },
+        error$1
+      );
     }
   }
   async upsert({
@@ -153,11 +174,23 @@ var PineconeVector = class extends vector.MastraVector {
       metadata: metadata?.[i] || {}
     }));
     const batchSize = 100;
-    for (let i = 0; i < records.length; i += batchSize) {
-      const batch = records.slice(i, i + batchSize);
-      await index.upsert(batch);
+    try {
+      for (let i = 0; i < records.length; i += batchSize) {
+        const batch = records.slice(i, i + batchSize);
+        await index.upsert(batch);
+      }
+      return vectorIds;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_PINECONE_VECTOR_UPSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName, vectorCount: vectors.length }
+        },
+        error$1
+      );
     }
-    return vectorIds;
   }
   transformFilter(filter) {
     const translator = new PineconeFilterTranslator();
@@ -184,17 +217,40 @@ var PineconeVector = class extends vector.MastraVector {
     if (sparseVector) {
       queryParams.sparseVector = sparseVector;
     }
-    const results = await index.query(queryParams);
-    return results.matches.map((match) => ({
-      id: match.id,
-      score: match.score || 0,
-      metadata: match.metadata,
-      ...includeVector && { vector: match.values || [] }
-    }));
+    try {
+      const results = await index.query(queryParams);
+      return results.matches.map((match) => ({
+        id: match.id,
+        score: match.score || 0,
+        metadata: match.metadata,
+        ...includeVector && { vector: match.values || [] }
+      }));
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_PINECONE_VECTOR_QUERY_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName, topK }
+        },
+        error$1
+      );
+    }
   }
   async listIndexes() {
-    const indexesResult = await this.client.listIndexes();
-    return indexesResult?.indexes?.map((index) => index.name) || [];
+    try {
+      const indexesResult = await this.client.listIndexes();
+      return indexesResult?.indexes?.map((index) => index.name) || [];
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_PINECONE_VECTOR_LIST_INDEXES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
   }
   /**
    * Retrieves statistics about a vector index.
@@ -203,21 +259,41 @@ var PineconeVector = class extends vector.MastraVector {
    * @returns A promise that resolves to the index statistics including dimension, count and metric
    */
   async describeIndex({ indexName }) {
-    const index = this.client.Index(indexName);
-    const stats = await index.describeIndexStats();
-    const description = await this.client.describeIndex(indexName);
-    return {
-      dimension: description.dimension,
-      count: stats.totalRecordCount || 0,
-      metric: description.metric,
-      namespaces: stats.namespaces
-    };
+    try {
+      const index = this.client.Index(indexName);
+      const stats = await index.describeIndexStats();
+      const description = await this.client.describeIndex(indexName);
+      return {
+        dimension: description.dimension,
+        count: stats.totalRecordCount || 0,
+        metric: description.metric,
+        namespaces: stats.namespaces
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_PINECONE_VECTOR_DESCRIBE_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error$1
+      );
+    }
   }
   async deleteIndex({ indexName }) {
     try {
       await this.client.deleteIndex(indexName);
-    } catch (error) {
-      throw new Error(`Failed to delete Pinecone index: ${error.message}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_PINECONE_VECTOR_DELETE_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error$1
+      );
     }
   }
   /**
@@ -232,10 +308,16 @@ var PineconeVector = class extends vector.MastraVector {
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
   async updateVector({ indexName, id, update, namespace }) {
+    if (!update.vector && !update.metadata) {
+      throw new error.MastraError({
+        id: "STORAGE_PINECONE_VECTOR_UPDATE_VECTOR_INVALID_ARGS",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: "No updates provided",
+        details: { indexName, id }
+      });
+    }
     try {
-      if (!update.vector && !update.metadata) {
-        throw new Error("No updates provided");
-      }
       const index = this.client.Index(indexName).namespace(namespace || "");
       const updateObj = { id };
       if (update.vector) {
@@ -245,8 +327,16 @@ var PineconeVector = class extends vector.MastraVector {
         updateObj.metadata = update.metadata;
       }
       await index.update(updateObj);
-    } catch (error) {
-      throw new Error(`Failed to update vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_PINECONE_VECTOR_UPDATE_VECTOR_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName, id }
+        },
+        error$1
+      );
     }
   }
   /**
@@ -261,8 +351,16 @@ var PineconeVector = class extends vector.MastraVector {
     try {
       const index = this.client.Index(indexName).namespace(namespace || "");
       await index.deleteOne(id);
-    } catch (error) {
-      throw new Error(`Failed to delete vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_PINECONE_VECTOR_DELETE_VECTOR_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName, id }
+        },
+        error$1
+      );
     }
   }
 };

package/dist/index.js

@@ -1,3 +1,4 @@
+import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
 import { MastraVector } from '@mastra/core/vector';
 import { Pinecone } from '@pinecone-database/pinecone';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
@@ -107,11 +108,23 @@ var PineconeVector = class extends MastraVector {
     return "-";
   }
   async createIndex({ indexName, dimension, metric = "cosine" }) {
-    if (!Number.isInteger(dimension) || dimension <= 0) {
-      throw new Error("Dimension must be a positive integer");
-    }
-    if (metric && !["cosine", "euclidean", "dotproduct"].includes(metric)) {
-      throw new Error("Metric must be one of: cosine, euclidean, dotproduct");
+    try {
+      if (!Number.isInteger(dimension) || dimension <= 0) {
+        throw new Error("Dimension must be a positive integer");
+      }
+      if (metric && !["cosine", "euclidean", "dotproduct"].includes(metric)) {
+        throw new Error("Metric must be one of: cosine, euclidean, dotproduct");
+      }
+    } catch (validationError) {
+      throw new MastraError(
+        {
+          id: "STORAGE_PINECONE_VECTOR_CREATE_INDEX_INVALID_ARGS",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { indexName, dimension, metric }
+        },
+        validationError
+      );
     }
     try {
       await this.client.createIndex({
@@ -131,7 +144,15 @@ var PineconeVector = class extends MastraVector {
         await this.validateExistingIndex(indexName, dimension, metric);
         return;
       }
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_PINECONE_VECTOR_CREATE_INDEX_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, dimension, metric }
+        },
+        error
+      );
     }
   }
   async upsert({
@@ -151,11 +172,23 @@ var PineconeVector = class extends MastraVector {
       metadata: metadata?.[i] || {}
     }));
     const batchSize = 100;
-    for (let i = 0; i < records.length; i += batchSize) {
-      const batch = records.slice(i, i + batchSize);
-      await index.upsert(batch);
+    try {
+      for (let i = 0; i < records.length; i += batchSize) {
+        const batch = records.slice(i, i + batchSize);
+        await index.upsert(batch);
+      }
+      return vectorIds;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_PINECONE_VECTOR_UPSERT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, vectorCount: vectors.length }
+        },
+        error
+      );
     }
-    return vectorIds;
   }
   transformFilter(filter) {
     const translator = new PineconeFilterTranslator();
@@ -182,17 +215,40 @@ var PineconeVector = class extends MastraVector {
     if (sparseVector) {
       queryParams.sparseVector = sparseVector;
     }
-    const results = await index.query(queryParams);
-    return results.matches.map((match) => ({
-      id: match.id,
-      score: match.score || 0,
-      metadata: match.metadata,
-      ...includeVector && { vector: match.values || [] }
-    }));
+    try {
+      const results = await index.query(queryParams);
+      return results.matches.map((match) => ({
+        id: match.id,
+        score: match.score || 0,
+        metadata: match.metadata,
+        ...includeVector && { vector: match.values || [] }
+      }));
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_PINECONE_VECTOR_QUERY_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, topK }
+        },
+        error
+      );
+    }
   }
   async listIndexes() {
-    const indexesResult = await this.client.listIndexes();
-    return indexesResult?.indexes?.map((index) => index.name) || [];
+    try {
+      const indexesResult = await this.client.listIndexes();
+      return indexesResult?.indexes?.map((index) => index.name) || [];
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_PINECONE_VECTOR_LIST_INDEXES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
   }
   /**
    * Retrieves statistics about a vector index.
@@ -201,21 +257,41 @@ var PineconeVector = class extends MastraVector {
    * @returns A promise that resolves to the index statistics including dimension, count and metric
    */
   async describeIndex({ indexName }) {
-    const index = this.client.Index(indexName);
-    const stats = await index.describeIndexStats();
-    const description = await this.client.describeIndex(indexName);
-    return {
-      dimension: description.dimension,
-      count: stats.totalRecordCount || 0,
-      metric: description.metric,
-      namespaces: stats.namespaces
-    };
+    try {
+      const index = this.client.Index(indexName);
+      const stats = await index.describeIndexStats();
+      const description = await this.client.describeIndex(indexName);
+      return {
+        dimension: description.dimension,
+        count: stats.totalRecordCount || 0,
+        metric: description.metric,
+        namespaces: stats.namespaces
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_PINECONE_VECTOR_DESCRIBE_INDEX_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error
+      );
+    }
   }
   async deleteIndex({ indexName }) {
     try {
       await this.client.deleteIndex(indexName);
     } catch (error) {
-      throw new Error(`Failed to delete Pinecone index: ${error.message}`);
+      throw new MastraError(
+        {
+          id: "STORAGE_PINECONE_VECTOR_DELETE_INDEX_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error
+      );
     }
   }
   /**
@@ -230,10 +306,16 @@ var PineconeVector = class extends MastraVector {
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
   async updateVector({ indexName, id, update, namespace }) {
+    if (!update.vector && !update.metadata) {
+      throw new MastraError({
+        id: "STORAGE_PINECONE_VECTOR_UPDATE_VECTOR_INVALID_ARGS",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: "No updates provided",
+        details: { indexName, id }
+      });
+    }
     try {
-      if (!update.vector && !update.metadata) {
-        throw new Error("No updates provided");
-      }
       const index = this.client.Index(indexName).namespace(namespace || "");
       const updateObj = { id };
       if (update.vector) {
@@ -244,7 +326,15 @@ var PineconeVector = class extends MastraVector {
       }
       await index.update(updateObj);
     } catch (error) {
-      throw new Error(`Failed to update vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+      throw new MastraError(
+        {
+          id: "STORAGE_PINECONE_VECTOR_UPDATE_VECTOR_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, id }
+        },
+        error
+      );
     }
   }
   /**
@@ -260,7 +350,15 @@ var PineconeVector = class extends MastraVector {
       const index = this.client.Index(indexName).namespace(namespace || "");
       await index.deleteOne(id);
     } catch (error) {
-      throw new Error(`Failed to delete vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+      throw new MastraError(
+        {
+          id: "STORAGE_PINECONE_VECTOR_DELETE_VECTOR_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, id }
+        },
+        error
+      );
     }
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/pinecone",
-  "version": "0.10.2-alpha.0",
+  "version": "0.10.3-alpha.0",
   "description": "Pinecone vector store provider for Mastra",
   "type": "module",
   "main": "dist/index.js",
@@ -24,14 +24,14 @@
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.52.8",
-    "@types/node": "^20.17.57",
+    "@types/node": "^20.19.0",
     "dotenv": "^16.5.0",
     "eslint": "^9.28.0",
     "tsup": "^8.5.0",
-    "typescript": "^5.8.2",
-    "vitest": "^3.2.2",
-    "@internal/lint": "0.0.10",
-    "@mastra/core": "0.10.4-alpha.3"
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.3",
+    "@internal/lint": "0.0.13",
+    "@mastra/core": "0.10.7-alpha.1"
   },
   "peerDependencies": {
     "@mastra/core": ">=0.10.4-0 <0.11.0"

package/src/vector/index.ts

@@ -1,3 +1,4 @@
+import { MastraError, ErrorDomain, ErrorCategory } from '@mastra/core/error';
 import { MastraVector } from '@mastra/core/vector';
 import type {
   QueryResult,
@@ -73,12 +74,25 @@ export class PineconeVector extends MastraVector {
   }
 
   async createIndex({ indexName, dimension, metric = 'cosine' }: CreateIndexParams): Promise<void> {
-    if (!Number.isInteger(dimension) || dimension <= 0) {
-      throw new Error('Dimension must be a positive integer');
-    }
-    if (metric && !['cosine', 'euclidean', 'dotproduct'].includes(metric)) {
-      throw new Error('Metric must be one of: cosine, euclidean, dotproduct');
+    try {
+      if (!Number.isInteger(dimension) || dimension <= 0) {
+        throw new Error('Dimension must be a positive integer');
+      }
+      if (metric && !['cosine', 'euclidean', 'dotproduct'].includes(metric)) {
+        throw new Error('Metric must be one of: cosine, euclidean, dotproduct');
+      }
+    } catch (validationError) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_PINECONE_VECTOR_CREATE_INDEX_INVALID_ARGS',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { indexName, dimension, metric },
+        },
+        validationError,
+      );
     }
+
     try {
       await this.client.createIndex({
         name: indexName,
@@ -103,8 +117,16 @@ export class PineconeVector extends MastraVector {
         await this.validateExistingIndex(indexName, dimension, metric);
         return;
       }
-      // For any other errors, propagate
-      throw error;
+      // For any other errors, wrap in MastraError
+      throw new MastraError(
+        {
+          id: 'STORAGE_PINECONE_VECTOR_CREATE_INDEX_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, dimension, metric },
+        },
+        error,
+      );
     }
   }
 
@@ -130,12 +152,24 @@ export class PineconeVector extends MastraVector {
 
     // Pinecone has a limit of 100 vectors per upsert request
     const batchSize = 100;
-    for (let i = 0; i < records.length; i += batchSize) {
-      const batch = records.slice(i, i + batchSize);
-      await index.upsert(batch);
-    }
+    try {
+      for (let i = 0; i < records.length; i += batchSize) {
+        const batch = records.slice(i, i + batchSize);
+        await index.upsert(batch);
+      }
 
-    return vectorIds;
+      return vectorIds;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_PINECONE_VECTOR_UPSERT_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, vectorCount: vectors.length },
+        },
+        error,
+      );
+    }
   }
 
   transformFilter(filter?: VectorFilter) {
@@ -169,19 +203,42 @@ export class PineconeVector extends MastraVector {
       queryParams.sparseVector = sparseVector;
     }
 
-    const results = await index.query(queryParams);
-
-    return results.matches.map(match => ({
-      id: match.id,
-      score: match.score || 0,
-      metadata: match.metadata as Record<string, any>,
-      ...(includeVector && { vector: match.values || [] }),
-    }));
+    try {
+      const results = await index.query(queryParams);
+
+      return results.matches.map(match => ({
+        id: match.id,
+        score: match.score || 0,
+        metadata: match.metadata as Record<string, any>,
+        ...(includeVector && { vector: match.values || [] }),
+      }));
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_PINECONE_VECTOR_QUERY_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, topK },
+        },
+        error,
+      );
+    }
   }
 
   async listIndexes(): Promise<string[]> {
-    const indexesResult = await this.client.listIndexes();
-    return indexesResult?.indexes?.map(index => index.name) || [];
+    try {
+      const indexesResult = await this.client.listIndexes();
+      return indexesResult?.indexes?.map(index => index.name) || [];
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_PINECONE_VECTOR_LIST_INDEXES_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+        },
+        error,
+      );
+    }
   }
 
   /**
@@ -191,23 +248,43 @@ export class PineconeVector extends MastraVector {
    * @returns A promise that resolves to the index statistics including dimension, count and metric
    */
   async describeIndex({ indexName }: DescribeIndexParams): Promise<PineconeIndexStats> {
-    const index = this.client.Index(indexName);
-    const stats = await index.describeIndexStats();
-    const description = await this.client.describeIndex(indexName);
-
-    return {
-      dimension: description.dimension,
-      count: stats.totalRecordCount || 0,
-      metric: description.metric as 'cosine' | 'euclidean' | 'dotproduct',
-      namespaces: stats.namespaces,
-    };
+    try {
+      const index = this.client.Index(indexName);
+      const stats = await index.describeIndexStats();
+      const description = await this.client.describeIndex(indexName);
+
+      return {
+        dimension: description.dimension,
+        count: stats.totalRecordCount || 0,
+        metric: description.metric as 'cosine' | 'euclidean' | 'dotproduct',
+        namespaces: stats.namespaces,
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_PINECONE_VECTOR_DESCRIBE_INDEX_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName },
+        },
+        error,
+      );
+    }
   }
 
   async deleteIndex({ indexName }: DeleteIndexParams): Promise<void> {
     try {
       await this.client.deleteIndex(indexName);
-    } catch (error: any) {
-      throw new Error(`Failed to delete Pinecone index: ${error.message}`);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_PINECONE_VECTOR_DELETE_INDEX_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName },
+        },
+        error,
+      );
     }
   }
 
@@ -223,11 +300,17 @@ export class PineconeVector extends MastraVector {
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
   async updateVector({ indexName, id, update, namespace }: PineconeUpdateVectorParams): Promise<void> {
-    try {
-      if (!update.vector && !update.metadata) {
-        throw new Error('No updates provided');
-      }
+    if (!update.vector && !update.metadata) {
+      throw new MastraError({
+        id: 'STORAGE_PINECONE_VECTOR_UPDATE_VECTOR_INVALID_ARGS',
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: 'No updates provided',
+        details: { indexName, id },
+      });
+    }
 
+    try {
       const index = this.client.Index(indexName).namespace(namespace || '');
 
       const updateObj: UpdateOptions = { id };
@@ -241,8 +324,16 @@ export class PineconeVector extends MastraVector {
       }
 
       await index.update(updateObj);
-    } catch (error: any) {
-      throw new Error(`Failed to update vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_PINECONE_VECTOR_UPDATE_VECTOR_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, id },
+        },
+        error,
+      );
     }
   }
 
@@ -258,8 +349,16 @@ export class PineconeVector extends MastraVector {
     try {
       const index = this.client.Index(indexName).namespace(namespace || '');
       await index.deleteOne(id);
-    } catch (error: any) {
-      throw new Error(`Failed to delete vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_PINECONE_VECTOR_DELETE_VECTOR_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, id },
+        },
+        error,
+      );
     }
   }
 }