@mastra/pinecone 0.10.2 → 0.11.0-alpha.1

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.11.0-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.5.0
 TSC Build start
-TSC ⚡️ Build success in 5926ms
+TSC ⚡️ Build success in 7566ms
 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 8809ms
+DTS ⚡️ Build success in 9021ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 12.38 KB
-ESM ⚡️ Build success in 495ms
-CJS dist/index.cjs 12.45 KB
-CJS ⚡️ Build success in 631ms
+ESM dist/index.js 14.87 KB
+ESM ⚡️ Build success in 712ms
+CJS dist/index.cjs 15.11 KB
+CJS ⚡️ Build success in 712ms

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @mastra/pinecone
 
+## 0.11.0-alpha.1
+
+### Minor Changes
+
+- 8a3bfd2: Update peerdeps to latest core
+
+### Patch Changes
+
+- Updated dependencies [792c4c0]
+- Updated dependencies [502fe05]
+- Updated dependencies [4efcfa0]
+  - @mastra/core@0.10.7-alpha.3
+
+## 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

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

@@ -1,12 +1,17 @@
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import type { BlacklistedRootOperators } from '@mastra/core/vector/filter';
 import type { CreateIndexParams } from '@mastra/core/vector';
 import type { DeleteIndexParams } from '@mastra/core/vector';
 import type { DeleteVectorParams } from '@mastra/core/vector';
 import type { DescribeIndexParams } from '@mastra/core/vector';
+import type { FilterValue } from '@mastra/core/vector/filter';
 import type { IndexStats } from '@mastra/core/vector';
 import type { IndexStatsDescription } from '@pinecone-database/pinecone';
+import type { LogicalOperatorValueMap } from '@mastra/core/vector/filter';
 import { MastraVector } from '@mastra/core/vector';
+import type { OperatorCondition } from '@mastra/core/vector/filter';
 import type { OperatorSupport } from '@mastra/core/vector/filter';
+import type { OperatorValueMap } from '@mastra/core/vector/filter';
 import type { QueryResult } from '@mastra/core/vector';
 import type { QueryVectorParams } from '@mastra/core/vector';
 import type { RecordSparseValues } from '@pinecone-database/pinecone';
@@ -14,6 +19,14 @@ import type { UpdateVectorParams } from '@mastra/core/vector';
 import type { UpsertVectorParams } from '@mastra/core/vector';
 import type { VectorFilter } from '@mastra/core/vector/filter';
 
+declare type InitialOperatorValueMap = Omit<OperatorValueMap, '$regex' | '$options' | '$elemMatch' | '$all'> & {
+    $contains: string;
+    $gt: number | Date;
+    $gte: number | Date;
+    $lt: number | Date;
+    $lte: number | Date;
+};
+
 /**
  * Vector store specific prompt that details supported operators and examples.
  * This prompt helps users construct valid filters for Pinecone Vector.
@@ -22,13 +35,15 @@ declare const PINECONE_PROMPT = "When querying Pinecone, you can ONLY use the op
 export { PINECONE_PROMPT }
 export { PINECONE_PROMPT as PINECONE_PROMPT_alias_1 }
 
+declare type PineconeBlacklisted = BlacklistedRootOperators | '$not' | '$nor';
+
 declare interface PineconeDeleteVectorParams extends DeleteVectorParams {
     namespace?: string;
 }
 
-export declare class PineconeFilterTranslator extends BaseFilterTranslator {
+export declare class PineconeFilterTranslator extends BaseFilterTranslator<PineconeVectorFilter> {
     protected getSupportedOperators(): OperatorSupport;
-    translate(filter?: VectorFilter): VectorFilter;
+    translate(filter?: PineconeVectorFilter): PineconeVectorFilter;
     private translateNode;
     private translateOperator;
 }
@@ -37,7 +52,13 @@ declare interface PineconeIndexStats extends IndexStats {
     namespaces?: IndexStatsDescription['namespaces'];
 }
 
-declare interface PineconeQueryVectorParams extends QueryVectorParams {
+declare type PineconeLogicalOperatorValueMap = Omit<LogicalOperatorValueMap, '$not' | '$nor'>;
+
+declare type PineconeOperatorValueMap = InitialOperatorValueMap & {
+    $all: OperatorCondition<keyof InitialOperatorValueMap, InitialOperatorValueMap>[] | FilterValue[];
+};
+
+declare interface PineconeQueryVectorParams extends QueryVectorParams<PineconeVectorFilter> {
     namespace?: string;
     sparseVector?: RecordSparseValues;
 }
@@ -51,7 +72,7 @@ declare interface PineconeUpsertVectorParams extends UpsertVectorParams {
     sparseVectors?: RecordSparseValues[];
 }
 
-declare class PineconeVector extends MastraVector {
+declare class PineconeVector extends MastraVector<PineconeVectorFilter> {
     private client;
     /**
      * Creates a new PineconeVector client.
@@ -65,7 +86,7 @@ declare class PineconeVector extends MastraVector {
     get indexSeparator(): string;
     createIndex({ indexName, dimension, metric }: CreateIndexParams): Promise<void>;
     upsert({ indexName, vectors, metadata, ids, namespace, sparseVectors, }: PineconeUpsertVectorParams): Promise<string[]>;
-    transformFilter(filter?: VectorFilter): VectorFilter;
+    transformFilter(filter?: PineconeVectorFilter): PineconeVectorFilter;
     query({ indexName, queryVector, topK, filter, includeVector, namespace, sparseVector, }: PineconeQueryVectorParams): Promise<QueryResult[]>;
     listIndexes(): Promise<string[]>;
     /**
@@ -101,4 +122,6 @@ declare class PineconeVector extends MastraVector {
 export { PineconeVector }
 export { PineconeVector as PineconeVector_alias_1 }
 
+export declare type PineconeVectorFilter = VectorFilter<keyof PineconeOperatorValueMap, PineconeOperatorValueMap, PineconeLogicalOperatorValueMap, PineconeBlacklisted>;
+
 export { }

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

@@ -1,12 +1,17 @@
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import type { BlacklistedRootOperators } from '@mastra/core/vector/filter';
 import type { CreateIndexParams } from '@mastra/core/vector';
 import type { DeleteIndexParams } from '@mastra/core/vector';
 import type { DeleteVectorParams } from '@mastra/core/vector';
 import type { DescribeIndexParams } from '@mastra/core/vector';
+import type { FilterValue } from '@mastra/core/vector/filter';
 import type { IndexStats } from '@mastra/core/vector';
 import type { IndexStatsDescription } from '@pinecone-database/pinecone';
+import type { LogicalOperatorValueMap } from '@mastra/core/vector/filter';
 import { MastraVector } from '@mastra/core/vector';
+import type { OperatorCondition } from '@mastra/core/vector/filter';
 import type { OperatorSupport } from '@mastra/core/vector/filter';
+import type { OperatorValueMap } from '@mastra/core/vector/filter';
 import type { QueryResult } from '@mastra/core/vector';
 import type { QueryVectorParams } from '@mastra/core/vector';
 import type { RecordSparseValues } from '@pinecone-database/pinecone';
@@ -14,6 +19,14 @@ import type { UpdateVectorParams } from '@mastra/core/vector';
 import type { UpsertVectorParams } from '@mastra/core/vector';
 import type { VectorFilter } from '@mastra/core/vector/filter';
 
+declare type InitialOperatorValueMap = Omit<OperatorValueMap, '$regex' | '$options' | '$elemMatch' | '$all'> & {
+    $contains: string;
+    $gt: number | Date;
+    $gte: number | Date;
+    $lt: number | Date;
+    $lte: number | Date;
+};
+
 /**
  * Vector store specific prompt that details supported operators and examples.
  * This prompt helps users construct valid filters for Pinecone Vector.
@@ -22,13 +35,15 @@ declare const PINECONE_PROMPT = "When querying Pinecone, you can ONLY use the op
 export { PINECONE_PROMPT }
 export { PINECONE_PROMPT as PINECONE_PROMPT_alias_1 }
 
+declare type PineconeBlacklisted = BlacklistedRootOperators | '$not' | '$nor';
+
 declare interface PineconeDeleteVectorParams extends DeleteVectorParams {
     namespace?: string;
 }
 
-export declare class PineconeFilterTranslator extends BaseFilterTranslator {
+export declare class PineconeFilterTranslator extends BaseFilterTranslator<PineconeVectorFilter> {
     protected getSupportedOperators(): OperatorSupport;
-    translate(filter?: VectorFilter): VectorFilter;
+    translate(filter?: PineconeVectorFilter): PineconeVectorFilter;
     private translateNode;
     private translateOperator;
 }
@@ -37,7 +52,13 @@ declare interface PineconeIndexStats extends IndexStats {
     namespaces?: IndexStatsDescription['namespaces'];
 }
 
-declare interface PineconeQueryVectorParams extends QueryVectorParams {
+declare type PineconeLogicalOperatorValueMap = Omit<LogicalOperatorValueMap, '$not' | '$nor'>;
+
+declare type PineconeOperatorValueMap = InitialOperatorValueMap & {
+    $all: OperatorCondition<keyof InitialOperatorValueMap, InitialOperatorValueMap>[] | FilterValue[];
+};
+
+declare interface PineconeQueryVectorParams extends QueryVectorParams<PineconeVectorFilter> {
     namespace?: string;
     sparseVector?: RecordSparseValues;
 }
@@ -51,7 +72,7 @@ declare interface PineconeUpsertVectorParams extends UpsertVectorParams {
     sparseVectors?: RecordSparseValues[];
 }
 
-declare class PineconeVector extends MastraVector {
+declare class PineconeVector extends MastraVector<PineconeVectorFilter> {
     private client;
     /**
      * Creates a new PineconeVector client.
@@ -65,7 +86,7 @@ declare class PineconeVector extends MastraVector {
     get indexSeparator(): string;
     createIndex({ indexName, dimension, metric }: CreateIndexParams): Promise<void>;
     upsert({ indexName, vectors, metadata, ids, namespace, sparseVectors, }: PineconeUpsertVectorParams): Promise<string[]>;
-    transformFilter(filter?: VectorFilter): VectorFilter;
+    transformFilter(filter?: PineconeVectorFilter): PineconeVectorFilter;
     query({ indexName, queryVector, topK, filter, includeVector, namespace, sparseVector, }: PineconeQueryVectorParams): Promise<QueryResult[]>;
     listIndexes(): Promise<string[]>;
     /**
@@ -101,4 +122,6 @@ declare class PineconeVector extends MastraVector {
 export { PineconeVector }
 export { PineconeVector as PineconeVector_alias_1 }
 
+export declare type PineconeVectorFilter = VectorFilter<keyof PineconeOperatorValueMap, PineconeOperatorValueMap, PineconeLogicalOperatorValueMap, PineconeBlacklisted>;
+
 export { }

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",
+  "version": "0.11.0-alpha.1",
   "description": "Pinecone vector store provider for Mastra",
   "type": "module",
   "main": "dist/index.js",
@@ -24,17 +24,17 @@
   },
   "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",
+    "eslint": "^9.29.0",
     "tsup": "^8.5.0",
-    "typescript": "^5.8.2",
-    "vitest": "^3.2.2",
-    "@internal/lint": "0.0.11",
-    "@mastra/core": "0.10.4"
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.3",
+    "@internal/lint": "0.0.13",
+    "@mastra/core": "0.10.7-alpha.3"
   },
   "peerDependencies": {
-    "@mastra/core": ">=0.10.4-0 <0.11.0"
+    "@mastra/core": ">=0.10.7-0 <0.11.0-0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",

package/src/vector/filter.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 
+import type { PineconeVectorFilter } from './filter';
 import { PineconeFilterTranslator } from './filter';
 
 describe('PineconeFilterTranslator', () => {
@@ -13,17 +14,17 @@ describe('PineconeFilterTranslator', () => {
   describe('basic operations', () => {
     it('handles empty filters', () => {
       expect(translator.translate({})).toEqual({});
-      expect(translator.translate(null as any)).toEqual(null);
-      expect(translator.translate(undefined as any)).toEqual(undefined);
+      expect(translator.translate(null)).toEqual(null);
+      expect(translator.translate(undefined)).toEqual(undefined);
     });
 
     it('allows implicit equality', () => {
-      const filter = { field: 'value' };
+      const filter: PineconeVectorFilter = { field: 'value' };
       expect(translator.translate(filter)).toEqual({ field: 'value' });
     });
 
     it('allows multiple top-level fields', () => {
-      const filter = {
+      const filter: PineconeVectorFilter = {
         field1: 'value1',
         field2: 'value2',
       };
@@ -34,7 +35,7 @@ describe('PineconeFilterTranslator', () => {
     });
 
     it('handles multiple operators on same field', () => {
-      const filter = {
+      const filter: PineconeVectorFilter = {
         price: { $gt: 100, $lt: 200 },
         quantity: { $gte: 10, $lte: 20 },
       };
@@ -46,12 +47,12 @@ describe('PineconeFilterTranslator', () => {
 
     it('normalizes date values', () => {
       const date = new Date('2024-01-01');
-      const filter = { timestamp: { $gt: date } };
+      const filter: PineconeVectorFilter = { timestamp: { $gt: date } };
       expect(translator.translate(filter)).toEqual({ timestamp: { $gt: date.toISOString() } });
     });
 
     it('handles $exists operator', () => {
-      const filter = { field: { $exists: true } };
+      const filter: PineconeVectorFilter = { field: { $exists: true } };
       expect(translator.translate(filter)).toEqual({ field: { $exists: true } });
     });
   });
@@ -59,12 +60,12 @@ describe('PineconeFilterTranslator', () => {
   // Array Operations
   describe('array operations', () => {
     it('handles arrays as $in operator', () => {
-      const filter = { tags: ['tag1', 'tag2'] };
+      const filter: PineconeVectorFilter = { tags: ['tag1', 'tag2'] };
       expect(translator.translate(filter)).toEqual({ tags: { $in: ['tag1', 'tag2'] } });
     });
 
     it('simulates $all using $and + $in', () => {
-      const filter = { tags: { $all: ['tag1', 'tag2'] } };
+      const filter: PineconeVectorFilter = { tags: { $all: ['tag1', 'tag2'] } };
       expect(translator.translate(filter)).toEqual({
         $and: [{ tags: { $in: ['tag1'] } }, { tags: { $in: ['tag2'] } }],
       });
@@ -127,7 +128,7 @@ describe('PineconeFilterTranslator', () => {
   // Logical Operators
   describe('logical operators', () => {
     it('handles logical operators', () => {
-      const filter = {
+      const filter: PineconeVectorFilter = {
         $or: [{ status: 'active' }, { age: { $gt: 25 } }],
       };
       expect(translator.translate(filter)).toEqual({
@@ -136,7 +137,7 @@ describe('PineconeFilterTranslator', () => {
     });
 
     it('handles nested logical operators', () => {
-      const filter = {
+      const filter: PineconeVectorFilter = {
         $and: [
           { status: 'active' },
           {
@@ -170,7 +171,7 @@ describe('PineconeFilterTranslator', () => {
     });
 
     it('handles complex nested conditions', () => {
-      const filter = {
+      const filter: PineconeVectorFilter = {
         $or: [
           { age: { $gt: 25 } },
           {
@@ -205,7 +206,7 @@ describe('PineconeFilterTranslator', () => {
     });
 
     it('preserves empty objects as exact match conditions', () => {
-      const filter = {
+      const filter: PineconeVectorFilter = {
         metadata: {},
         'user.profile': {},
       };
@@ -217,7 +218,7 @@ describe('PineconeFilterTranslator', () => {
     });
 
     it('handles empty objects in logical operators', () => {
-      const filter = {
+      const filter: PineconeVectorFilter = {
         $or: [{}, { status: 'active' }],
       };
 
@@ -241,7 +242,7 @@ describe('PineconeFilterTranslator', () => {
     });
 
     it('handles empty objects in comparison operators', () => {
-      const filter = {
+      const filter: PineconeVectorFilter = {
         metadata: { $eq: {} },
       };
 
@@ -251,7 +252,7 @@ describe('PineconeFilterTranslator', () => {
     });
 
     it('handles empty objects in array operators', () => {
-      const filter = {
+      const filter: PineconeVectorFilter = {
         tags: { $in: [{}] },
       };
 
@@ -367,7 +368,7 @@ describe('PineconeFilterTranslator', () => {
       });
 
       it('throws error for unsupported logical operators', () => {
-        const invalidFilters = [
+        const invalidFilters: any = [
           {
             $not: { field: 'value' },
           },
@@ -389,13 +390,13 @@ describe('PineconeFilterTranslator', () => {
     });
 
     it('ensure all operator filters are supported', () => {
-      const supportedFilters = [
+      const supportedFilters: PineconeVectorFilter[] = [
         { field: { $eq: 'value' } },
         { field: { $ne: 'value' } },
-        { field: { $gt: 'value' } },
-        { field: { $gte: 'value' } },
-        { field: { $lt: 'value' } },
-        { field: { $lte: 'value' } },
+        { field: { $gt: 10 } },
+        { field: { $gte: 10 } },
+        { field: { $lt: 10 } },
+        { field: { $lte: 10 } },
         { field: { $in: ['value'] } },
         { $and: [{ field: { $eq: 'value' } }] },
         { $or: [{ field: { $eq: 'value' } }] },
@@ -431,7 +432,7 @@ describe('PineconeFilterTranslator', () => {
     });
 
     it('throws error for invalid operator values', () => {
-      const filter = { tags: { $all: 'not-an-array' } };
+      const filter: any = { tags: { $all: 'not-an-array' } };
       expect(() => translator.translate(filter)).toThrow();
     });
     it('throws error for regex operators', () => {
@@ -439,7 +440,7 @@ describe('PineconeFilterTranslator', () => {
       expect(() => translator.translate(filter)).toThrow();
     });
     it('throws error for non-logical operators at top level', () => {
-      const invalidFilters = [{ $gt: 100 }, { $in: ['value1', 'value2'] }, { $eq: true }];
+      const invalidFilters: any = [{ $gt: 100 }, { $in: ['value1', 'value2'] }, { $eq: true }];
 
       invalidFilters.forEach(filter => {
         expect(() => translator.translate(filter)).toThrow(/Invalid top-level operator/);

package/src/vector/filter.ts

@@ -1,7 +1,38 @@
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
-import type { FieldCondition, VectorFilter, OperatorSupport, QueryOperator } from '@mastra/core/vector/filter';
+import type {
+  VectorFilter,
+  OperatorSupport,
+  OperatorValueMap,
+  LogicalOperatorValueMap,
+  BlacklistedRootOperators,
+  QueryOperator,
+  FilterValue,
+  OperatorCondition,
+} from '@mastra/core/vector/filter';
 
-export class PineconeFilterTranslator extends BaseFilterTranslator {
+type InitialOperatorValueMap = Omit<OperatorValueMap, '$regex' | '$options' | '$elemMatch' | '$all'> & {
+  $contains: string;
+  $gt: number | Date;
+  $gte: number | Date;
+  $lt: number | Date;
+  $lte: number | Date;
+};
+
+type PineconeOperatorValueMap = InitialOperatorValueMap & {
+  $all: OperatorCondition<keyof InitialOperatorValueMap, InitialOperatorValueMap>[] | FilterValue[];
+};
+type PineconeLogicalOperatorValueMap = Omit<LogicalOperatorValueMap, '$not' | '$nor'>;
+
+type PineconeBlacklisted = BlacklistedRootOperators | '$not' | '$nor';
+
+export type PineconeVectorFilter = VectorFilter<
+  keyof PineconeOperatorValueMap,
+  PineconeOperatorValueMap,
+  PineconeLogicalOperatorValueMap,
+  PineconeBlacklisted
+>;
+
+export class PineconeFilterTranslator extends BaseFilterTranslator<PineconeVectorFilter> {
   protected override getSupportedOperators(): OperatorSupport {
     return {
       ...BaseFilterTranslator.DEFAULT_OPERATORS,
@@ -13,13 +44,13 @@ export class PineconeFilterTranslator extends BaseFilterTranslator {
     };
   }
 
-  translate(filter?: VectorFilter): VectorFilter {
+  translate(filter?: PineconeVectorFilter): PineconeVectorFilter {
     if (this.isEmpty(filter)) return filter;
     this.validateFilter(filter);
     return this.translateNode(filter);
   }
 
-  private translateNode(node: VectorFilter | FieldCondition, currentPath: string = ''): any {
+  private translateNode(node: PineconeVectorFilter, currentPath: string = ''): any {
     if (this.isRegex(node)) {
       throw new Error('Regex is not supported in Pinecone');
     }

package/src/vector/index.test.ts

@@ -728,7 +728,11 @@ describe.skip('PineconeVector Integration Tests', () => {
         vectorDB.query({
           indexName: testIndexName,
           queryVector: [1, 0, 0],
-          filter: { field1: { $in: 'not-array' }, field2: { $exists: 'not-boolean' }, field3: { $gt: 'not-number' } },
+          filter: {
+            field1: { $in: 'not-array' },
+            field2: { $exists: 'not-boolean' },
+            field3: { $gt: 'not-number' },
+          } as any,
         }),
       ).rejects.toThrow();
     });
@@ -754,7 +758,7 @@ describe.skip('PineconeVector Integration Tests', () => {
         vectorDB.query({
           indexName: testIndexName,
           queryVector: [1, 0, 0],
-          filter: { field: { $all: 'not-an-array' } },
+          filter: { field: { $all: 'not-an-array' } } as any,
         }),
       ).rejects.toThrow('A non-empty array is required for the $all operator');
     });
@@ -1164,7 +1168,7 @@ describe.skip('PineconeVector Integration Tests', () => {
         vectorDB.query({
           indexName: testIndexName,
           queryVector: [1, 0, 0],
-          filter: { price: { $gt: '500' } }, // string instead of number
+          filter: { price: { $gt: '500' } } as any, // string instead of number
         }),
       ).rejects.toThrow('the $gt operator must be followed by a number');
     });

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,
@@ -10,7 +11,6 @@ import type {
   DeleteVectorParams,
   UpdateVectorParams,
 } from '@mastra/core/vector';
-import type { VectorFilter } from '@mastra/core/vector/filter';
 import { Pinecone } from '@pinecone-database/pinecone';
 import type {
   IndexStatsDescription,
@@ -20,12 +20,13 @@ import type {
 } from '@pinecone-database/pinecone';
 
 import { PineconeFilterTranslator } from './filter';
+import type { PineconeVectorFilter } from './filter';
 
 interface PineconeIndexStats extends IndexStats {
   namespaces?: IndexStatsDescription['namespaces'];
 }
 
-interface PineconeQueryVectorParams extends QueryVectorParams {
+interface PineconeQueryVectorParams extends QueryVectorParams<PineconeVectorFilter> {
   namespace?: string;
   sparseVector?: RecordSparseValues;
 }
@@ -43,7 +44,7 @@ interface PineconeDeleteVectorParams extends DeleteVectorParams {
   namespace?: string;
 }
 
-export class PineconeVector extends MastraVector {
+export class PineconeVector extends MastraVector<PineconeVectorFilter> {
   private client: Pinecone;
 
   /**
@@ -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,15 +152,27 @@ 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) {
+  transformFilter(filter?: PineconeVectorFilter) {
     const translator = new PineconeFilterTranslator();
     return translator.translate(filter);
   }
@@ -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,
+      );
     }
   }
 }