@mastra/vectorize 1.1.0 → 1.1.1

package/dist/index.cjs

@@ -1,410 +1,430 @@
-'use strict';
-
-var error = require('@mastra/core/error');
-var storage = require('@mastra/core/storage');
-var vector = require('@mastra/core/vector');
-var Cloudflare = require('cloudflare');
-var filter = require('@mastra/core/vector/filter');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var Cloudflare__default = /*#__PURE__*/_interopDefault(Cloudflare);
-
-// src/vector/index.ts
-var VectorizeFilterTranslator = class extends filter.BaseFilterTranslator {
-  getSupportedOperators() {
-    return {
-      ...filter.BaseFilterTranslator.DEFAULT_OPERATORS,
-      logical: [],
-      array: ["$in", "$nin"],
-      element: [],
-      regex: [],
-      custom: []
-    };
-  }
-  translate(filter) {
-    if (this.isEmpty(filter)) return filter;
-    this.validateFilter(filter);
-    return this.translateNode(filter);
-  }
-  translateNode(node, currentPath = "") {
-    if (this.isRegex(node)) {
-      throw new Error("Regex is not supported in Vectorize");
-    }
-    if (this.isPrimitive(node)) return { $eq: this.normalizeComparisonValue(node) };
-    if (Array.isArray(node)) return { $in: this.normalizeArrayValues(node) };
-    const entries = Object.entries(node);
-    const firstEntry = entries[0];
-    if (entries.length === 1 && firstEntry && this.isOperator(firstEntry[0])) {
-      const [operator, value] = firstEntry;
-      return { [operator]: this.normalizeComparisonValue(value) };
-    }
-    const result = {};
-    for (const [key, value] of entries) {
-      const newPath = currentPath ? `${currentPath}.${key}` : key;
-      if (this.isOperator(key)) {
-        result[key] = this.normalizeComparisonValue(value);
-        continue;
-      }
-      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-        if (Object.keys(value).length === 0) {
-          result[newPath] = this.translateNode(value);
-          continue;
-        }
-        const hasOperators = Object.keys(value).some((k) => this.isOperator(k));
-        if (hasOperators) {
-          result[newPath] = this.translateNode(value);
-        } else {
-          Object.assign(result, this.translateNode(value, newPath));
-        }
-      } else {
-        result[newPath] = this.translateNode(value);
-      }
-    }
-    return result;
-  }
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
 };
-
-// src/vector/index.ts
-var CloudflareVector = class extends vector.MastraVector {
-  client;
-  accountId;
-  constructor({ accountId, apiToken, id }) {
-    super({ id });
-    this.accountId = accountId;
-    this.client = new Cloudflare__default.default({
-      apiToken
-    });
-  }
-  get indexSeparator() {
-    return "-";
-  }
-  async upsert({ indexName, vectors, metadata, ids }) {
-    const generatedIds = ids || vectors.map(() => crypto.randomUUID());
-    const ndjson = vectors.map(
-      (vector, index) => JSON.stringify({
-        id: generatedIds[index],
-        values: vector,
-        metadata: metadata?.[index]
-      })
-    ).join("\n");
-    try {
-      const body = new File([ndjson], `${indexName}.ndjson`, { type: "application/x-ndjson" });
-      await this.client.vectorize.indexes.upsert(indexName, {
-        account_id: this.accountId,
-        body
-      });
-      return generatedIds;
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("VECTORIZE", "UPSERT", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName, vectorCount: vectors?.length }
-        },
-        error$1
-      );
-    }
-  }
-  transformFilter(filter) {
-    const translator = new VectorizeFilterTranslator();
-    return translator.translate(filter);
-  }
-  async createIndex({ indexName, dimension, metric = "cosine" }) {
-    try {
-      await this.client.vectorize.indexes.create({
-        account_id: this.accountId,
-        config: {
-          dimensions: dimension,
-          metric: metric === "dotproduct" ? "dot-product" : metric
-        },
-        name: indexName
-      });
-    } catch (error$1) {
-      const message = error$1?.errors?.[0]?.message || error$1?.message;
-      if (error$1.status === 409 || typeof message === "string" && (message.toLowerCase().includes("already exists") || message.toLowerCase().includes("duplicate"))) {
-        await this.validateExistingIndex(indexName, dimension, metric);
-        return;
-      }
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("VECTORIZE", "CREATE_INDEX", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName, dimension, metric }
-        },
-        error$1
-      );
-    }
-  }
-  async query({
-    indexName,
-    queryVector,
-    topK = 10,
-    filter,
-    includeVector = false
-  }) {
-    if (!queryVector) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("VECTORIZE", "QUERY", "MISSING_VECTOR"),
-        text: "queryVector is required for Vectorize queries. Metadata-only queries are not supported by this vector store.",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        details: { indexName }
-      });
-    }
-    try {
-      const translatedFilter = this.transformFilter(filter) ?? {};
-      const response = await this.client.vectorize.indexes.query(indexName, {
-        account_id: this.accountId,
-        vector: queryVector,
-        returnValues: includeVector,
-        returnMetadata: "all",
-        topK,
-        filter: translatedFilter
-      });
-      return response?.matches?.map((match) => {
-        return {
-          id: match.id,
-          metadata: match.metadata,
-          score: match.score,
-          vector: match.values
-        };
-      }) || [];
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("VECTORIZE", "QUERY", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName, topK }
-        },
-        error$1
-      );
-    }
-  }
-  async listIndexes() {
-    try {
-      const res = await this.client.vectorize.indexes.list({
-        account_id: this.accountId
-      });
-      return res?.result?.map((index) => index.name) || [];
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("VECTORIZE", "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 index = await this.client.vectorize.indexes.get(indexName, {
-        account_id: this.accountId
-      });
-      const described = await this.client.vectorize.indexes.info(indexName, {
-        account_id: this.accountId
-      });
-      return {
-        dimension: described?.dimensions,
-        // Since vector_count is not available in the response,
-        // we might need a separate API call to get the count if needed
-        count: described?.vectorCount || 0,
-        metric: index?.config?.metric
-      };
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("VECTORIZE", "DESCRIBE_INDEX", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName }
-        },
-        error$1
-      );
-    }
-  }
-  async deleteIndex({ indexName }) {
-    try {
-      await this.client.vectorize.indexes.delete(indexName, {
-        account_id: this.accountId
-      });
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("VECTORIZE", "DELETE_INDEX", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName }
-        },
-        error$1
-      );
-    }
-  }
-  async createMetadataIndex(indexName, propertyName, indexType) {
-    try {
-      await this.client.vectorize.indexes.metadataIndex.create(indexName, {
-        account_id: this.accountId,
-        propertyName,
-        indexType
-      });
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("VECTORIZE", "CREATE_METADATA_INDEX", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName, propertyName, indexType }
-        },
-        error$1
-      );
-    }
-  }
-  async deleteMetadataIndex(indexName, propertyName) {
-    try {
-      await this.client.vectorize.indexes.metadataIndex.delete(indexName, {
-        account_id: this.accountId,
-        propertyName
-      });
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("VECTORIZE", "DELETE_METADATA_INDEX", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName, propertyName }
-        },
-        error$1
-      );
-    }
-  }
-  async listMetadataIndexes(indexName) {
-    try {
-      const res = await this.client.vectorize.indexes.metadataIndex.list(indexName, {
-        account_id: this.accountId
-      });
-      return res?.metadataIndexes ?? [];
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("VECTORIZE", "LIST_METADATA_INDEXES", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          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("VECTORIZE", "UPDATE_VECTOR", "INVALID_ARGS"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "id is required for Vectorize updateVector",
-        details: { indexName }
-      });
-    }
-    if (!update.vector && !update.metadata) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("VECTORIZE", "UPDATE_VECTOR", "NO_PAYLOAD"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "No update data provided",
-        details: { indexName, id }
-      });
-    }
-    try {
-      const updatePayload = {
-        };
-      if (update.vector) {
-        updatePayload.vectors = [update.vector];
-      }
-      if (update.metadata) {
-        updatePayload.metadata = [update.metadata];
-      }
-      await this.upsert({ indexName, vectors: updatePayload.vectors, metadata: updatePayload.metadata });
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("VECTORIZE", "UPDATE_VECTOR", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          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 {
-      await this.client.vectorize.indexes.deleteByIds(indexName, {
-        ids: [id],
-        account_id: this.accountId
-      });
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("VECTORIZE", "DELETE_VECTOR", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            indexName,
-            ...id && { id }
-          }
-        },
-        error$1
-      );
-    }
-  }
-  async deleteVectors({ indexName, filter, ids }) {
-    throw new error.MastraError({
-      id: storage.createVectorErrorId("VECTORIZE", "DELETE_VECTORS", "NOT_SUPPORTED"),
-      text: "deleteVectors is not yet implemented for Vectorize vector store",
-      domain: error.ErrorDomain.STORAGE,
-      category: error.ErrorCategory.SYSTEM,
-      details: {
-        indexName,
-        ...filter && { filter: JSON.stringify(filter) },
-        ...ids && { idsCount: ids.length }
-      }
-    });
-  }
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+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 cloudflare = require("cloudflare");
+cloudflare = __toESM(cloudflare, 1);
+let _mastra_core_vector_filter = require("@mastra/core/vector/filter");
+//#region src/vector/filter.ts
+var VectorizeFilterTranslator = class extends _mastra_core_vector_filter.BaseFilterTranslator {
+	getSupportedOperators() {
+		return {
+			..._mastra_core_vector_filter.BaseFilterTranslator.DEFAULT_OPERATORS,
+			logical: [],
+			array: ["$in", "$nin"],
+			element: [],
+			regex: [],
+			custom: []
+		};
+	}
+	translate(filter) {
+		if (this.isEmpty(filter)) return filter;
+		this.validateFilter(filter);
+		return this.translateNode(filter);
+	}
+	translateNode(node, currentPath = "") {
+		if (this.isRegex(node)) throw new Error("Regex is not supported in Vectorize");
+		if (this.isPrimitive(node)) return { $eq: this.normalizeComparisonValue(node) };
+		if (Array.isArray(node)) return { $in: this.normalizeArrayValues(node) };
+		const entries = Object.entries(node);
+		const firstEntry = entries[0];
+		if (entries.length === 1 && firstEntry && this.isOperator(firstEntry[0])) {
+			const [operator, value] = firstEntry;
+			return { [operator]: this.normalizeComparisonValue(value) };
+		}
+		const result = {};
+		for (const [key, value] of entries) {
+			const newPath = currentPath ? `${currentPath}.${key}` : key;
+			if (this.isOperator(key)) {
+				result[key] = this.normalizeComparisonValue(value);
+				continue;
+			}
+			if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+				if (Object.keys(value).length === 0) {
+					result[newPath] = this.translateNode(value);
+					continue;
+				}
+				if (Object.keys(value).some((k) => this.isOperator(k))) result[newPath] = this.translateNode(value);
+				else Object.assign(result, this.translateNode(value, newPath));
+			} else result[newPath] = this.translateNode(value);
+		}
+		return result;
+	}
 };
-
-// src/vector/prompt.ts
-var VECTORIZE_PROMPT = `When querying Vectorize, you can ONLY use the operators listed below. Any other operators will be rejected.
+//#endregion
+//#region src/vector/index.ts
+var CloudflareVector = class extends _mastra_core_vector.MastraVector {
+	client;
+	accountId;
+	constructor({ accountId, apiToken, id }) {
+		super({ id });
+		this.accountId = accountId;
+		this.client = new cloudflare.default({ apiToken });
+	}
+	get indexSeparator() {
+		return "-";
+	}
+	async upsert({ indexName, vectors, metadata, ids }) {
+		const generatedIds = ids || vectors.map(() => crypto.randomUUID());
+		const ndjson = vectors.map((vector, index) => JSON.stringify({
+			id: generatedIds[index],
+			values: vector,
+			metadata: metadata?.[index]
+		})).join("\n");
+		try {
+			const body = new File([ndjson], `${indexName}.ndjson`, { type: "application/x-ndjson" });
+			await this.client.vectorize.indexes.upsert(indexName, {
+				account_id: this.accountId,
+				body
+			});
+			return generatedIds;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("VECTORIZE", "UPSERT", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					vectorCount: vectors?.length
+				}
+			}, error);
+		}
+	}
+	transformFilter(filter) {
+		return new VectorizeFilterTranslator().translate(filter);
+	}
+	async createIndex({ indexName, dimension, metric = "cosine" }) {
+		try {
+			await this.client.vectorize.indexes.create({
+				account_id: this.accountId,
+				config: {
+					dimensions: dimension,
+					metric: metric === "dotproduct" ? "dot-product" : metric
+				},
+				name: indexName
+			});
+		} catch (error) {
+			const message = error?.errors?.[0]?.message || error?.message;
+			if (error.status === 409 || typeof message === "string" && (message.toLowerCase().includes("already exists") || message.toLowerCase().includes("duplicate"))) {
+				await this.validateExistingIndex(indexName, dimension, metric);
+				return;
+			}
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("VECTORIZE", "CREATE_INDEX", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					dimension,
+					metric
+				}
+			}, error);
+		}
+	}
+	async query({ indexName, queryVector, topK = 10, filter, includeVector = false }) {
+		if (!queryVector) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("VECTORIZE", "QUERY", "MISSING_VECTOR"),
+			text: "queryVector is required for Vectorize 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 }
+		});
+		try {
+			const translatedFilter = this.transformFilter(filter) ?? {};
+			return (await this.client.vectorize.indexes.query(indexName, {
+				account_id: this.accountId,
+				vector: queryVector,
+				returnValues: includeVector,
+				returnMetadata: "all",
+				topK,
+				filter: translatedFilter
+			}))?.matches?.map((match) => {
+				return {
+					id: match.id,
+					metadata: match.metadata,
+					score: match.score,
+					vector: match.values
+				};
+			}) || [];
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("VECTORIZE", "QUERY", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					topK
+				}
+			}, error);
+		}
+	}
+	async listIndexes() {
+		try {
+			return (await this.client.vectorize.indexes.list({ account_id: this.accountId }))?.result?.map((index) => index.name) || [];
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("VECTORIZE", "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 index = await this.client.vectorize.indexes.get(indexName, { account_id: this.accountId });
+			const described = await this.client.vectorize.indexes.info(indexName, { account_id: this.accountId });
+			return {
+				dimension: described?.dimensions,
+				count: described?.vectorCount || 0,
+				metric: index?.config?.metric
+			};
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("VECTORIZE", "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.vectorize.indexes.delete(indexName, { account_id: this.accountId });
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("VECTORIZE", "DELETE_INDEX", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { indexName }
+			}, error);
+		}
+	}
+	async createMetadataIndex(indexName, propertyName, indexType) {
+		try {
+			await this.client.vectorize.indexes.metadataIndex.create(indexName, {
+				account_id: this.accountId,
+				propertyName,
+				indexType
+			});
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("VECTORIZE", "CREATE_METADATA_INDEX", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					propertyName,
+					indexType
+				}
+			}, error);
+		}
+	}
+	async deleteMetadataIndex(indexName, propertyName) {
+		try {
+			await this.client.vectorize.indexes.metadataIndex.delete(indexName, {
+				account_id: this.accountId,
+				propertyName
+			});
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("VECTORIZE", "DELETE_METADATA_INDEX", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					propertyName
+				}
+			}, error);
+		}
+	}
+	async listMetadataIndexes(indexName) {
+		try {
+			return (await this.client.vectorize.indexes.metadataIndex.list(indexName, { account_id: this.accountId }))?.metadataIndexes ?? [];
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("VECTORIZE", "LIST_METADATA_INDEXES", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				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)("VECTORIZE", "UPDATE_VECTOR", "INVALID_ARGS"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			text: "id is required for Vectorize updateVector",
+			details: { indexName }
+		});
+		if (!update.vector && !update.metadata) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("VECTORIZE", "UPDATE_VECTOR", "NO_PAYLOAD"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			text: "No update data provided",
+			details: {
+				indexName,
+				id
+			}
+		});
+		if (!update.vector) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("VECTORIZE", "UPDATE_VECTOR", "MISSING_VECTOR"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			text: "Vectorize requires vector values when updating; metadata-only updates are not supported. Provide update.vector alongside update.metadata.",
+			details: {
+				indexName,
+				id
+			}
+		});
+		try {
+			await this.upsert({
+				indexName,
+				ids: [id],
+				vectors: [update.vector],
+				...update.metadata && { metadata: [update.metadata] }
+			});
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("VECTORIZE", "UPDATE_VECTOR", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				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.client.vectorize.indexes.deleteByIds(indexName, {
+				ids: [id],
+				account_id: this.accountId
+			});
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("VECTORIZE", "DELETE_VECTOR", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					...id && { id }
+				}
+			}, error);
+		}
+	}
+	/**
+	* Deletes multiple vectors by their IDs.
+	*
+	* Vectorize has no filtered-delete primitive, so metadata-filter deletion is rejected.
+	*
+	* @param indexName - The name of the index containing the vectors.
+	* @param ids - The IDs of the vectors to delete. Mutually exclusive with `filter`.
+	* @throws Will throw an error if the arguments are invalid or the deletion operation fails.
+	*/
+	async deleteVectors({ indexName, filter, ids }) {
+		if (ids && filter) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("VECTORIZE", "DELETE_VECTORS", "MUTUALLY_EXCLUSIVE"),
+			text: "Cannot specify both ids and filter - they are mutually exclusive",
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			details: { indexName }
+		});
+		if (filter) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("VECTORIZE", "DELETE_VECTORS", "UNSUPPORTED_FILTER"),
+			text: "Deleting by metadata filter is not supported for Vectorize vector store - delete by ids instead",
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.SYSTEM,
+			details: {
+				indexName,
+				filter: JSON.stringify(filter)
+			}
+		});
+		if (!ids) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("VECTORIZE", "DELETE_VECTORS", "NO_TARGET"),
+			text: "Either filter or ids must be provided",
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			details: { indexName }
+		});
+		if (ids.length === 0) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("VECTORIZE", "DELETE_VECTORS", "EMPTY_IDS"),
+			text: "Cannot delete with empty ids array",
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			details: { indexName }
+		});
+		try {
+			await this.client.vectorize.indexes.deleteByIds(indexName, {
+				ids,
+				account_id: this.accountId
+			});
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("VECTORIZE", "DELETE_VECTORS", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					idsCount: ids.length
+				}
+			}, error);
+		}
+	}
+};
+//#endregion
+//#region src/vector/prompt.ts
+/**
+* Vector store specific prompt that details supported operators and examples.
+* This prompt helps users construct valid filters for Vectorize.
+*/
+const VECTORIZE_PROMPT = `When querying Vectorize, 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.
 
@@ -480,8 +500,8 @@ Example Complex Query:
     ]}
   ]
 }`;
-
+//#endregion
 exports.CloudflareVector = CloudflareVector;
 exports.VECTORIZE_PROMPT = VECTORIZE_PROMPT;
-//# sourceMappingURL=index.cjs.map
+
 //# sourceMappingURL=index.cjs.map