@mastra/astra 1.1.0 → 1.1.1-alpha.0

package/dist/index.cjs

@@ -1,371 +1,326 @@
-'use strict';
-
-var astraDbTs = require('@datastax/astra-db-ts');
-var error = require('@mastra/core/error');
-var storage = require('@mastra/core/storage');
-var vector = require('@mastra/core/vector');
-var filter = require('@mastra/core/vector/filter');
-
-// src/vector/index.ts
-var AstraFilterTranslator = class extends filter.BaseFilterTranslator {
-  getSupportedOperators() {
-    return {
-      ...filter.BaseFilterTranslator.DEFAULT_OPERATORS,
-      array: ["$all", "$in", "$nin"],
-      logical: ["$and", "$or", "$not"],
-      regex: [],
-      custom: ["$size"]
-    };
-  }
-  translate(filter) {
-    if (this.isEmpty(filter)) return filter;
-    this.validateFilter(filter);
-    return this.translateNode(filter);
-  }
-  translateNode(node) {
-    if (this.isRegex(node)) {
-      throw new Error("Regex is not supported in Astra DB");
-    }
-    if (this.isPrimitive(node) || Array.isArray(node)) {
-      return node;
-    }
-    const entries = Object.entries(node);
-    const translatedEntries = entries.map(([key, value]) => {
-      if (this.isOperator(key)) {
-        return [key, this.translateOperatorValue(key, value)];
-      }
-      return [key, this.translateNode(value)];
-    });
-    return Object.fromEntries(translatedEntries);
-  }
-  translateOperatorValue(operator, value) {
-    if (this.isBasicOperator(operator) || this.isNumericOperator(operator)) {
-      return this.normalizeComparisonValue(value);
-    }
-    if (this.isArrayOperator(operator) && Array.isArray(value)) {
-      return this.normalizeArrayValues(value);
-    }
-    return this.translateNode(value);
-  }
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _datastax_astra_db_ts = require("@datastax/astra-db-ts");
+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 _mastra_core_vector_filter = require("@mastra/core/vector/filter");
+//#region src/vector/filter.ts
+/**
+* Translator for Astra DB filter queries.
+* Maintains MongoDB-compatible syntax while ensuring proper validation
+* and normalization of values.
+*/
+var AstraFilterTranslator = class extends _mastra_core_vector_filter.BaseFilterTranslator {
+	getSupportedOperators() {
+		return {
+			..._mastra_core_vector_filter.BaseFilterTranslator.DEFAULT_OPERATORS,
+			array: [
+				"$all",
+				"$in",
+				"$nin"
+			],
+			logical: [
+				"$and",
+				"$or",
+				"$not"
+			],
+			regex: [],
+			custom: ["$size"]
+		};
+	}
+	translate(filter) {
+		if (this.isEmpty(filter)) return filter;
+		this.validateFilter(filter);
+		return this.translateNode(filter);
+	}
+	translateNode(node) {
+		if (this.isRegex(node)) throw new Error("Regex is not supported in Astra DB");
+		if (this.isPrimitive(node) || Array.isArray(node)) return node;
+		const translatedEntries = Object.entries(node).map(([key, value]) => {
+			if (this.isOperator(key)) return [key, this.translateOperatorValue(key, value)];
+			return [key, this.translateNode(value)];
+		});
+		return Object.fromEntries(translatedEntries);
+	}
+	translateOperatorValue(operator, value) {
+		if (this.isBasicOperator(operator) || this.isNumericOperator(operator)) return this.normalizeComparisonValue(value);
+		if (this.isArrayOperator(operator) && Array.isArray(value)) return this.normalizeArrayValues(value);
+		return this.translateNode(value);
+	}
 };
-
-// src/vector/index.ts
-var metricMap = {
-  cosine: "cosine",
-  euclidean: "euclidean",
-  dotproduct: "dot_product"
+//#endregion
+//#region src/vector/index.ts
+const metricMap = {
+	cosine: "cosine",
+	euclidean: "euclidean",
+	dotproduct: "dot_product"
 };
-var AstraVector = class extends vector.MastraVector {
-  #db;
-  constructor({ token, endpoint, keyspace, id }) {
-    super({ id });
-    const client = new astraDbTs.DataAPIClient(token);
-    this.#db = client.db(endpoint, { keyspace });
-  }
-  /**
-   * Creates a new collection with the specified configuration.
-   *
-   * @param {string} indexName - The name of the collection to create.
-   * @param {number} dimension - The dimension of the vectors to be stored in the collection.
-   * @param {'cosine' | 'euclidean' | 'dotproduct'} [metric=cosine] - The metric to use to sort vectors in the collection.
-   * @returns {Promise<void>} A promise that resolves when the collection is created.
-   */
-  async createIndex({ indexName, dimension, metric = "cosine" }) {
-    if (!Number.isInteger(dimension) || dimension <= 0) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("ASTRA", "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: storage.createVectorErrorId("ASTRA", "CREATE_INDEX", "DB_ERROR"),
-          domain: error.ErrorDomain.MASTRA_VECTOR,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName }
-        },
-        error$1
-      );
-    }
-  }
-  /**
-   * Inserts or updates vectors in the specified collection.
-   *
-   * @param {string} indexName - The name of the collection to upsert into.
-   * @param {number[][]} vectors - An array of vectors to upsert.
-   * @param {Record<string, any>[]} [metadata] - An optional array of metadata objects corresponding to each vector.
-   * @param {string[]} [ids] - An optional array of IDs corresponding to each vector. If not provided, new IDs will be generated.
-   * @returns {Promise<string[]>} A promise that resolves to an array of IDs of the upserted vectors.
-   */
-  async upsert({ indexName, vectors, metadata, ids }) {
-    const collection = this.#db.collection(indexName);
-    const vectorIds = ids || vectors.map(() => astraDbTs.UUID.v7().toString());
-    const records = vectors.map((vector, i) => ({
-      id: vectorIds[i],
-      $vector: vector,
-      metadata: metadata?.[i] || {}
-    }));
-    try {
-      await collection.insertMany(records);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("ASTRA", "UPSERT", "DB_ERROR"),
-          domain: error.ErrorDomain.MASTRA_VECTOR,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName }
-        },
-        error$1
-      );
-    }
-    return vectorIds;
-  }
-  transformFilter(filter) {
-    const translator = new AstraFilterTranslator();
-    return translator.translate(filter);
-  }
-  /**
-   * Queries the specified collection using a vector and optional filter.
-   *
-   * @param {string} indexName - The name of the collection to query.
-   * @param {number[]} queryVector - The vector to query with.
-   * @param {number} [topK] - The maximum number of results to return.
-   * @param {Record<string, any>} [filter] - An optional filter to apply to the query. For more on filters in Astra DB, see the filtering reference: https://docs.datastax.com/en/astra-db-serverless/api-reference/documents.html#operators
-   * @param {boolean} [includeVectors=false] - Whether to include the vectors in the response.
-   * @returns {Promise<QueryResult[]>} A promise that resolves to an array of query results.
-   */
-  async query({
-    indexName,
-    queryVector,
-    topK = 10,
-    filter,
-    includeVector = false
-  }) {
-    if (!queryVector) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("ASTRA", "QUERY", "MISSING_VECTOR"),
-        text: "queryVector is required for Astra queries. Metadata-only queries are not supported by this vector store.",
-        domain: error.ErrorDomain.MASTRA_VECTOR,
-        category: error.ErrorCategory.USER,
-        details: { indexName }
-      });
-    }
-    const collection = this.#db.collection(indexName);
-    const translatedFilter = this.transformFilter(filter);
-    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: storage.createVectorErrorId("ASTRA", "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.
-   */
-  async listIndexes() {
-    try {
-      return await this.#db.listCollections({ nameOnly: true });
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("ASTRA", "LIST_INDEXES", "DB_ERROR"),
-          domain: error.ErrorDomain.MASTRA_VECTOR,
-          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 }) {
-    const collection = this.#db.collection(indexName);
-    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: storage.createVectorErrorId("ASTRA", "DESCRIBE_INDEX", "DB_ERROR"),
-          domain: error.ErrorDomain.MASTRA_VECTOR,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName }
-        },
-        error$1
-      );
-    }
-  }
-  /**
-   * Deletes the specified collection.
-   *
-   * @param {string} indexName - The name of the collection to delete.
-   * @returns {Promise<void>} A promise that resolves when the collection is deleted.
-   */
-  async deleteIndex({ indexName }) {
-    const collection = this.#db.collection(indexName);
-    try {
-      await collection.drop();
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("ASTRA", "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.
-   * @param indexName - The name of the index containing the vector.
-   * @param id - The ID of the vector 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, update }) {
-    if (!id) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("ASTRA", "UPDATE_VECTOR", "NO_ID"),
-        text: "id is required for Astra updateVector",
-        domain: error.ErrorDomain.MASTRA_VECTOR,
-        category: error.ErrorCategory.USER,
-        details: { indexName }
-      });
-    }
-    if (!update.vector && !update.metadata) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("ASTRA", "UPDATE_VECTOR", "NO_PAYLOAD"),
-        text: "No updates provided for vector",
-        domain: error.ErrorDomain.MASTRA_VECTOR,
-        category: error.ErrorCategory.USER,
-        details: {
-          indexName,
-          id
-        }
-      });
-    }
-    try {
-      const collection = this.#db.collection(indexName);
-      const updateDoc = {};
-      if (update.vector) {
-        updateDoc.$vector = update.vector;
-      }
-      if (update.metadata) {
-        updateDoc.metadata = update.metadata;
-      }
-      await collection.findOneAndUpdate({ id }, { $set: updateDoc });
-    } catch (error$1) {
-      if (error$1 instanceof error.MastraError) throw error$1;
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("ASTRA", "UPDATE_VECTOR", "FAILED_UNHANDLED"),
-          domain: error.ErrorDomain.MASTRA_VECTOR,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            indexName,
-            ...id && { id }
-          }
-        },
-        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 collection = this.#db.collection(indexName);
-      await collection.deleteOne({ id });
-    } catch (error$1) {
-      if (error$1 instanceof error.MastraError) throw error$1;
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("ASTRA", "DELETE_VECTOR", "FAILED"),
-          domain: error.ErrorDomain.MASTRA_VECTOR,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            indexName,
-            ...id && { id }
-          }
-        },
-        error$1
-      );
-    }
-  }
-  async deleteVectors({ indexName, filter, ids }) {
-    throw new error.MastraError({
-      id: storage.createVectorErrorId("ASTRA", "DELETE_VECTORS", "NOT_SUPPORTED"),
-      text: "deleteVectors is not yet implemented for Astra vector store",
-      domain: error.ErrorDomain.MASTRA_VECTOR,
-      category: error.ErrorCategory.SYSTEM,
-      details: {
-        indexName,
-        ...filter && { filter: JSON.stringify(filter) },
-        ...ids && { idsCount: ids.length }
-      }
-    });
-  }
+var AstraVector = class extends _mastra_core_vector.MastraVector {
+	#db;
+	constructor({ token, endpoint, keyspace, id }) {
+		super({ id });
+		const client = new _datastax_astra_db_ts.DataAPIClient(token);
+		this.#db = client.db(endpoint, { keyspace });
+	}
+	/**
+	* Creates a new collection with the specified configuration.
+	*
+	* @param {string} indexName - The name of the collection to create.
+	* @param {number} dimension - The dimension of the vectors to be stored in the collection.
+	* @param {'cosine' | 'euclidean' | 'dotproduct'} [metric=cosine] - The metric to use to sort vectors in the collection.
+	* @returns {Promise<void>} A promise that resolves when the collection is created.
+	*/
+	async createIndex({ indexName, dimension, metric = "cosine" }) {
+		if (!Number.isInteger(dimension) || dimension <= 0) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("ASTRA", "CREATE_INDEX", "INVALID_DIMENSION"),
+			text: "Dimension must be a positive integer",
+			domain: _mastra_core_error.ErrorDomain.MASTRA_VECTOR,
+			category: _mastra_core_error.ErrorCategory.USER
+		});
+		try {
+			await this.#db.createCollection(indexName, {
+				vector: {
+					dimension,
+					metric: metricMap[metric]
+				},
+				checkExists: false
+			});
+		} catch (error) {
+			new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("ASTRA", "CREATE_INDEX", "DB_ERROR"),
+				domain: _mastra_core_error.ErrorDomain.MASTRA_VECTOR,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { indexName }
+			}, error);
+		}
+	}
+	/**
+	* Inserts or updates vectors in the specified collection.
+	*
+	* @param {string} indexName - The name of the collection to upsert into.
+	* @param {number[][]} vectors - An array of vectors to upsert.
+	* @param {Record<string, any>[]} [metadata] - An optional array of metadata objects corresponding to each vector.
+	* @param {string[]} [ids] - An optional array of IDs corresponding to each vector. If not provided, new IDs will be generated.
+	* @returns {Promise<string[]>} A promise that resolves to an array of IDs of the upserted vectors.
+	*/
+	async upsert({ indexName, vectors, metadata, ids }) {
+		const collection = this.#db.collection(indexName);
+		const vectorIds = ids || vectors.map(() => _datastax_astra_db_ts.UUID.v7().toString());
+		const records = vectors.map((vector, i) => ({
+			id: vectorIds[i],
+			$vector: vector,
+			metadata: metadata?.[i] || {}
+		}));
+		try {
+			await collection.insertMany(records);
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("ASTRA", "UPSERT", "DB_ERROR"),
+				domain: _mastra_core_error.ErrorDomain.MASTRA_VECTOR,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { indexName }
+			}, error);
+		}
+		return vectorIds;
+	}
+	transformFilter(filter) {
+		return new AstraFilterTranslator().translate(filter);
+	}
+	/**
+	* Queries the specified collection using a vector and optional filter.
+	*
+	* @param {string} indexName - The name of the collection to query.
+	* @param {number[]} queryVector - The vector to query with.
+	* @param {number} [topK] - The maximum number of results to return.
+	* @param {Record<string, any>} [filter] - An optional filter to apply to the query. For more on filters in Astra DB, see the filtering reference: https://docs.datastax.com/en/astra-db-serverless/api-reference/documents.html#operators
+	* @param {boolean} [includeVectors=false] - Whether to include the vectors in the response.
+	* @returns {Promise<QueryResult[]>} A promise that resolves to an array of query results.
+	*/
+	async query({ indexName, queryVector, topK = 10, filter, includeVector = false }) {
+		if (!queryVector) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("ASTRA", "QUERY", "MISSING_VECTOR"),
+			text: "queryVector is required for Astra queries. Metadata-only queries are not supported by this vector store.",
+			domain: _mastra_core_error.ErrorDomain.MASTRA_VECTOR,
+			category: _mastra_core_error.ErrorCategory.USER,
+			details: { indexName }
+		});
+		const collection = this.#db.collection(indexName);
+		const translatedFilter = this.transformFilter(filter);
+		try {
+			return (await collection.find(translatedFilter ?? {}, {
+				sort: { $vector: queryVector },
+				limit: topK,
+				includeSimilarity: true,
+				projection: { $vector: includeVector ? true : false }
+			}).toArray()).map((result) => ({
+				id: result.id,
+				score: result.$similarity,
+				metadata: result.metadata,
+				...includeVector && { vector: result.$vector }
+			}));
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("ASTRA", "QUERY", "DB_ERROR"),
+				domain: _mastra_core_error.ErrorDomain.MASTRA_VECTOR,
+				category: _mastra_core_error.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.
+	*/
+	async listIndexes() {
+		try {
+			return await this.#db.listCollections({ nameOnly: true });
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("ASTRA", "LIST_INDEXES", "DB_ERROR"),
+				domain: _mastra_core_error.ErrorDomain.MASTRA_VECTOR,
+				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 }) {
+		const collection = this.#db.collection(indexName);
+		try {
+			const optionsPromise = collection.options();
+			const countPromise = collection.countDocuments({}, 100);
+			const [options, count] = await Promise.all([optionsPromise, countPromise]);
+			const metric = Object.keys(metricMap).find((key) => metricMap[key] === options.vector?.metric);
+			return {
+				dimension: options.vector?.dimension,
+				metric,
+				count
+			};
+		} catch (error) {
+			if (error instanceof _mastra_core_error.MastraError) throw error;
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("ASTRA", "DESCRIBE_INDEX", "DB_ERROR"),
+				domain: _mastra_core_error.ErrorDomain.MASTRA_VECTOR,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { indexName }
+			}, error);
+		}
+	}
+	/**
+	* Deletes the specified collection.
+	*
+	* @param {string} indexName - The name of the collection to delete.
+	* @returns {Promise<void>} A promise that resolves when the collection is deleted.
+	*/
+	async deleteIndex({ indexName }) {
+		const collection = this.#db.collection(indexName);
+		try {
+			await collection.drop();
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("ASTRA", "DELETE_INDEX", "DB_ERROR"),
+				domain: _mastra_core_error.ErrorDomain.MASTRA_VECTOR,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { indexName }
+			}, error);
+		}
+	}
+	/**
+	* Updates a vector by its ID 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 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, update }) {
+		if (!id) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("ASTRA", "UPDATE_VECTOR", "NO_ID"),
+			text: "id is required for Astra updateVector",
+			domain: _mastra_core_error.ErrorDomain.MASTRA_VECTOR,
+			category: _mastra_core_error.ErrorCategory.USER,
+			details: { indexName }
+		});
+		if (!update.vector && !update.metadata) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("ASTRA", "UPDATE_VECTOR", "NO_PAYLOAD"),
+			text: "No updates provided for vector",
+			domain: _mastra_core_error.ErrorDomain.MASTRA_VECTOR,
+			category: _mastra_core_error.ErrorCategory.USER,
+			details: {
+				indexName,
+				id
+			}
+		});
+		try {
+			const collection = this.#db.collection(indexName);
+			const updateDoc = {};
+			if (update.vector) updateDoc.$vector = update.vector;
+			if (update.metadata) updateDoc.metadata = update.metadata;
+			await collection.findOneAndUpdate({ id }, { $set: updateDoc });
+		} catch (error) {
+			if (error instanceof _mastra_core_error.MastraError) throw error;
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("ASTRA", "UPDATE_VECTOR", "FAILED_UNHANDLED"),
+				domain: _mastra_core_error.ErrorDomain.MASTRA_VECTOR,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					...id && { id }
+				}
+			}, 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.#db.collection(indexName).deleteOne({ id });
+		} catch (error) {
+			if (error instanceof _mastra_core_error.MastraError) throw error;
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("ASTRA", "DELETE_VECTOR", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.MASTRA_VECTOR,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					...id && { id }
+				}
+			}, error);
+		}
+	}
+	async deleteVectors({ indexName, filter, ids }) {
+		throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("ASTRA", "DELETE_VECTORS", "NOT_SUPPORTED"),
+			text: "deleteVectors is not yet implemented for Astra vector store",
+			domain: _mastra_core_error.ErrorDomain.MASTRA_VECTOR,
+			category: _mastra_core_error.ErrorCategory.SYSTEM,
+			details: {
+				indexName,
+				...filter && { filter: JSON.stringify(filter) },
+				...ids && { idsCount: ids.length }
+			}
+		});
+	}
 };
-
-// src/vector/prompt.ts
-var ASTRA_PROMPT = `When querying Astra, you can ONLY use the operators listed below. Any other operators will be rejected.
+//#endregion
+//#region src/vector/prompt.ts
+/**
+* Vector store specific prompt that details supported operators and examples.
+* This prompt helps users construct valid filters for Astra Vector.
+*/
+const ASTRA_PROMPT = `When querying Astra, you can ONLY use the operators listed below. Any other operators will be rejected.
 Important: Don't explain how to construct the filter - use the specified operators and fields to search the content and return relevant results.
 If a user tries to give an explicit operator that is not supported, reject the filter entirely and let them know that the operator is not supported.
 
@@ -452,8 +407,8 @@ Example Complex Query:
     ]}
   ]
 }`;
-
+//#endregion
 exports.ASTRA_PROMPT = ASTRA_PROMPT;
 exports.AstraVector = AstraVector;
-//# sourceMappingURL=index.cjs.map
+
 //# sourceMappingURL=index.cjs.map