@mastra/turbopuffer 0.10.3-alpha.0 → 0.10.4-alpha.0

package/dist/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var error = require('@mastra/core/error');
 var vector = require('@mastra/core/vector');
 var turbopuffer = require('@turbopuffer/turbopuffer');
 var filter = require('@mastra/core/vector/filter');
@@ -188,28 +189,40 @@ var TurbopufferVector = class extends vector.MastraVector {
   }
   async createIndex({ indexName, dimension, metric }) {
     metric = metric ?? "cosine";
-    if (this.createIndexCache.has(indexName)) {
-      const expected = this.createIndexCache.get(indexName);
-      if (dimension !== expected.dimension || metric !== expected.metric) {
-        throw new Error(
-          `createIndex() called more than once with inconsistent inputs. Index ${indexName} expected dimensions=${expected.dimension} and metric=${expected.metric} but got dimensions=${dimension} and metric=${metric}`
-        );
-      }
-      return;
-    }
-    if (dimension <= 0) {
-      throw new Error("Dimension must be a positive integer");
-    }
     let distanceMetric = "cosine_distance";
-    switch (metric) {
-      case "cosine":
-        distanceMetric = "cosine_distance";
-        break;
-      case "euclidean":
-        distanceMetric = "euclidean_squared";
-        break;
-      case "dotproduct":
-        throw new Error("dotproduct is not supported in Turbopuffer");
+    try {
+      if (this.createIndexCache.has(indexName)) {
+        const expected = this.createIndexCache.get(indexName);
+        if (dimension !== expected.dimension || metric !== expected.metric) {
+          throw new Error(
+            `createIndex() called more than once with inconsistent inputs. Index ${indexName} expected dimensions=${expected.dimension} and metric=${expected.metric} but got dimensions=${dimension} and metric=${metric}`
+          );
+        }
+        return;
+      }
+      if (dimension <= 0) {
+        throw new Error("Dimension must be a positive integer");
+      }
+      switch (metric) {
+        case "cosine":
+          distanceMetric = "cosine_distance";
+          break;
+        case "euclidean":
+          distanceMetric = "euclidean_squared";
+          break;
+        case "dotproduct":
+          throw new Error("dotproduct is not supported in Turbopuffer");
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_TURBOBUFFER_VECTOR_CREATE_INDEX_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { indexName, dimension, metric }
+        },
+        error$1
+      );
     }
     this.createIndexCache.set(indexName, {
       indexName,
@@ -219,15 +232,29 @@ var TurbopufferVector = class extends vector.MastraVector {
     });
   }
   async upsert({ indexName, vectors, metadata, ids }) {
+    let index;
+    let createIndex;
     try {
       if (vectors.length === 0) {
         throw new Error("upsert() called with empty vectors");
       }
-      const index = this.client.namespace(indexName);
-      const createIndex = this.createIndexCache.get(indexName);
+      index = this.client.namespace(indexName);
+      createIndex = this.createIndexCache.get(indexName);
       if (!createIndex) {
         throw new Error(`createIndex() not called for this index`);
       }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_TURBOBUFFER_VECTOR_UPSERT_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { indexName }
+        },
+        error$1
+      );
+    }
+    try {
       const distanceMetric = createIndex.tpufDistanceMetric;
       const vectorIds = ids || vectors.map(() => crypto.randomUUID());
       const records = vectors.map((vector, i) => ({
@@ -254,22 +281,43 @@ var TurbopufferVector = class extends vector.MastraVector {
         await index.upsert(upsertOptions);
       }
       return vectorIds;
-    } catch (error) {
-      throw new Error(`Failed to upsert vectors into Turbopuffer namespace ${indexName}: ${error}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_TURBOBUFFER_VECTOR_UPSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error$1
+      );
     }
   }
   async query({ indexName, queryVector, topK, filter, includeVector }) {
-    const schemaConfig = this.opts.schemaConfigForIndex?.(indexName);
-    if (schemaConfig) {
-      if (queryVector.length !== schemaConfig.dimensions) {
-        throw new Error(
-          `Turbopuffer index ${indexName} was configured with dimensions=${schemaConfig.dimensions} but attempting to query with queryVector.length=${queryVector.length}`
-        );
+    let createIndex;
+    try {
+      const schemaConfig = this.opts.schemaConfigForIndex?.(indexName);
+      if (schemaConfig) {
+        if (queryVector.length !== schemaConfig.dimensions) {
+          throw new Error(
+            `Turbopuffer index ${indexName} was configured with dimensions=${schemaConfig.dimensions} but attempting to query with queryVector.length=${queryVector.length}`
+          );
+        }
       }
-    }
-    const createIndex = this.createIndexCache.get(indexName);
-    if (!createIndex) {
-      throw new Error(`createIndex() not called for this index`);
+      createIndex = this.createIndexCache.get(indexName);
+      if (!createIndex) {
+        throw new Error(`createIndex() not called for this index`);
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_TURBOBUFFER_VECTOR_QUERY_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { indexName }
+        },
+        error$1
+      );
     }
     const distanceMetric = createIndex.tpufDistanceMetric;
     try {
@@ -291,16 +339,31 @@ var TurbopufferVector = class extends vector.MastraVector {
         metadata: item.attributes || {},
         ...includeVector && item.vector ? { vector: item.vector } : {}
       }));
-    } catch (error) {
-      throw new Error(`Failed to query Turbopuffer namespace ${indexName}: ${error}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_TURBOBUFFER_VECTOR_QUERY_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error$1
+      );
     }
   }
   async listIndexes() {
     try {
       const namespacesResult = await this.client.namespaces({});
       return namespacesResult.namespaces.map((namespace) => namespace.id);
-    } catch (error) {
-      throw new Error(`Failed to list Turbopuffer namespaces: ${error}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_TURBOBUFFER_VECTOR_LIST_INDEXES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
     }
   }
   /**
@@ -324,8 +387,16 @@ var TurbopufferVector = class extends vector.MastraVector {
         count,
         metric: createIndex.metric
       };
-    } catch (error) {
-      throw new Error(`Failed to describe Turbopuffer namespace ${indexName}: ${error}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_TURBOBUFFER_VECTOR_DESCRIBE_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error$1
+      );
     }
   }
   async deleteIndex({ indexName }) {
@@ -333,8 +404,16 @@ var TurbopufferVector = class extends vector.MastraVector {
       const namespace = this.client.namespace(indexName);
       await namespace.deleteAll();
       this.createIndexCache.delete(indexName);
-    } catch (error) {
-      throw new Error(`Failed to delete Turbopuffer namespace ${indexName}: ${error.message}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_TURBOBUFFER_VECTOR_DELETE_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error$1
+      );
     }
   }
   /**
@@ -348,22 +427,46 @@ var TurbopufferVector = 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 }) {
+    let namespace;
+    let createIndex;
+    let distanceMetric;
+    let record;
     try {
-      const namespace = this.client.namespace(indexName);
-      const createIndex = this.createIndexCache.get(indexName);
+      namespace = this.client.namespace(indexName);
+      createIndex = this.createIndexCache.get(indexName);
       if (!createIndex) {
         throw new Error(`createIndex() not called for this index`);
       }
-      const distanceMetric = createIndex.tpufDistanceMetric;
-      const record = { id };
+      distanceMetric = createIndex.tpufDistanceMetric;
+      record = { id };
       if (update.vector) record.vector = update.vector;
       if (update.metadata) record.attributes = update.metadata;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_TURBOBUFFER_VECTOR_UPDATE_VECTOR_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { indexName }
+        },
+        error$1
+      );
+    }
+    try {
       await namespace.upsert({
         vectors: [record],
         distance_metric: distanceMetric
       });
-    } catch (error) {
-      throw new Error(`Failed to update Turbopuffer namespace ${indexName}: ${error.message}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_TURBOBUFFER_VECTOR_UPDATE_VECTOR_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error$1
+      );
     }
   }
   /**
@@ -377,8 +480,16 @@ var TurbopufferVector = class extends vector.MastraVector {
     try {
       const namespace = this.client.namespace(indexName);
       await namespace.delete({ ids: [id] });
-    } catch (error) {
-      throw new Error(`Failed to delete Turbopuffer namespace ${indexName}: ${error.message}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_TURBOBUFFER_VECTOR_DELETE_VECTOR_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        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 { Turbopuffer } from '@turbopuffer/turbopuffer';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
@@ -186,28 +187,40 @@ var TurbopufferVector = class extends MastraVector {
   }
   async createIndex({ indexName, dimension, metric }) {
     metric = metric ?? "cosine";
-    if (this.createIndexCache.has(indexName)) {
-      const expected = this.createIndexCache.get(indexName);
-      if (dimension !== expected.dimension || metric !== expected.metric) {
-        throw new Error(
-          `createIndex() called more than once with inconsistent inputs. Index ${indexName} expected dimensions=${expected.dimension} and metric=${expected.metric} but got dimensions=${dimension} and metric=${metric}`
-        );
-      }
-      return;
-    }
-    if (dimension <= 0) {
-      throw new Error("Dimension must be a positive integer");
-    }
     let distanceMetric = "cosine_distance";
-    switch (metric) {
-      case "cosine":
-        distanceMetric = "cosine_distance";
-        break;
-      case "euclidean":
-        distanceMetric = "euclidean_squared";
-        break;
-      case "dotproduct":
-        throw new Error("dotproduct is not supported in Turbopuffer");
+    try {
+      if (this.createIndexCache.has(indexName)) {
+        const expected = this.createIndexCache.get(indexName);
+        if (dimension !== expected.dimension || metric !== expected.metric) {
+          throw new Error(
+            `createIndex() called more than once with inconsistent inputs. Index ${indexName} expected dimensions=${expected.dimension} and metric=${expected.metric} but got dimensions=${dimension} and metric=${metric}`
+          );
+        }
+        return;
+      }
+      if (dimension <= 0) {
+        throw new Error("Dimension must be a positive integer");
+      }
+      switch (metric) {
+        case "cosine":
+          distanceMetric = "cosine_distance";
+          break;
+        case "euclidean":
+          distanceMetric = "euclidean_squared";
+          break;
+        case "dotproduct":
+          throw new Error("dotproduct is not supported in Turbopuffer");
+      }
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_TURBOBUFFER_VECTOR_CREATE_INDEX_INVALID_ARGS",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { indexName, dimension, metric }
+        },
+        error
+      );
     }
     this.createIndexCache.set(indexName, {
       indexName,
@@ -217,15 +230,29 @@ var TurbopufferVector = class extends MastraVector {
     });
   }
   async upsert({ indexName, vectors, metadata, ids }) {
+    let index;
+    let createIndex;
     try {
       if (vectors.length === 0) {
         throw new Error("upsert() called with empty vectors");
       }
-      const index = this.client.namespace(indexName);
-      const createIndex = this.createIndexCache.get(indexName);
+      index = this.client.namespace(indexName);
+      createIndex = this.createIndexCache.get(indexName);
       if (!createIndex) {
         throw new Error(`createIndex() not called for this index`);
       }
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_TURBOBUFFER_VECTOR_UPSERT_INVALID_ARGS",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { indexName }
+        },
+        error
+      );
+    }
+    try {
       const distanceMetric = createIndex.tpufDistanceMetric;
       const vectorIds = ids || vectors.map(() => crypto.randomUUID());
       const records = vectors.map((vector, i) => ({
@@ -253,21 +280,42 @@ var TurbopufferVector = class extends MastraVector {
       }
       return vectorIds;
     } catch (error) {
-      throw new Error(`Failed to upsert vectors into Turbopuffer namespace ${indexName}: ${error}`);
+      throw new MastraError(
+        {
+          id: "STORAGE_TURBOBUFFER_VECTOR_UPSERT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error
+      );
     }
   }
   async query({ indexName, queryVector, topK, filter, includeVector }) {
-    const schemaConfig = this.opts.schemaConfigForIndex?.(indexName);
-    if (schemaConfig) {
-      if (queryVector.length !== schemaConfig.dimensions) {
-        throw new Error(
-          `Turbopuffer index ${indexName} was configured with dimensions=${schemaConfig.dimensions} but attempting to query with queryVector.length=${queryVector.length}`
-        );
+    let createIndex;
+    try {
+      const schemaConfig = this.opts.schemaConfigForIndex?.(indexName);
+      if (schemaConfig) {
+        if (queryVector.length !== schemaConfig.dimensions) {
+          throw new Error(
+            `Turbopuffer index ${indexName} was configured with dimensions=${schemaConfig.dimensions} but attempting to query with queryVector.length=${queryVector.length}`
+          );
+        }
       }
-    }
-    const createIndex = this.createIndexCache.get(indexName);
-    if (!createIndex) {
-      throw new Error(`createIndex() not called for this index`);
+      createIndex = this.createIndexCache.get(indexName);
+      if (!createIndex) {
+        throw new Error(`createIndex() not called for this index`);
+      }
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_TURBOBUFFER_VECTOR_QUERY_INVALID_ARGS",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { indexName }
+        },
+        error
+      );
     }
     const distanceMetric = createIndex.tpufDistanceMetric;
     try {
@@ -290,7 +338,15 @@ var TurbopufferVector = class extends MastraVector {
         ...includeVector && item.vector ? { vector: item.vector } : {}
       }));
     } catch (error) {
-      throw new Error(`Failed to query Turbopuffer namespace ${indexName}: ${error}`);
+      throw new MastraError(
+        {
+          id: "STORAGE_TURBOBUFFER_VECTOR_QUERY_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error
+      );
     }
   }
   async listIndexes() {
@@ -298,7 +354,14 @@ var TurbopufferVector = class extends MastraVector {
       const namespacesResult = await this.client.namespaces({});
       return namespacesResult.namespaces.map((namespace) => namespace.id);
     } catch (error) {
-      throw new Error(`Failed to list Turbopuffer namespaces: ${error}`);
+      throw new MastraError(
+        {
+          id: "STORAGE_TURBOBUFFER_VECTOR_LIST_INDEXES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
     }
   }
   /**
@@ -323,7 +386,15 @@ var TurbopufferVector = class extends MastraVector {
         metric: createIndex.metric
       };
     } catch (error) {
-      throw new Error(`Failed to describe Turbopuffer namespace ${indexName}: ${error}`);
+      throw new MastraError(
+        {
+          id: "STORAGE_TURBOBUFFER_VECTOR_DESCRIBE_INDEX_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error
+      );
     }
   }
   async deleteIndex({ indexName }) {
@@ -332,7 +403,15 @@ var TurbopufferVector = class extends MastraVector {
       await namespace.deleteAll();
       this.createIndexCache.delete(indexName);
     } catch (error) {
-      throw new Error(`Failed to delete Turbopuffer namespace ${indexName}: ${error.message}`);
+      throw new MastraError(
+        {
+          id: "STORAGE_TURBOBUFFER_VECTOR_DELETE_INDEX_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error
+      );
     }
   }
   /**
@@ -346,22 +425,46 @@ var TurbopufferVector = class extends MastraVector {
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
   async updateVector({ indexName, id, update }) {
+    let namespace;
+    let createIndex;
+    let distanceMetric;
+    let record;
     try {
-      const namespace = this.client.namespace(indexName);
-      const createIndex = this.createIndexCache.get(indexName);
+      namespace = this.client.namespace(indexName);
+      createIndex = this.createIndexCache.get(indexName);
       if (!createIndex) {
         throw new Error(`createIndex() not called for this index`);
       }
-      const distanceMetric = createIndex.tpufDistanceMetric;
-      const record = { id };
+      distanceMetric = createIndex.tpufDistanceMetric;
+      record = { id };
       if (update.vector) record.vector = update.vector;
       if (update.metadata) record.attributes = update.metadata;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_TURBOBUFFER_VECTOR_UPDATE_VECTOR_INVALID_ARGS",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { indexName }
+        },
+        error
+      );
+    }
+    try {
       await namespace.upsert({
         vectors: [record],
         distance_metric: distanceMetric
       });
     } catch (error) {
-      throw new Error(`Failed to update Turbopuffer namespace ${indexName}: ${error.message}`);
+      throw new MastraError(
+        {
+          id: "STORAGE_TURBOBUFFER_VECTOR_UPDATE_VECTOR_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error
+      );
     }
   }
   /**
@@ -376,7 +479,15 @@ var TurbopufferVector = class extends MastraVector {
       const namespace = this.client.namespace(indexName);
       await namespace.delete({ ids: [id] });
     } catch (error) {
-      throw new Error(`Failed to delete Turbopuffer namespace ${indexName}: ${error.message}`);
+      throw new MastraError(
+        {
+          id: "STORAGE_TURBOBUFFER_VECTOR_DELETE_VECTOR_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error
+      );
     }
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/turbopuffer",
-  "version": "0.10.3-alpha.0",
+  "version": "0.10.4-alpha.0",
   "description": "Turbopuffer vector store provider for Mastra",
   "type": "module",
   "files": [
@@ -33,8 +33,8 @@
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.3",
-    "@internal/lint": "0.0.12",
-    "@mastra/core": "0.10.6-alpha.0"
+    "@internal/lint": "0.0.13",
+    "@mastra/core": "0.10.7-alpha.1"
   },
   "peerDependencies": {
     "@mastra/core": ">=0.10.4-0 <0.11.0"