@mastra/turbopuffer 1.2.0 → 1.2.1-alpha.0

package/dist/index.cjs

@@ -1,685 +1,579 @@
-'use strict';
-
-var error = require('@mastra/core/error');
-var storage = require('@mastra/core/storage');
-var vector = require('@mastra/core/vector');
-var turbopuffer = require('@turbopuffer/turbopuffer');
-var filter = require('@mastra/core/vector/filter');
-
-// src/vector/index.ts
-var TurbopufferFilterTranslator = class extends filter.BaseFilterTranslator {
-  getSupportedOperators() {
-    return {
-      ...filter.BaseFilterTranslator.DEFAULT_OPERATORS,
-      logical: ["$and", "$or"],
-      array: ["$in", "$nin", "$all"],
-      element: ["$exists"],
-      regex: [],
-      // No regex support in Turbopuffer
-      custom: []
-      // No custom operators
-    };
-  }
-  /**
-   * Map Mastra operators to Turbopuffer operators
-   */
-  operatorMap = {
-    $eq: "Eq",
-    $ne: "NotEq",
-    $gt: "Gt",
-    $gte: "Gte",
-    $lt: "Lt",
-    $lte: "Lte",
-    $in: "In",
-    $nin: "NotIn"
-  };
-  /**
-   * Convert the Mastra filter to Turbopuffer format
-   */
-  translate(filter) {
-    if (this.isEmpty(filter)) {
-      return void 0;
-    }
-    this.validateFilter(filter);
-    const result = this.translateNode(filter);
-    if (!Array.isArray(result) || result.length !== 2 || result[0] !== "And" && result[0] !== "Or") {
-      return ["And", [result]];
-    }
-    return result;
-  }
-  /**
-   * Recursively translate a filter node
-   */
-  translateNode(node) {
-    if (node === null || node === void 0 || Object.keys(node).length === 0) {
-      return ["And", []];
-    }
-    if (this.isPrimitive(node)) {
-      throw new Error("Direct primitive values not valid in this context for Turbopuffer");
-    }
-    if (Array.isArray(node)) {
-      throw new Error("Direct array values not valid in this context for Turbopuffer");
-    }
-    const entries = Object.entries(node);
-    if (entries.length === 0) {
-      return ["And", []];
-    }
-    const [key, value] = entries[0];
-    if (key && this.isLogicalOperator(key)) {
-      return this.translateLogical(key, value);
-    }
-    if (entries.length > 1) {
-      const conditions = entries.map(([field, fieldValue]) => this.translateFieldCondition(field, fieldValue));
-      return ["And", conditions];
-    }
-    return this.translateFieldCondition(key, value);
-  }
-  /**
-   * Translate a field condition
-   */
-  translateFieldCondition(field, value) {
-    if (value instanceof Date) {
-      return [field, "Eq", this.normalizeValue(value)];
-    }
-    if (this.isPrimitive(value)) {
-      return [field, "Eq", this.normalizeValue(value)];
-    }
-    if (Array.isArray(value)) {
-      return [field, "In", this.normalizeArrayValues(value)];
-    }
-    if (typeof value === "object" && value !== null) {
-      const operators = Object.keys(value);
-      if (operators.length > 1) {
-        const allOperators = operators.every((op2) => this.isOperator(op2));
-        if (allOperators) {
-          const conditions = operators.map((op2) => this.translateOperator(field, op2, value[op2]));
-          return ["And", conditions];
-        } else {
-          const conditions = operators.map((op2) => {
-            const nestedField = `${field}.${op2}`;
-            return this.translateFieldCondition(nestedField, value[op2]);
-          });
-          return ["And", conditions];
-        }
-      }
-      const op = operators[0];
-      if (op && this.isOperator(op)) {
-        return this.translateOperator(field, op, value[op]);
-      }
-      if (op && !this.isOperator(op)) {
-        const nestedField = `${field}.${op}`;
-        return this.translateFieldCondition(nestedField, value[op]);
-      }
-    }
-    throw new Error(`Unsupported filter format for field: ${field}`);
-  }
-  /**
-   * Translate a logical operator
-   */
-  translateLogical(operator, conditions) {
-    const logicalOp = operator === "$and" ? "And" : "Or";
-    if (!Array.isArray(conditions)) {
-      throw new Error(`Logical operator ${operator} requires an array of conditions`);
-    }
-    const translatedConditions = conditions.map((condition) => {
-      if (typeof condition !== "object" || condition === null) {
-        throw new Error(`Invalid condition for logical operator ${operator}`);
-      }
-      return this.translateNode(condition);
-    });
-    return [logicalOp, translatedConditions];
-  }
-  /**
-   * Translate a specific operator
-   */
-  translateOperator(field, operator, value) {
-    if (operator && this.operatorMap[operator]) {
-      return [field, this.operatorMap[operator], this.normalizeValue(value)];
-    }
-    switch (operator) {
-      case "$exists":
-        return value ? [field, "NotEq", null] : [field, "Eq", null];
-      case "$all":
-        if (!Array.isArray(value) || value.length === 0) {
-          throw new Error("$all operator requires a non-empty array");
-        }
-        const allConditions = value.map((item) => [field, "In", [this.normalizeValue(item)]]);
-        return ["And", allConditions];
-      default:
-        throw new Error(`Unsupported operator: ${operator || "undefined"}`);
-    }
-  }
-  /**
-   * Normalize a value for comparison operations
-   */
-  normalizeValue(value) {
-    if (value instanceof Date) {
-      return value.toISOString();
-    }
-    return value;
-  }
-  /**
-   * Normalize array values
-   */
-  normalizeArrayValues(values) {
-    return values.map((value) => this.normalizeValue(value));
-  }
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _mastra_core_error = require("@mastra/core/error");
+let _mastra_core_storage = require("@mastra/core/storage");
+let _mastra_core_vector = require("@mastra/core/vector");
+let _turbopuffer_turbopuffer = require("@turbopuffer/turbopuffer");
+let _mastra_core_vector_filter = require("@mastra/core/vector/filter");
+//#region src/vector/filter.ts
+/**
+* Translator for converting Mastra filters to Turbopuffer format
+*
+* Mastra filters: { field: { $gt: 10 } }
+* Turbopuffer filters: ["And", [["field", "Gt", 10]]]
+*/
+var TurbopufferFilterTranslator = class extends _mastra_core_vector_filter.BaseFilterTranslator {
+	getSupportedOperators() {
+		return {
+			..._mastra_core_vector_filter.BaseFilterTranslator.DEFAULT_OPERATORS,
+			logical: ["$and", "$or"],
+			array: [
+				"$in",
+				"$nin",
+				"$all"
+			],
+			element: ["$exists"],
+			regex: [],
+			custom: []
+		};
+	}
+	/**
+	* Map Mastra operators to Turbopuffer operators
+	*/
+	operatorMap = {
+		$eq: "Eq",
+		$ne: "NotEq",
+		$gt: "Gt",
+		$gte: "Gte",
+		$lt: "Lt",
+		$lte: "Lte",
+		$in: "In",
+		$nin: "NotIn"
+	};
+	/**
+	* Convert the Mastra filter to Turbopuffer format
+	*/
+	translate(filter) {
+		if (this.isEmpty(filter)) return;
+		this.validateFilter(filter);
+		const result = this.translateNode(filter);
+		if (!Array.isArray(result) || result.length !== 2 || result[0] !== "And" && result[0] !== "Or") return ["And", [result]];
+		return result;
+	}
+	/**
+	* Recursively translate a filter node
+	*/
+	translateNode(node) {
+		if (node === null || node === void 0 || Object.keys(node).length === 0) return ["And", []];
+		if (this.isPrimitive(node)) throw new Error("Direct primitive values not valid in this context for Turbopuffer");
+		if (Array.isArray(node)) throw new Error("Direct array values not valid in this context for Turbopuffer");
+		const entries = Object.entries(node);
+		if (entries.length === 0) return ["And", []];
+		const [key, value] = entries[0];
+		if (key && this.isLogicalOperator(key)) return this.translateLogical(key, value);
+		if (entries.length > 1) return ["And", entries.map(([field, fieldValue]) => this.translateFieldCondition(field, fieldValue))];
+		return this.translateFieldCondition(key, value);
+	}
+	/**
+	* Translate a field condition
+	*/
+	translateFieldCondition(field, value) {
+		if (value instanceof Date) return [
+			field,
+			"Eq",
+			this.normalizeValue(value)
+		];
+		if (this.isPrimitive(value)) return [
+			field,
+			"Eq",
+			this.normalizeValue(value)
+		];
+		if (Array.isArray(value)) return [
+			field,
+			"In",
+			this.normalizeArrayValues(value)
+		];
+		if (typeof value === "object" && value !== null) {
+			const operators = Object.keys(value);
+			if (operators.length > 1) if (operators.every((op) => this.isOperator(op))) return ["And", operators.map((op) => this.translateOperator(field, op, value[op]))];
+			else return ["And", operators.map((op) => {
+				const nestedField = `${field}.${op}`;
+				return this.translateFieldCondition(nestedField, value[op]);
+			})];
+			const op = operators[0];
+			if (op && this.isOperator(op)) return this.translateOperator(field, op, value[op]);
+			if (op && !this.isOperator(op)) {
+				const nestedField = `${field}.${op}`;
+				return this.translateFieldCondition(nestedField, value[op]);
+			}
+		}
+		throw new Error(`Unsupported filter format for field: ${field}`);
+	}
+	/**
+	* Translate a logical operator
+	*/
+	translateLogical(operator, conditions) {
+		const logicalOp = operator === "$and" ? "And" : "Or";
+		if (!Array.isArray(conditions)) throw new Error(`Logical operator ${operator} requires an array of conditions`);
+		return [logicalOp, conditions.map((condition) => {
+			if (typeof condition !== "object" || condition === null) throw new Error(`Invalid condition for logical operator ${operator}`);
+			return this.translateNode(condition);
+		})];
+	}
+	/**
+	* Translate a specific operator
+	*/
+	translateOperator(field, operator, value) {
+		if (operator && this.operatorMap[operator]) return [
+			field,
+			this.operatorMap[operator],
+			this.normalizeValue(value)
+		];
+		switch (operator) {
+			case "$exists": return value ? [
+				field,
+				"NotEq",
+				null
+			] : [
+				field,
+				"Eq",
+				null
+			];
+			case "$all":
+				if (!Array.isArray(value) || value.length === 0) throw new Error("$all operator requires a non-empty array");
+				return ["And", value.map((item) => [
+					field,
+					"In",
+					[this.normalizeValue(item)]
+				])];
+			default: throw new Error(`Unsupported operator: ${operator || "undefined"}`);
+		}
+	}
+	/**
+	* Normalize a value for comparison operations
+	*/
+	normalizeValue(value) {
+		if (value instanceof Date) return value.toISOString();
+		return value;
+	}
+	/**
+	* Normalize array values
+	*/
+	normalizeArrayValues(values) {
+		return values.map((value) => this.normalizeValue(value));
+	}
 };
-
-// src/vector/index.ts
-var TurbopufferVector = class extends vector.MastraVector {
-  client;
-  filterTranslator;
-  // There is no explicit create index operation in Turbopuffer, so just register that
-  // someone has called createIndex() and verify that subsequent upsert calls are consistent
-  // with how the index was "created"
-  createIndexCache = /* @__PURE__ */ new Map();
-  opts;
-  constructor(opts) {
-    super({ id: opts.id });
-    this.filterTranslator = new TurbopufferFilterTranslator();
-    this.opts = opts;
-    this.client = new turbopuffer.Turbopuffer(opts);
-  }
-  async createIndex({ indexName, dimension, metric }) {
-    metric = metric ?? "cosine";
-    let distanceMetric = "cosine_distance";
-    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.createVectorErrorId("TURBOPUFFER", "CREATE_INDEX", "INVALID_ARGS"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: { indexName, dimension, metric }
-        },
-        error$1
-      );
-    }
-    this.createIndexCache.set(indexName, {
-      indexName,
-      dimension,
-      metric,
-      tpufDistanceMetric: distanceMetric
-    });
-  }
-  async upsert({ indexName, vectors, metadata, ids }) {
-    let index;
-    let createIndex;
-    try {
-      if (vectors.length === 0) {
-        throw new Error("upsert() called with empty vectors");
-      }
-      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.createVectorErrorId("TURBOPUFFER", "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) => ({
-        id: vectorIds[i],
-        vector,
-        ...metadata?.[i] || {}
-      }));
-      const batchSize = 100;
-      for (let i = 0; i < records.length; i += batchSize) {
-        const batch = records.slice(i, i + batchSize);
-        const writeOptions = {
-          upsert_rows: batch,
-          distance_metric: distanceMetric
-        };
-        const schemaConfig = this.opts.schemaConfigForIndex?.(indexName);
-        if (schemaConfig) {
-          writeOptions.schema = schemaConfig.schema;
-          if (vectors[0]?.length !== schemaConfig.dimensions) {
-            throw new Error(
-              `Turbopuffer index ${indexName} was configured with dimensions=${schemaConfig.dimensions} but attempting to upsert vectors[0].length=${vectors[0]?.length}`
-            );
-          }
-        }
-        await index.write(writeOptions);
-      }
-      return vectorIds;
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("TURBOPUFFER", "UPSERT", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName }
-        },
-        error$1
-      );
-    }
-  }
-  async query({
-    indexName,
-    queryVector,
-    topK,
-    filter,
-    includeVector,
-    consistency
-  }) {
-    if (!queryVector) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("TURBOPUFFER", "QUERY", "MISSING_VECTOR"),
-        text: "queryVector is required for Turbopuffer queries. Metadata-only queries are not supported by this vector store.",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        details: { indexName }
-      });
-    }
-    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}`
-          );
-        }
-      }
-      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.createVectorErrorId("TURBOPUFFER", "QUERY", "INVALID_ARGS"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: { indexName }
-        },
-        error$1
-      );
-    }
-    const distanceMetric = createIndex.tpufDistanceMetric;
-    try {
-      const index = this.client.namespace(indexName);
-      const translatedFilter = this.filterTranslator.translate(filter);
-      const results = await index.query({
-        distance_metric: distanceMetric,
-        rank_by: ["vector", "ANN", queryVector],
-        top_k: topK,
-        filters: translatedFilter,
-        vector_encoding: includeVector ? "float" : void 0,
-        include_attributes: true,
-        consistency: { level: consistency ?? this.opts.consistency ?? "strong" }
-      });
-      return (results.rows ?? []).map((item) => {
-        const { id, vector, $dist, ...metadata } = item;
-        return {
-          id: String(id),
-          score: typeof $dist === "number" ? $dist : 0,
-          metadata,
-          ...includeVector && Array.isArray(vector) ? { vector } : {}
-        };
-      });
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("TURBOPUFFER", "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$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("TURBOPUFFER", "LIST_INDEXES", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
-        },
-        error$1
-      );
-    }
-  }
-  /**
-   * Retrieves statistics about a vector index.
-   *
-   * @param {string} indexName - The name of the index to describe
-   * @returns A promise that resolves to the index statistics including dimension, count and metric
-   */
-  async describeIndex({ indexName }) {
-    try {
-      const namespace = this.client.namespace(indexName);
-      const metadata = await namespace.metadata();
-      const createIndex = this.createIndexCache.get(indexName);
-      if (!createIndex) {
-        throw new Error(`createIndex() not called for this index`);
-      }
-      const dimension = createIndex.dimension;
-      const count = metadata.approx_row_count;
-      return {
-        dimension,
-        count,
-        metric: createIndex.metric
-      };
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("TURBOPUFFER", "DESCRIBE_INDEX", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName }
-        },
-        error$1
-      );
-    }
-  }
-  async deleteIndex({ indexName }) {
-    try {
-      const namespace = this.client.namespace(indexName);
-      await namespace.deleteAll();
-      this.createIndexCache.delete(indexName);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("TURBOPUFFER", "DELETE_INDEX", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName }
-        },
-        error$1
-      );
-    }
-  }
-  /**
-   * Updates a vector by its ID or filter with the provided vector and/or metadata.
-   * @param indexName - The name of the index containing the vector.
-   * @param id - The ID of the vector to update.
-   * @param filter - The filter to match vectors to update.
-   * @param update - An object containing the vector and/or metadata to update.
-   * @param update.vector - An optional array of numbers representing the new vector.
-   * @param update.metadata - An optional record containing the new metadata.
-   * @returns A promise that resolves when the update is complete.
-   * @throws Will throw an error if no updates are provided or if the update operation fails.
-   */
-  async updateVector({ indexName, id, filter, update }) {
-    if (id && filter) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("TURBOPUFFER", "UPDATE_VECTOR", "MUTUALLY_EXCLUSIVE"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "id and filter are mutually exclusive",
-        details: { indexName }
-      });
-    }
-    if (!id && !filter) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("TURBOPUFFER", "UPDATE_VECTOR", "NO_TARGET"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "Either id or filter must be provided",
-        details: { indexName }
-      });
-    }
-    if (!update.vector && !update.metadata) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("TURBOPUFFER", "UPDATE_VECTOR", "NO_PAYLOAD"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "No update data provided",
-        details: { indexName, ...id && { id } }
-      });
-    }
-    let namespace;
-    let createIndex;
-    let distanceMetric;
-    try {
-      namespace = this.client.namespace(indexName);
-      createIndex = this.createIndexCache.get(indexName);
-      if (!createIndex) {
-        throw new Error(`createIndex() not called for this index`);
-      }
-      distanceMetric = createIndex.tpufDistanceMetric;
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("TURBOPUFFER", "UPDATE_VECTOR", "INVALID_ARGS"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: { indexName }
-        },
-        error$1
-      );
-    }
-    try {
-      let idsToUpdate = [];
-      if (id) {
-        idsToUpdate = [id];
-      } else if (filter) {
-        if (Object.keys(filter).length === 0) {
-          throw new error.MastraError({
-            id: storage.createVectorErrorId("TURBOPUFFER", "UPDATE_VECTOR", "EMPTY_FILTER"),
-            domain: error.ErrorDomain.STORAGE,
-            category: error.ErrorCategory.USER,
-            text: "Filter cannot be an empty object",
-            details: { indexName }
-          });
-        }
-        const dummyVector = new Array(createIndex.dimension).fill(1 / Math.sqrt(createIndex.dimension));
-        const translatedFilter = this.filterTranslator.translate(filter);
-        const results = await namespace.query({
-          rank_by: ["vector", "ANN", dummyVector],
-          top_k: 1e4,
-          // Get all matching vectors
-          filters: translatedFilter,
-          vector_encoding: update.vector ? void 0 : "float",
-          // Only fetch vectors if we're not replacing them
-          include_attributes: true
-        });
-        const rows = results.rows ?? [];
-        idsToUpdate = rows.map((r) => String(r.id));
-        if (!update.vector || !update.metadata) {
-          for (const result of rows) {
-            const { id: resultId, vector, $dist, ...metadata } = result;
-            const record = { id: resultId };
-            if (update.vector) {
-              record.vector = update.vector;
-            } else if (Array.isArray(vector)) {
-              record.vector = vector;
-            }
-            if (update.metadata) {
-              Object.assign(record, update.metadata);
-            } else {
-              Object.assign(record, metadata);
-            }
-            await namespace.write({
-              upsert_rows: [record],
-              distance_metric: distanceMetric
-            });
-          }
-          return;
-        }
-      }
-      if (idsToUpdate.length === 0) {
-        this.logger.info(`No vectors matched the criteria for update in ${indexName}`);
-        return;
-      }
-      const records = idsToUpdate.map((vecId) => ({
-        id: vecId,
-        ...update.vector ? { vector: update.vector } : {},
-        ...update.metadata || {}
-      }));
-      const batchSize = 1e3;
-      for (let i = 0; i < records.length; i += batchSize) {
-        const batch = records.slice(i, i + batchSize);
-        await namespace.write({
-          upsert_rows: batch,
-          distance_metric: distanceMetric
-        });
-      }
-    } catch (error$1) {
-      if (error$1 instanceof error.MastraError) throw error$1;
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("TURBOPUFFER", "UPDATE_VECTOR", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            indexName,
-            ...id && { id },
-            ...filter && { filter: JSON.stringify(filter) }
-          }
-        },
-        error$1
-      );
-    }
-  }
-  /**
-   * Deletes a vector by its ID.
-   * @param indexName - The name of the index containing the vector.
-   * @param id - The ID of the vector to delete.
-   * @returns A promise that resolves when the deletion is complete.
-   * @throws Will throw an error if the deletion operation fails.
-   */
-  async deleteVector({ indexName, id }) {
-    try {
-      const namespace = this.client.namespace(indexName);
-      await namespace.write({ deletes: [id] });
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("TURBOPUFFER", "DELETE_VECTOR", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName }
-        },
-        error$1
-      );
-    }
-  }
-  async deleteVectors({ indexName, filter, ids }) {
-    if (ids && filter) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("TURBOPUFFER", "DELETE_VECTORS", "MUTUALLY_EXCLUSIVE"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "ids and filter are mutually exclusive",
-        details: { indexName }
-      });
-    }
-    if (!ids && !filter) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("TURBOPUFFER", "DELETE_VECTORS", "NO_TARGET"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "Either filter or ids must be provided",
-        details: { indexName }
-      });
-    }
-    if (ids && ids.length === 0) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("TURBOPUFFER", "DELETE_VECTORS", "EMPTY_IDS"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "ids array cannot be empty",
-        details: { indexName }
-      });
-    }
-    if (filter && Object.keys(filter).length === 0) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("TURBOPUFFER", "DELETE_VECTORS", "EMPTY_FILTER"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "Filter cannot be an empty object",
-        details: { indexName }
-      });
-    }
-    try {
-      const namespace = this.client.namespace(indexName);
-      let idsToDelete = [];
-      if (ids) {
-        idsToDelete = ids;
-      } else if (filter) {
-        const createIndex = this.createIndexCache.get(indexName);
-        if (!createIndex) {
-          throw new Error(`createIndex() not called for this index`);
-        }
-        const dummyVector = new Array(createIndex.dimension).fill(1 / Math.sqrt(createIndex.dimension));
-        const translatedFilter = this.filterTranslator.translate(filter);
-        const results = await namespace.query({
-          rank_by: ["vector", "ANN", dummyVector],
-          top_k: 1e4,
-          // Get all matching vectors
-          filters: translatedFilter,
-          include_attributes: []
-        });
-        idsToDelete = (results.rows ?? []).map((r) => String(r.id));
-      }
-      if (idsToDelete.length === 0) {
-        this.logger.info(`No vectors matched the criteria for deletion in ${indexName}`);
-        return;
-      }
-      const batchSize = 1e3;
-      for (let i = 0; i < idsToDelete.length; i += batchSize) {
-        const batch = idsToDelete.slice(i, i + batchSize);
-        await namespace.write({ deletes: batch });
-      }
-    } catch (error$1) {
-      if (error$1 instanceof error.MastraError) throw error$1;
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("TURBOPUFFER", "DELETE_VECTORS", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            indexName,
-            ...filter && { filter: JSON.stringify(filter) },
-            ...ids && { idsCount: ids.length }
-          }
-        },
-        error$1
-      );
-    }
-  }
+//#endregion
+//#region src/vector/index.ts
+var TurbopufferVector = class extends _mastra_core_vector.MastraVector {
+	client;
+	filterTranslator;
+	createIndexCache = /* @__PURE__ */ new Map();
+	opts;
+	constructor(opts) {
+		super({ id: opts.id });
+		this.filterTranslator = new TurbopufferFilterTranslator();
+		this.opts = opts;
+		this.client = new _turbopuffer_turbopuffer.Turbopuffer(opts);
+	}
+	async createIndex({ indexName, dimension, metric }) {
+		metric = metric ?? "cosine";
+		let distanceMetric = "cosine_distance";
+		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 _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("TURBOPUFFER", "CREATE_INDEX", "INVALID_ARGS"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.USER,
+				details: {
+					indexName,
+					dimension,
+					metric
+				}
+			}, error);
+		}
+		this.createIndexCache.set(indexName, {
+			indexName,
+			dimension,
+			metric,
+			tpufDistanceMetric: distanceMetric
+		});
+	}
+	async upsert({ indexName, vectors, metadata, ids }) {
+		let index;
+		let createIndex;
+		try {
+			if (vectors.length === 0) throw new Error("upsert() called with empty vectors");
+			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 _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("TURBOPUFFER", "UPSERT", "INVALID_ARGS"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.USER,
+				details: { indexName }
+			}, error);
+		}
+		try {
+			const distanceMetric = createIndex.tpufDistanceMetric;
+			const vectorIds = ids || vectors.map(() => crypto.randomUUID());
+			const records = vectors.map((vector, i) => ({
+				id: vectorIds[i],
+				vector,
+				...metadata?.[i] || {}
+			}));
+			const batchSize = 100;
+			for (let i = 0; i < records.length; i += batchSize) {
+				const writeOptions = {
+					upsert_rows: records.slice(i, i + batchSize),
+					distance_metric: distanceMetric
+				};
+				const schemaConfig = this.opts.schemaConfigForIndex?.(indexName);
+				if (schemaConfig) {
+					writeOptions.schema = schemaConfig.schema;
+					if (vectors[0]?.length !== schemaConfig.dimensions) throw new Error(`Turbopuffer index ${indexName} was configured with dimensions=${schemaConfig.dimensions} but attempting to upsert vectors[0].length=${vectors[0]?.length}`);
+				}
+				await index.write(writeOptions);
+			}
+			return vectorIds;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("TURBOPUFFER", "UPSERT", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { indexName }
+			}, error);
+		}
+	}
+	async query({ indexName, queryVector, topK, filter, includeVector, consistency }) {
+		if (!queryVector) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("TURBOPUFFER", "QUERY", "MISSING_VECTOR"),
+			text: "queryVector is required for Turbopuffer queries. Metadata-only queries are not supported by this vector store.",
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			details: { indexName }
+		});
+		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}`);
+			}
+			createIndex = this.createIndexCache.get(indexName);
+			if (!createIndex) throw new Error(`createIndex() not called for this index`);
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("TURBOPUFFER", "QUERY", "INVALID_ARGS"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.USER,
+				details: { indexName }
+			}, error);
+		}
+		const distanceMetric = createIndex.tpufDistanceMetric;
+		try {
+			const index = this.client.namespace(indexName);
+			const translatedFilter = this.filterTranslator.translate(filter);
+			return ((await index.query({
+				distance_metric: distanceMetric,
+				rank_by: [
+					"vector",
+					"ANN",
+					queryVector
+				],
+				top_k: topK,
+				filters: translatedFilter,
+				vector_encoding: includeVector ? "float" : void 0,
+				include_attributes: true,
+				consistency: { level: consistency ?? this.opts.consistency ?? "strong" }
+			})).rows ?? []).map((item) => {
+				const { id, vector, $dist, ...metadata } = item;
+				return {
+					id: String(id),
+					score: typeof $dist === "number" ? $dist : 0,
+					metadata,
+					...includeVector && Array.isArray(vector) ? { vector } : {}
+				};
+			});
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("TURBOPUFFER", "QUERY", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { indexName }
+			}, error);
+		}
+	}
+	async listIndexes() {
+		try {
+			return (await this.client.namespaces({})).namespaces.map((namespace) => namespace.id);
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("TURBOPUFFER", "LIST_INDEXES", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY
+			}, error);
+		}
+	}
+	/**
+	* Retrieves statistics about a vector index.
+	*
+	* @param {string} indexName - The name of the index to describe
+	* @returns A promise that resolves to the index statistics including dimension, count and metric
+	*/
+	async describeIndex({ indexName }) {
+		try {
+			const metadata = await this.client.namespace(indexName).metadata();
+			const createIndex = this.createIndexCache.get(indexName);
+			if (!createIndex) throw new Error(`createIndex() not called for this index`);
+			return {
+				dimension: createIndex.dimension,
+				count: metadata.approx_row_count,
+				metric: createIndex.metric
+			};
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("TURBOPUFFER", "DESCRIBE_INDEX", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { indexName }
+			}, error);
+		}
+	}
+	async deleteIndex({ indexName }) {
+		try {
+			await this.client.namespace(indexName).deleteAll();
+			this.createIndexCache.delete(indexName);
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("TURBOPUFFER", "DELETE_INDEX", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { indexName }
+			}, error);
+		}
+	}
+	/**
+	* Updates a vector by its ID or filter with the provided vector and/or metadata.
+	* @param indexName - The name of the index containing the vector.
+	* @param id - The ID of the vector to update.
+	* @param filter - The filter to match vectors to update.
+	* @param update - An object containing the vector and/or metadata to update.
+	* @param update.vector - An optional array of numbers representing the new vector.
+	* @param update.metadata - An optional record containing the new metadata.
+	* @returns A promise that resolves when the update is complete.
+	* @throws Will throw an error if no updates are provided or if the update operation fails.
+	*/
+	async updateVector({ indexName, id, filter, update }) {
+		if (id && filter) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("TURBOPUFFER", "UPDATE_VECTOR", "MUTUALLY_EXCLUSIVE"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			text: "id and filter are mutually exclusive",
+			details: { indexName }
+		});
+		if (!id && !filter) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("TURBOPUFFER", "UPDATE_VECTOR", "NO_TARGET"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			text: "Either id or filter must be provided",
+			details: { indexName }
+		});
+		if (!update.vector && !update.metadata) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("TURBOPUFFER", "UPDATE_VECTOR", "NO_PAYLOAD"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			text: "No update data provided",
+			details: {
+				indexName,
+				...id && { id }
+			}
+		});
+		let namespace;
+		let createIndex;
+		let distanceMetric;
+		try {
+			namespace = this.client.namespace(indexName);
+			createIndex = this.createIndexCache.get(indexName);
+			if (!createIndex) throw new Error(`createIndex() not called for this index`);
+			distanceMetric = createIndex.tpufDistanceMetric;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("TURBOPUFFER", "UPDATE_VECTOR", "INVALID_ARGS"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.USER,
+				details: { indexName }
+			}, error);
+		}
+		try {
+			let idsToUpdate = [];
+			if (id) idsToUpdate = [id];
+			else if (filter) {
+				if (Object.keys(filter).length === 0) throw new _mastra_core_error.MastraError({
+					id: (0, _mastra_core_storage.createVectorErrorId)("TURBOPUFFER", "UPDATE_VECTOR", "EMPTY_FILTER"),
+					domain: _mastra_core_error.ErrorDomain.STORAGE,
+					category: _mastra_core_error.ErrorCategory.USER,
+					text: "Filter cannot be an empty object",
+					details: { indexName }
+				});
+				const dummyVector = new Array(createIndex.dimension).fill(1 / Math.sqrt(createIndex.dimension));
+				const translatedFilter = this.filterTranslator.translate(filter);
+				const rows = (await namespace.query({
+					rank_by: [
+						"vector",
+						"ANN",
+						dummyVector
+					],
+					top_k: 1e4,
+					filters: translatedFilter,
+					vector_encoding: update.vector ? void 0 : "float",
+					include_attributes: true
+				})).rows ?? [];
+				idsToUpdate = rows.map((r) => String(r.id));
+				if (!update.vector || !update.metadata) {
+					for (const result of rows) {
+						const { id: resultId, vector, $dist, ...metadata } = result;
+						const record = { id: resultId };
+						if (update.vector) record.vector = update.vector;
+						else if (Array.isArray(vector)) record.vector = vector;
+						if (update.metadata) Object.assign(record, update.metadata);
+						else Object.assign(record, metadata);
+						await namespace.write({
+							upsert_rows: [record],
+							distance_metric: distanceMetric
+						});
+					}
+					return;
+				}
+			}
+			if (idsToUpdate.length === 0) {
+				this.logger.info(`No vectors matched the criteria for update in ${indexName}`);
+				return;
+			}
+			const records = idsToUpdate.map((vecId) => ({
+				id: vecId,
+				...update.vector ? { vector: update.vector } : {},
+				...update.metadata || {}
+			}));
+			const batchSize = 1e3;
+			for (let i = 0; i < records.length; i += batchSize) {
+				const batch = records.slice(i, i + batchSize);
+				await namespace.write({
+					upsert_rows: batch,
+					distance_metric: distanceMetric
+				});
+			}
+		} catch (error) {
+			if (error instanceof _mastra_core_error.MastraError) throw error;
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("TURBOPUFFER", "UPDATE_VECTOR", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					...id && { id },
+					...filter && { filter: JSON.stringify(filter) }
+				}
+			}, error);
+		}
+	}
+	/**
+	* Deletes a vector by its ID.
+	* @param indexName - The name of the index containing the vector.
+	* @param id - The ID of the vector to delete.
+	* @returns A promise that resolves when the deletion is complete.
+	* @throws Will throw an error if the deletion operation fails.
+	*/
+	async deleteVector({ indexName, id }) {
+		try {
+			await this.client.namespace(indexName).write({ deletes: [id] });
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("TURBOPUFFER", "DELETE_VECTOR", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { indexName }
+			}, error);
+		}
+	}
+	async deleteVectors({ indexName, filter, ids }) {
+		if (ids && filter) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("TURBOPUFFER", "DELETE_VECTORS", "MUTUALLY_EXCLUSIVE"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			text: "ids and filter are mutually exclusive",
+			details: { indexName }
+		});
+		if (!ids && !filter) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("TURBOPUFFER", "DELETE_VECTORS", "NO_TARGET"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			text: "Either filter or ids must be provided",
+			details: { indexName }
+		});
+		if (ids && ids.length === 0) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("TURBOPUFFER", "DELETE_VECTORS", "EMPTY_IDS"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			text: "ids array cannot be empty",
+			details: { indexName }
+		});
+		if (filter && Object.keys(filter).length === 0) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("TURBOPUFFER", "DELETE_VECTORS", "EMPTY_FILTER"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			text: "Filter cannot be an empty object",
+			details: { indexName }
+		});
+		try {
+			const namespace = this.client.namespace(indexName);
+			let idsToDelete = [];
+			if (ids) idsToDelete = ids;
+			else if (filter) {
+				const createIndex = this.createIndexCache.get(indexName);
+				if (!createIndex) throw new Error(`createIndex() not called for this index`);
+				const dummyVector = new Array(createIndex.dimension).fill(1 / Math.sqrt(createIndex.dimension));
+				const translatedFilter = this.filterTranslator.translate(filter);
+				idsToDelete = ((await namespace.query({
+					rank_by: [
+						"vector",
+						"ANN",
+						dummyVector
+					],
+					top_k: 1e4,
+					filters: translatedFilter,
+					include_attributes: []
+				})).rows ?? []).map((r) => String(r.id));
+			}
+			if (idsToDelete.length === 0) {
+				this.logger.info(`No vectors matched the criteria for deletion in ${indexName}`);
+				return;
+			}
+			const batchSize = 1e3;
+			for (let i = 0; i < idsToDelete.length; i += batchSize) {
+				const batch = idsToDelete.slice(i, i + batchSize);
+				await namespace.write({ deletes: batch });
+			}
+		} catch (error) {
+			if (error instanceof _mastra_core_error.MastraError) throw error;
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("TURBOPUFFER", "DELETE_VECTORS", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					...filter && { filter: JSON.stringify(filter) },
+					...ids && { idsCount: ids.length }
+				}
+			}, error);
+		}
+	}
 };
-
+//#endregion
 exports.TurbopufferVector = TurbopufferVector;
-//# sourceMappingURL=index.cjs.map
+
 //# sourceMappingURL=index.cjs.map