@mastra/astra 0.10.2 → 0.10.3-alpha.0

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/astra@0.10.2-alpha.0 build /home/runner/work/mastra/mastra/stores/astra
+> @mastra/astra@0.10.3-alpha.0 build /home/runner/work/mastra/mastra/stores/astra
 > 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 6874ms
+TSC ⚡️ Build success in 5947ms
 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/astra/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/astra/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 9957ms
+DTS ⚡️ Build success in 8679ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.cjs 11.63 KB
-CJS ⚡️ Build success in 733ms
-ESM dist/index.js 11.57 KB
-ESM ⚡️ Build success in 734ms
+CJS dist/index.cjs 14.42 KB
+CJS ⚡️ Build success in 486ms
+ESM dist/index.js 14.16 KB
+ESM ⚡️ Build success in 486ms

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @mastra/astra
 
+## 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/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var astraDbTs = require('@datastax/astra-db-ts');
+var error = require('@mastra/core/error');
 var vector = require('@mastra/core/vector');
 var filter = require('@mastra/core/vector/filter');
 
@@ -70,15 +71,32 @@ var AstraVector = class extends vector.MastraVector {
    */
   async createIndex({ indexName, dimension, metric = "cosine" }) {
     if (!Number.isInteger(dimension) || dimension <= 0) {
-      throw new Error("Dimension must be a positive integer");
+      throw new error.MastraError({
+        id: "ASTRA_VECTOR_CREATE_INDEX_INVALID_DIMENSION",
+        text: "Dimension must be a positive integer",
+        domain: error.ErrorDomain.MASTRA_VECTOR,
+        category: error.ErrorCategory.USER
+      });
+    }
+    try {
+      await this.#db.createCollection(indexName, {
+        vector: {
+          dimension,
+          metric: metricMap[metric]
+        },
+        checkExists: false
+      });
+    } catch (error$1) {
+      new error.MastraError(
+        {
+          id: "ASTRA_VECTOR_CREATE_INDEX_DB_ERROR",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error$1
+      );
     }
-    await this.#db.createCollection(indexName, {
-      vector: {
-        dimension,
-        metric: metricMap[metric]
-      },
-      checkExists: false
-    });
   }
   /**
    * Inserts or updates vectors in the specified collection.
@@ -97,7 +115,19 @@ var AstraVector = class extends vector.MastraVector {
       $vector: vector,
       metadata: metadata?.[i] || {}
     }));
-    await collection.insertMany(records);
+    try {
+      await collection.insertMany(records);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "ASTRA_VECTOR_UPSERT_DB_ERROR",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error$1
+      );
+    }
     return vectorIds;
   }
   transformFilter(filter) {
@@ -123,29 +153,52 @@ var AstraVector = class extends vector.MastraVector {
   }) {
     const collection = this.#db.collection(indexName);
     const translatedFilter = this.transformFilter(filter);
-    const cursor = collection.find(translatedFilter ?? {}, {
-      sort: { $vector: queryVector },
-      limit: topK,
-      includeSimilarity: true,
-      projection: {
-        $vector: includeVector ? true : false
-      }
-    });
-    const results = await cursor.toArray();
-    return results.map((result) => ({
-      id: result.id,
-      score: result.$similarity,
-      metadata: result.metadata,
-      ...includeVector && { vector: result.$vector }
-    }));
+    try {
+      const cursor = collection.find(translatedFilter ?? {}, {
+        sort: { $vector: queryVector },
+        limit: topK,
+        includeSimilarity: true,
+        projection: {
+          $vector: includeVector ? true : false
+        }
+      });
+      const results = await cursor.toArray();
+      return results.map((result) => ({
+        id: result.id,
+        score: result.$similarity,
+        metadata: result.metadata,
+        ...includeVector && { vector: result.$vector }
+      }));
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "ASTRA_VECTOR_QUERY_DB_ERROR",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error$1
+      );
+    }
   }
   /**
    * Lists all collections in the database.
    *
    * @returns {Promise<string[]>} A promise that resolves to an array of collection names.
    */
-  listIndexes() {
-    return this.#db.listCollections({ nameOnly: true });
+  async listIndexes() {
+    try {
+      return await this.#db.listCollections({ nameOnly: true });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "ASTRA_VECTOR_LIST_INDEXES_DB_ERROR",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
   }
   /**
    * Retrieves statistics about a vector index.
@@ -155,16 +208,29 @@ var AstraVector = class extends vector.MastraVector {
    */
   async describeIndex({ indexName }) {
     const collection = this.#db.collection(indexName);
-    const optionsPromise = collection.options();
-    const countPromise = collection.countDocuments({}, 100);
-    const [options, count] = await Promise.all([optionsPromise, countPromise]);
-    const keys = Object.keys(metricMap);
-    const metric = keys.find((key) => metricMap[key] === options.vector?.metric);
-    return {
-      dimension: options.vector?.dimension,
-      metric,
-      count
-    };
+    try {
+      const optionsPromise = collection.options();
+      const countPromise = collection.countDocuments({}, 100);
+      const [options, count] = await Promise.all([optionsPromise, countPromise]);
+      const keys = Object.keys(metricMap);
+      const metric = keys.find((key) => metricMap[key] === options.vector?.metric);
+      return {
+        dimension: options.vector?.dimension,
+        metric,
+        count
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: "ASTRA_VECTOR_DESCRIBE_INDEX_DB_ERROR",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error$1
+      );
+    }
   }
   /**
    * Deletes the specified collection.
@@ -174,7 +240,19 @@ var AstraVector = class extends vector.MastraVector {
    */
   async deleteIndex({ indexName }) {
     const collection = this.#db.collection(indexName);
-    await collection.drop();
+    try {
+      await collection.drop();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "ASTRA_VECTOR_DELETE_INDEX_DB_ERROR",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error$1
+      );
+    }
   }
   /**
    * Updates a vector by its ID with the provided vector and/or metadata.
@@ -187,10 +265,16 @@ var AstraVector = 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 }) {
+    if (!update.vector && !update.metadata) {
+      throw new error.MastraError({
+        id: "ASTRA_VECTOR_UPDATE_NO_PAYLOAD",
+        text: "No updates provided for vector",
+        domain: error.ErrorDomain.MASTRA_VECTOR,
+        category: error.ErrorCategory.USER,
+        details: { indexName, id }
+      });
+    }
     try {
-      if (!update.vector && !update.metadata) {
-        throw new Error("No updates provided");
-      }
       const collection = this.#db.collection(indexName);
       const updateDoc = {};
       if (update.vector) {
@@ -200,8 +284,17 @@ var AstraVector = class extends vector.MastraVector {
         updateDoc.metadata = update.metadata;
       }
       await collection.findOneAndUpdate({ id }, { $set: updateDoc });
-    } catch (error) {
-      throw new Error(`Failed to update vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: "ASTRA_VECTOR_UPDATE_FAILED_UNHANDLED",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName, id }
+        },
+        error$1
+      );
     }
   }
   /**
@@ -215,8 +308,17 @@ var AstraVector = class extends vector.MastraVector {
     try {
       const collection = this.#db.collection(indexName);
       await collection.deleteOne({ id });
-    } catch (error) {
-      throw new Error(`Failed to delete vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: "ASTRA_VECTOR_DELETE_FAILED",
+          domain: error.ErrorDomain.MASTRA_VECTOR,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName, id }
+        },
+        error$1
+      );
     }
   }
 };

package/dist/index.js

@@ -1,4 +1,5 @@
 import { DataAPIClient, UUID } from '@datastax/astra-db-ts';
+import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
 import { MastraVector } from '@mastra/core/vector';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 
@@ -68,15 +69,32 @@ var AstraVector = class extends MastraVector {
    */
   async createIndex({ indexName, dimension, metric = "cosine" }) {
     if (!Number.isInteger(dimension) || dimension <= 0) {
-      throw new Error("Dimension must be a positive integer");
+      throw new MastraError({
+        id: "ASTRA_VECTOR_CREATE_INDEX_INVALID_DIMENSION",
+        text: "Dimension must be a positive integer",
+        domain: ErrorDomain.MASTRA_VECTOR,
+        category: ErrorCategory.USER
+      });
+    }
+    try {
+      await this.#db.createCollection(indexName, {
+        vector: {
+          dimension,
+          metric: metricMap[metric]
+        },
+        checkExists: false
+      });
+    } catch (error) {
+      new MastraError(
+        {
+          id: "ASTRA_VECTOR_CREATE_INDEX_DB_ERROR",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error
+      );
     }
-    await this.#db.createCollection(indexName, {
-      vector: {
-        dimension,
-        metric: metricMap[metric]
-      },
-      checkExists: false
-    });
   }
   /**
    * Inserts or updates vectors in the specified collection.
@@ -95,7 +113,19 @@ var AstraVector = class extends MastraVector {
       $vector: vector,
       metadata: metadata?.[i] || {}
     }));
-    await collection.insertMany(records);
+    try {
+      await collection.insertMany(records);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "ASTRA_VECTOR_UPSERT_DB_ERROR",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error
+      );
+    }
     return vectorIds;
   }
   transformFilter(filter) {
@@ -121,29 +151,52 @@ var AstraVector = class extends MastraVector {
   }) {
     const collection = this.#db.collection(indexName);
     const translatedFilter = this.transformFilter(filter);
-    const cursor = collection.find(translatedFilter ?? {}, {
-      sort: { $vector: queryVector },
-      limit: topK,
-      includeSimilarity: true,
-      projection: {
-        $vector: includeVector ? true : false
-      }
-    });
-    const results = await cursor.toArray();
-    return results.map((result) => ({
-      id: result.id,
-      score: result.$similarity,
-      metadata: result.metadata,
-      ...includeVector && { vector: result.$vector }
-    }));
+    try {
+      const cursor = collection.find(translatedFilter ?? {}, {
+        sort: { $vector: queryVector },
+        limit: topK,
+        includeSimilarity: true,
+        projection: {
+          $vector: includeVector ? true : false
+        }
+      });
+      const results = await cursor.toArray();
+      return results.map((result) => ({
+        id: result.id,
+        score: result.$similarity,
+        metadata: result.metadata,
+        ...includeVector && { vector: result.$vector }
+      }));
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "ASTRA_VECTOR_QUERY_DB_ERROR",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error
+      );
+    }
   }
   /**
    * Lists all collections in the database.
    *
    * @returns {Promise<string[]>} A promise that resolves to an array of collection names.
    */
-  listIndexes() {
-    return this.#db.listCollections({ nameOnly: true });
+  async listIndexes() {
+    try {
+      return await this.#db.listCollections({ nameOnly: true });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "ASTRA_VECTOR_LIST_INDEXES_DB_ERROR",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
   }
   /**
    * Retrieves statistics about a vector index.
@@ -153,16 +206,29 @@ var AstraVector = class extends MastraVector {
    */
   async describeIndex({ indexName }) {
     const collection = this.#db.collection(indexName);
-    const optionsPromise = collection.options();
-    const countPromise = collection.countDocuments({}, 100);
-    const [options, count] = await Promise.all([optionsPromise, countPromise]);
-    const keys = Object.keys(metricMap);
-    const metric = keys.find((key) => metricMap[key] === options.vector?.metric);
-    return {
-      dimension: options.vector?.dimension,
-      metric,
-      count
-    };
+    try {
+      const optionsPromise = collection.options();
+      const countPromise = collection.countDocuments({}, 100);
+      const [options, count] = await Promise.all([optionsPromise, countPromise]);
+      const keys = Object.keys(metricMap);
+      const metric = keys.find((key) => metricMap[key] === options.vector?.metric);
+      return {
+        dimension: options.vector?.dimension,
+        metric,
+        count
+      };
+    } catch (error) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: "ASTRA_VECTOR_DESCRIBE_INDEX_DB_ERROR",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error
+      );
+    }
   }
   /**
    * Deletes the specified collection.
@@ -172,7 +238,19 @@ var AstraVector = class extends MastraVector {
    */
   async deleteIndex({ indexName }) {
     const collection = this.#db.collection(indexName);
-    await collection.drop();
+    try {
+      await collection.drop();
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "ASTRA_VECTOR_DELETE_INDEX_DB_ERROR",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error
+      );
+    }
   }
   /**
    * Updates a vector by its ID with the provided vector and/or metadata.
@@ -185,10 +263,16 @@ var AstraVector = class extends MastraVector {
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
   async updateVector({ indexName, id, update }) {
+    if (!update.vector && !update.metadata) {
+      throw new MastraError({
+        id: "ASTRA_VECTOR_UPDATE_NO_PAYLOAD",
+        text: "No updates provided for vector",
+        domain: ErrorDomain.MASTRA_VECTOR,
+        category: ErrorCategory.USER,
+        details: { indexName, id }
+      });
+    }
     try {
-      if (!update.vector && !update.metadata) {
-        throw new Error("No updates provided");
-      }
       const collection = this.#db.collection(indexName);
       const updateDoc = {};
       if (update.vector) {
@@ -199,7 +283,16 @@ var AstraVector = class extends MastraVector {
       }
       await collection.findOneAndUpdate({ id }, { $set: updateDoc });
     } catch (error) {
-      throw new Error(`Failed to update vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: "ASTRA_VECTOR_UPDATE_FAILED_UNHANDLED",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, id }
+        },
+        error
+      );
     }
   }
   /**
@@ -214,7 +307,16 @@ var AstraVector = class extends MastraVector {
       const collection = this.#db.collection(indexName);
       await collection.deleteOne({ id });
     } catch (error) {
-      throw new Error(`Failed to delete vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: "ASTRA_VECTOR_DELETE_FAILED",
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, id }
+        },
+        error
+      );
     }
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/astra",
-  "version": "0.10.2",
+  "version": "0.10.3-alpha.0",
   "description": "Astra DB provider for Mastra - includes vector store capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -24,13 +24,13 @@
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.52.8",
-    "@types/node": "^20.17.57",
+    "@types/node": "^20.19.0",
     "eslint": "^9.28.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.1"
   },
   "peerDependencies": {
     "@mastra/core": ">=0.10.4-0 <0.11.0"

package/src/vector/index.ts

@@ -1,5 +1,6 @@
 import type { Db } from '@datastax/astra-db-ts';
 import { DataAPIClient, UUID } from '@datastax/astra-db-ts';
+import { MastraError, ErrorDomain, ErrorCategory } from '@mastra/core/error';
 import { MastraVector } from '@mastra/core/vector';
 import type {
   QueryResult,
@@ -48,15 +49,32 @@ export class AstraVector 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');
+      throw new MastraError({
+        id: 'ASTRA_VECTOR_CREATE_INDEX_INVALID_DIMENSION',
+        text: 'Dimension must be a positive integer',
+        domain: ErrorDomain.MASTRA_VECTOR,
+        category: ErrorCategory.USER,
+      });
+    }
+    try {
+      await this.#db.createCollection(indexName, {
+        vector: {
+          dimension,
+          metric: metricMap[metric],
+        },
+        checkExists: false,
+      });
+    } catch (error: any) {
+      new MastraError(
+        {
+          id: 'ASTRA_VECTOR_CREATE_INDEX_DB_ERROR',
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName },
+        },
+        error,
+      );
     }
-    await this.#db.createCollection(indexName, {
-      vector: {
-        dimension,
-        metric: metricMap[metric],
-      },
-      checkExists: false,
-    });
   }
 
   /**
@@ -80,7 +98,19 @@ export class AstraVector extends MastraVector {
       metadata: metadata?.[i] || {},
     }));
 
-    await collection.insertMany(records);
+    try {
+      await collection.insertMany(records);
+    } catch (error: any) {
+      throw new MastraError(
+        {
+          id: 'ASTRA_VECTOR_UPSERT_DB_ERROR',
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName },
+        },
+        error,
+      );
+    }
     return vectorIds;
   }
 
@@ -110,23 +140,35 @@ export class AstraVector extends MastraVector {
 
     const translatedFilter = this.transformFilter(filter);
 
-    const cursor = collection.find(translatedFilter ?? {}, {
-      sort: { $vector: queryVector },
-      limit: topK,
-      includeSimilarity: true,
-      projection: {
-        $vector: includeVector ? true : false,
-      },
-    });
-
-    const results = await cursor.toArray();
-
-    return results.map(result => ({
-      id: result.id,
-      score: result.$similarity,
-      metadata: result.metadata,
-      ...(includeVector && { vector: result.$vector }),
-    }));
+    try {
+      const cursor = collection.find(translatedFilter ?? {}, {
+        sort: { $vector: queryVector },
+        limit: topK,
+        includeSimilarity: true,
+        projection: {
+          $vector: includeVector ? true : false,
+        },
+      });
+
+      const results = await cursor.toArray();
+
+      return results.map(result => ({
+        id: result.id,
+        score: result.$similarity,
+        metadata: result.metadata,
+        ...(includeVector && { vector: result.$vector }),
+      }));
+    } catch (error: any) {
+      throw new MastraError(
+        {
+          id: 'ASTRA_VECTOR_QUERY_DB_ERROR',
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName },
+        },
+        error,
+      );
+    }
   }
 
   /**
@@ -134,8 +176,19 @@ export class AstraVector extends MastraVector {
    *
    * @returns {Promise<string[]>} A promise that resolves to an array of collection names.
    */
-  listIndexes(): Promise<string[]> {
-    return this.#db.listCollections({ nameOnly: true });
+  async listIndexes(): Promise<string[]> {
+    try {
+      return await this.#db.listCollections({ nameOnly: true });
+    } catch (error: any) {
+      throw new MastraError(
+        {
+          id: 'ASTRA_VECTOR_LIST_INDEXES_DB_ERROR',
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+        },
+        error,
+      );
+    }
   }
 
   /**
@@ -146,17 +199,30 @@ export class AstraVector extends MastraVector {
    */
   async describeIndex({ indexName }: DescribeIndexParams): Promise<IndexStats> {
     const collection = this.#db.collection(indexName);
-    const optionsPromise = collection.options();
-    const countPromise = collection.countDocuments({}, 100);
-    const [options, count] = await Promise.all([optionsPromise, countPromise]);
-
-    const keys = Object.keys(metricMap) as (keyof typeof metricMap)[];
-    const metric = keys.find(key => metricMap[key] === options.vector?.metric);
-    return {
-      dimension: options.vector?.dimension!,
-      metric,
-      count: count,
-    };
+    try {
+      const optionsPromise = collection.options();
+      const countPromise = collection.countDocuments({}, 100);
+      const [options, count] = await Promise.all([optionsPromise, countPromise]);
+
+      const keys = Object.keys(metricMap) as (keyof typeof metricMap)[];
+      const metric = keys.find(key => metricMap[key] === options.vector?.metric);
+      return {
+        dimension: options.vector?.dimension!,
+        metric,
+        count: count,
+      };
+    } catch (error: any) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: 'ASTRA_VECTOR_DESCRIBE_INDEX_DB_ERROR',
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName },
+        },
+        error,
+      );
+    }
   }
 
   /**
@@ -167,7 +233,19 @@ export class AstraVector extends MastraVector {
    */
   async deleteIndex({ indexName }: DeleteIndexParams): Promise<void> {
     const collection = this.#db.collection(indexName);
-    await collection.drop();
+    try {
+      await collection.drop();
+    } catch (error: any) {
+      throw new MastraError(
+        {
+          id: 'ASTRA_VECTOR_DELETE_INDEX_DB_ERROR',
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName },
+        },
+        error,
+      );
+    }
   }
 
   /**
@@ -181,11 +259,17 @@ export class AstraVector extends MastraVector {
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
   async updateVector({ indexName, id, update }: UpdateVectorParams): Promise<void> {
-    try {
-      if (!update.vector && !update.metadata) {
-        throw new Error('No updates provided');
-      }
+    if (!update.vector && !update.metadata) {
+      throw new MastraError({
+        id: 'ASTRA_VECTOR_UPDATE_NO_PAYLOAD',
+        text: 'No updates provided for vector',
+        domain: ErrorDomain.MASTRA_VECTOR,
+        category: ErrorCategory.USER,
+        details: { indexName, id },
+      });
+    }
 
+    try {
       const collection = this.#db.collection(indexName);
       const updateDoc: Record<string, any> = {};
 
@@ -199,7 +283,16 @@ export class AstraVector extends MastraVector {
 
       await collection.findOneAndUpdate({ id }, { $set: updateDoc });
     } catch (error: any) {
-      throw new Error(`Failed to update vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: 'ASTRA_VECTOR_UPDATE_FAILED_UNHANDLED',
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, id },
+        },
+        error,
+      );
     }
   }
 
@@ -215,7 +308,16 @@ export class AstraVector extends MastraVector {
       const collection = this.#db.collection(indexName);
       await collection.deleteOne({ id });
     } catch (error: any) {
-      throw new Error(`Failed to delete vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: 'ASTRA_VECTOR_DELETE_FAILED',
+          domain: ErrorDomain.MASTRA_VECTOR,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, id },
+        },
+        error,
+      );
     }
   }
 }