@mastra/elasticsearch 1.3.0 → 1.3.1

package/dist/index.cjs

@@ -1,1078 +1,846 @@
-'use strict';
-
-var elasticsearch = require('@elastic/elasticsearch');
-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
-
-// package.json
-var package_default = {
-  version: "1.3.0"};
-var ElasticSearchFilterTranslator = class extends filter.BaseFilterTranslator {
-  getSupportedOperators() {
-    return {
-      ...filter.BaseFilterTranslator.DEFAULT_OPERATORS,
-      logical: ["$and", "$or", "$not", "$nor"],
-      array: ["$in", "$nin", "$all"],
-      regex: ["$regex"],
-      custom: []
-    };
-  }
-  translate(filter) {
-    if (this.isEmpty(filter)) return void 0;
-    this.validateFilter(filter);
-    return this.translateNode(filter);
-  }
-  translateNode(node) {
-    if (this.isPrimitive(node) || Array.isArray(node)) {
-      return node;
-    }
-    const entries = Object.entries(node);
-    const logicalOperators = [];
-    const fieldConditions = [];
-    entries.forEach(([key, value]) => {
-      if (this.isLogicalOperator(key)) {
-        logicalOperators.push([key, value]);
-      } else {
-        fieldConditions.push([key, value]);
-      }
-    });
-    if (logicalOperators.length === 1 && fieldConditions.length === 0) {
-      const [operator, value] = logicalOperators[0];
-      if (!Array.isArray(value) && typeof value !== "object") {
-        throw new Error(`Invalid logical operator structure: ${operator} must have an array or object value`);
-      }
-      return this.translateLogicalOperator(operator, value);
-    }
-    const fieldConditionQueries = fieldConditions.map(([key, value]) => {
-      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-        const hasOperators = Object.keys(value).some((k) => this.isOperator(k));
-        const nestedField = `metadata.${key}`;
-        return hasOperators ? this.translateFieldConditions(nestedField, value) : this.translateNestedObject(nestedField, value);
-      }
-      if (Array.isArray(value)) {
-        const fieldWithKeyword2 = this.addKeywordIfNeeded(`metadata.${key}`, value);
-        return { terms: { [fieldWithKeyword2]: value } };
-      }
-      const fieldWithKeyword = this.addKeywordIfNeeded(`metadata.${key}`, value);
-      return { term: { [fieldWithKeyword]: value } };
-    });
-    if (logicalOperators.length > 0) {
-      const logicalConditions = logicalOperators.map(
-        ([operator, value]) => this.translateOperator(operator, value)
-      );
-      return {
-        bool: {
-          must: [...logicalConditions, ...fieldConditionQueries]
-        }
-      };
-    }
-    if (fieldConditionQueries.length > 1) {
-      return {
-        bool: {
-          must: fieldConditionQueries
-        }
-      };
-    }
-    if (fieldConditionQueries.length === 1) {
-      return fieldConditionQueries[0];
-    }
-    return { match_all: {} };
-  }
-  /**
-   * Handles translation of nested objects with dot notation fields
-   */
-  translateNestedObject(field, value) {
-    const conditions = Object.entries(value).map(([subField, subValue]) => {
-      const fullField = `${field}.${subField}`;
-      if (this.isOperator(subField)) {
-        return this.translateOperator(subField, subValue, field);
-      }
-      if (typeof subValue === "object" && subValue !== null && !Array.isArray(subValue)) {
-        const hasOperators = Object.keys(subValue).some((k) => this.isOperator(k));
-        if (hasOperators) {
-          return this.translateFieldConditions(fullField, subValue);
-        }
-        return this.translateNestedObject(fullField, subValue);
-      }
-      const fieldWithKeyword = this.addKeywordIfNeeded(fullField, subValue);
-      return { term: { [fieldWithKeyword]: subValue } };
-    });
-    return {
-      bool: {
-        must: conditions
-      }
-    };
-  }
-  translateLogicalOperator(operator, value) {
-    const conditions = Array.isArray(value) ? value.map((item) => this.translateNode(item)) : [this.translateNode(value)];
-    switch (operator) {
-      case "$and":
-        if (Array.isArray(value) && value.length === 0) {
-          return { match_all: {} };
-        }
-        return {
-          bool: {
-            must: conditions
-          }
-        };
-      case "$or":
-        if (Array.isArray(value) && value.length === 0) {
-          return {
-            bool: {
-              must_not: [{ match_all: {} }]
-            }
-          };
-        }
-        return {
-          bool: {
-            should: conditions,
-            minimum_should_match: 1
-          }
-        };
-      case "$not":
-      case "$nor":
-        return {
-          bool: {
-            must_not: conditions
-          }
-        };
-      default:
-        return value;
-    }
-  }
-  translateFieldOperator(field, operator, value) {
-    if (this.isBasicOperator(operator)) {
-      const normalizedValue = this.normalizeComparisonValue(value);
-      const fieldWithKeyword2 = this.addKeywordIfNeeded(field, value);
-      switch (operator) {
-        case "$eq":
-          if (value === null) {
-            return {
-              bool: {
-                must_not: [{ exists: { field } }]
-              }
-            };
-          }
-          return { term: { [fieldWithKeyword2]: normalizedValue } };
-        case "$ne":
-          if (value === null) {
-            return { exists: { field } };
-          }
-          return {
-            bool: {
-              must_not: [{ term: { [fieldWithKeyword2]: normalizedValue } }]
-            }
-          };
-        default:
-          return { term: { [fieldWithKeyword2]: normalizedValue } };
-      }
-    }
-    if (this.isNumericOperator(operator)) {
-      const normalizedValue = this.normalizeComparisonValue(value);
-      const rangeOp = operator.replace("$", "");
-      return { range: { [field]: { [rangeOp]: normalizedValue } } };
-    }
-    if (this.isArrayOperator(operator)) {
-      if (!Array.isArray(value)) {
-        throw new Error(`Invalid array operator value: ${operator} requires an array value`);
-      }
-      const normalizedValues = this.normalizeArrayValues(value);
-      const fieldWithKeyword2 = this.addKeywordIfNeeded(field, value);
-      switch (operator) {
-        case "$in":
-          return { terms: { [fieldWithKeyword2]: normalizedValues } };
-        case "$nin":
-          if (normalizedValues.length === 0) {
-            return { match_all: {} };
-          }
-          return {
-            bool: {
-              must_not: [{ terms: { [fieldWithKeyword2]: normalizedValues } }]
-            }
-          };
-        case "$all":
-          if (normalizedValues.length === 0) {
-            return {
-              bool: {
-                must_not: [{ match_all: {} }]
-              }
-            };
-          }
-          return {
-            bool: {
-              must: normalizedValues.map((v) => ({ term: { [fieldWithKeyword2]: v } }))
-            }
-          };
-        default:
-          return { terms: { [fieldWithKeyword2]: normalizedValues } };
-      }
-    }
-    if (this.isElementOperator(operator)) {
-      switch (operator) {
-        case "$exists":
-          return value ? { exists: { field } } : { bool: { must_not: [{ exists: { field } }] } };
-        default:
-          return { exists: { field } };
-      }
-    }
-    if (this.isRegexOperator(operator)) {
-      return this.translateRegexOperator(field, value);
-    }
-    const fieldWithKeyword = this.addKeywordIfNeeded(field, value);
-    return { term: { [fieldWithKeyword]: value } };
-  }
-  /**
-   * Escapes wildcard metacharacters (* and ?) for use in wildcard queries.
-   * Existing wildcard metacharacters in the pattern are escaped before
-   * adding leading/trailing * to prevent semantic changes.
-   * First escapes backslashes to avoid ambiguous encoding sequences.
-   */
-  escapeWildcardMetacharacters(pattern) {
-    return pattern.replace(/\\/g, "\\\\").replace(/\*/g, "\\*").replace(/\?/g, "\\?");
-  }
-  /**
-   * Translates regex patterns to ElasticSearch query syntax
-   */
-  translateRegexOperator(field, value) {
-    const regexValue = typeof value === "string" ? value : value.toString();
-    let processedRegex = regexValue;
-    const hasStartAnchor = regexValue.startsWith("^");
-    const hasEndAnchor = regexValue.endsWith("$");
-    if (hasStartAnchor || hasEndAnchor) {
-      if (hasStartAnchor) {
-        processedRegex = processedRegex.substring(1);
-      }
-      if (hasEndAnchor) {
-        processedRegex = processedRegex.substring(0, processedRegex.length - 1);
-      }
-      const escapedPattern = this.escapeWildcardMetacharacters(processedRegex);
-      let wildcardPattern = escapedPattern;
-      if (!hasStartAnchor) {
-        wildcardPattern = "*" + wildcardPattern;
-      }
-      if (!hasEndAnchor) {
-        wildcardPattern = wildcardPattern + "*";
-      }
-      return { wildcard: { [field]: { value: wildcardPattern } } };
-    }
-    return { regexp: { [field]: { value: regexValue } } };
-  }
-  addKeywordIfNeeded(field, value) {
-    if (typeof value === "string") {
-      return `${field}.keyword`;
-    }
-    if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
-      return `${field}.keyword`;
-    }
-    return field;
-  }
-  /**
-   * Helper method to handle special cases for the $not operator
-   */
-  handleNotOperatorSpecialCases(value, field) {
-    if (value === null) {
-      return { exists: { field } };
-    }
-    if (typeof value === "object" && value !== null) {
-      if ("$eq" in value && value.$eq === null) {
-        return { exists: { field } };
-      }
-      if ("$ne" in value && value.$ne === null) {
-        return {
-          bool: {
-            must_not: [{ exists: { field } }]
-          }
-        };
-      }
-    }
-    return null;
-  }
-  translateOperator(operator, value, field) {
-    if (!this.isOperator(operator)) {
-      throw new Error(`Unsupported operator: ${operator}`);
-    }
-    if (operator === "$not" && field) {
-      const specialCaseResult = this.handleNotOperatorSpecialCases(value, field);
-      if (specialCaseResult) {
-        return specialCaseResult;
-      }
-    }
-    if (this.isLogicalOperator(operator)) {
-      if (operator === "$not" && field && typeof value === "object" && value !== null && !Array.isArray(value)) {
-        const entries = Object.entries(value);
-        if (entries.length > 0) {
-          if (entries.every(([op]) => this.isOperator(op))) {
-            const translatedCondition = this.translateFieldConditions(field, value);
-            return {
-              bool: {
-                must_not: [translatedCondition]
-              }
-            };
-          }
-          if (entries.length === 1 && entries[0] && this.isOperator(entries[0][0])) {
-            const [nestedOp, nestedVal] = entries[0];
-            const translatedNested = this.translateFieldOperator(field, nestedOp, nestedVal);
-            return {
-              bool: {
-                must_not: [translatedNested]
-              }
-            };
-          }
-        }
-      }
-      return this.translateLogicalOperator(operator, value);
-    }
-    if (field) {
-      return this.translateFieldOperator(field, operator, value);
-    }
-    return value;
-  }
-  /**
-   * Translates field conditions to ElasticSearch query syntax
-   * Handles special cases like range queries and multiple operators
-   */
-  translateFieldConditions(field, conditions) {
-    if (this.canOptimizeToRangeQuery(conditions)) {
-      return this.createRangeQuery(field, conditions);
-    }
-    const queryConditions = [];
-    Object.entries(conditions).forEach(([operator, value]) => {
-      if (this.isOperator(operator)) {
-        queryConditions.push(this.translateOperator(operator, value, field));
-      } else {
-        const fieldWithKeyword = this.addKeywordIfNeeded(`${field}.${operator}`, value);
-        queryConditions.push({ term: { [fieldWithKeyword]: value } });
-      }
-    });
-    if (queryConditions.length === 1) {
-      return queryConditions[0];
-    }
-    return {
-      bool: {
-        must: queryConditions
-      }
-    };
-  }
-  /**
-   * Checks if conditions can be optimized to a range query
-   */
-  canOptimizeToRangeQuery(conditions) {
-    return Object.keys(conditions).every((op) => this.isNumericOperator(op)) && Object.keys(conditions).length > 0;
-  }
-  /**
-   * Creates a range query from numeric operators
-   */
-  createRangeQuery(field, conditions) {
-    const rangeParams = Object.fromEntries(
-      Object.entries(conditions).map(([op, val]) => [op.replace("$", ""), this.normalizeComparisonValue(val)])
-    );
-    return { range: { [field]: rangeParams } };
-  }
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _elastic_elasticsearch = require("@elastic/elasticsearch");
+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 package.json
+var version = "1.3.1";
+//#endregion
+//#region src/vector/filter.ts
+/**
+* Translator for ElasticSearch filter queries.
+* Maintains ElasticSearch-compatible syntax while ensuring proper validation
+* and normalization of values.
+*/
+var ElasticSearchFilterTranslator = class extends _mastra_core_vector_filter.BaseFilterTranslator {
+	getSupportedOperators() {
+		return {
+			..._mastra_core_vector_filter.BaseFilterTranslator.DEFAULT_OPERATORS,
+			logical: [
+				"$and",
+				"$or",
+				"$not",
+				"$nor"
+			],
+			array: [
+				"$in",
+				"$nin",
+				"$all"
+			],
+			regex: ["$regex"],
+			custom: []
+		};
+	}
+	translate(filter) {
+		if (this.isEmpty(filter)) return void 0;
+		this.validateFilter(filter);
+		return this.translateNode(filter);
+	}
+	translateNode(node) {
+		if (this.isPrimitive(node) || Array.isArray(node)) return node;
+		const entries = Object.entries(node);
+		const logicalOperators = [];
+		const fieldConditions = [];
+		entries.forEach(([key, value]) => {
+			if (this.isLogicalOperator(key)) logicalOperators.push([key, value]);
+			else fieldConditions.push([key, value]);
+		});
+		if (logicalOperators.length === 1 && fieldConditions.length === 0) {
+			const [operator, value] = logicalOperators[0];
+			if (!Array.isArray(value) && typeof value !== "object") throw new Error(`Invalid logical operator structure: ${operator} must have an array or object value`);
+			return this.translateLogicalOperator(operator, value);
+		}
+		const fieldConditionQueries = fieldConditions.map(([key, value]) => {
+			if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+				const hasOperators = Object.keys(value).some((k) => this.isOperator(k));
+				const nestedField = `metadata.${key}`;
+				return hasOperators ? this.translateFieldConditions(nestedField, value) : this.translateNestedObject(nestedField, value);
+			}
+			if (Array.isArray(value)) return { terms: { [this.addKeywordIfNeeded(`metadata.${key}`, value)]: value } };
+			return { term: { [this.addKeywordIfNeeded(`metadata.${key}`, value)]: value } };
+		});
+		if (logicalOperators.length > 0) return { bool: { must: [...logicalOperators.map(([operator, value]) => this.translateOperator(operator, value)), ...fieldConditionQueries] } };
+		if (fieldConditionQueries.length > 1) return { bool: { must: fieldConditionQueries } };
+		if (fieldConditionQueries.length === 1) return fieldConditionQueries[0];
+		return { match_all: {} };
+	}
+	/**
+	* Handles translation of nested objects with dot notation fields
+	*/
+	translateNestedObject(field, value) {
+		return { bool: { must: Object.entries(value).map(([subField, subValue]) => {
+			const fullField = `${field}.${subField}`;
+			if (this.isOperator(subField)) return this.translateOperator(subField, subValue, field);
+			if (typeof subValue === "object" && subValue !== null && !Array.isArray(subValue)) {
+				if (Object.keys(subValue).some((k) => this.isOperator(k))) return this.translateFieldConditions(fullField, subValue);
+				return this.translateNestedObject(fullField, subValue);
+			}
+			return { term: { [this.addKeywordIfNeeded(fullField, subValue)]: subValue } };
+		}) } };
+	}
+	translateLogicalOperator(operator, value) {
+		const conditions = Array.isArray(value) ? value.map((item) => this.translateNode(item)) : [this.translateNode(value)];
+		switch (operator) {
+			case "$and":
+				if (Array.isArray(value) && value.length === 0) return { match_all: {} };
+				return { bool: { must: conditions } };
+			case "$or":
+				if (Array.isArray(value) && value.length === 0) return { bool: { must_not: [{ match_all: {} }] } };
+				return { bool: {
+					should: conditions,
+					minimum_should_match: 1
+				} };
+			case "$not":
+			case "$nor": return { bool: { must_not: conditions } };
+			default: return value;
+		}
+	}
+	translateFieldOperator(field, operator, value) {
+		if (this.isBasicOperator(operator)) {
+			const normalizedValue = this.normalizeComparisonValue(value);
+			const fieldWithKeyword = this.addKeywordIfNeeded(field, value);
+			switch (operator) {
+				case "$eq":
+					if (value === null) return { bool: { must_not: [{ exists: { field } }] } };
+					return { term: { [fieldWithKeyword]: normalizedValue } };
+				case "$ne":
+					if (value === null) return { exists: { field } };
+					return { bool: { must_not: [{ term: { [fieldWithKeyword]: normalizedValue } }] } };
+				default: return { term: { [fieldWithKeyword]: normalizedValue } };
+			}
+		}
+		if (this.isNumericOperator(operator)) {
+			const normalizedValue = this.normalizeComparisonValue(value);
+			const rangeOp = operator.replace("$", "");
+			return { range: { [field]: { [rangeOp]: normalizedValue } } };
+		}
+		if (this.isArrayOperator(operator)) {
+			if (!Array.isArray(value)) throw new Error(`Invalid array operator value: ${operator} requires an array value`);
+			const normalizedValues = this.normalizeArrayValues(value);
+			const fieldWithKeyword = this.addKeywordIfNeeded(field, value);
+			switch (operator) {
+				case "$in": return { terms: { [fieldWithKeyword]: normalizedValues } };
+				case "$nin":
+					if (normalizedValues.length === 0) return { match_all: {} };
+					return { bool: { must_not: [{ terms: { [fieldWithKeyword]: normalizedValues } }] } };
+				case "$all":
+					if (normalizedValues.length === 0) return { bool: { must_not: [{ match_all: {} }] } };
+					return { bool: { must: normalizedValues.map((v) => ({ term: { [fieldWithKeyword]: v } })) } };
+				default: return { terms: { [fieldWithKeyword]: normalizedValues } };
+			}
+		}
+		if (this.isElementOperator(operator)) switch (operator) {
+			case "$exists": return value ? { exists: { field } } : { bool: { must_not: [{ exists: { field } }] } };
+			default: return { exists: { field } };
+		}
+		if (this.isRegexOperator(operator)) return this.translateRegexOperator(field, value);
+		return { term: { [this.addKeywordIfNeeded(field, value)]: value } };
+	}
+	/**
+	* Escapes wildcard metacharacters (* and ?) for use in wildcard queries.
+	* Existing wildcard metacharacters in the pattern are escaped before
+	* adding leading/trailing * to prevent semantic changes.
+	* First escapes backslashes to avoid ambiguous encoding sequences.
+	*/
+	escapeWildcardMetacharacters(pattern) {
+		return pattern.replace(/\\/g, "\\\\").replace(/\*/g, "\\*").replace(/\?/g, "\\?");
+	}
+	/**
+	* Translates regex patterns to ElasticSearch query syntax
+	*/
+	translateRegexOperator(field, value) {
+		const regexValue = typeof value === "string" ? value : value.toString();
+		let processedRegex = regexValue;
+		const hasStartAnchor = regexValue.startsWith("^");
+		const hasEndAnchor = regexValue.endsWith("$");
+		if (hasStartAnchor || hasEndAnchor) {
+			if (hasStartAnchor) processedRegex = processedRegex.substring(1);
+			if (hasEndAnchor) processedRegex = processedRegex.substring(0, processedRegex.length - 1);
+			let wildcardPattern = this.escapeWildcardMetacharacters(processedRegex);
+			if (!hasStartAnchor) wildcardPattern = "*" + wildcardPattern;
+			if (!hasEndAnchor) wildcardPattern = wildcardPattern + "*";
+			return { wildcard: { [field]: { value: wildcardPattern } } };
+		}
+		return { regexp: { [field]: { value: regexValue } } };
+	}
+	addKeywordIfNeeded(field, value) {
+		if (typeof value === "string") return `${field}.keyword`;
+		if (Array.isArray(value) && value.every((item) => typeof item === "string")) return `${field}.keyword`;
+		return field;
+	}
+	/**
+	* Helper method to handle special cases for the $not operator
+	*/
+	handleNotOperatorSpecialCases(value, field) {
+		if (value === null) return { exists: { field } };
+		if (typeof value === "object" && value !== null) {
+			if ("$eq" in value && value.$eq === null) return { exists: { field } };
+			if ("$ne" in value && value.$ne === null) return { bool: { must_not: [{ exists: { field } }] } };
+		}
+		return null;
+	}
+	translateOperator(operator, value, field) {
+		if (!this.isOperator(operator)) throw new Error(`Unsupported operator: ${operator}`);
+		if (operator === "$not" && field) {
+			const specialCaseResult = this.handleNotOperatorSpecialCases(value, field);
+			if (specialCaseResult) return specialCaseResult;
+		}
+		if (this.isLogicalOperator(operator)) {
+			if (operator === "$not" && field && typeof value === "object" && value !== null && !Array.isArray(value)) {
+				const entries = Object.entries(value);
+				if (entries.length > 0) {
+					if (entries.every(([op]) => this.isOperator(op))) return { bool: { must_not: [this.translateFieldConditions(field, value)] } };
+					if (entries.length === 1 && entries[0] && this.isOperator(entries[0][0])) {
+						const [nestedOp, nestedVal] = entries[0];
+						return { bool: { must_not: [this.translateFieldOperator(field, nestedOp, nestedVal)] } };
+					}
+				}
+			}
+			return this.translateLogicalOperator(operator, value);
+		}
+		if (field) return this.translateFieldOperator(field, operator, value);
+		return value;
+	}
+	/**
+	* Translates field conditions to ElasticSearch query syntax
+	* Handles special cases like range queries and multiple operators
+	*/
+	translateFieldConditions(field, conditions) {
+		if (this.canOptimizeToRangeQuery(conditions)) return this.createRangeQuery(field, conditions);
+		const queryConditions = [];
+		Object.entries(conditions).forEach(([operator, value]) => {
+			if (this.isOperator(operator)) queryConditions.push(this.translateOperator(operator, value, field));
+			else {
+				const fieldWithKeyword = this.addKeywordIfNeeded(`${field}.${operator}`, value);
+				queryConditions.push({ term: { [fieldWithKeyword]: value } });
+			}
+		});
+		if (queryConditions.length === 1) return queryConditions[0];
+		return { bool: { must: queryConditions } };
+	}
+	/**
+	* Checks if conditions can be optimized to a range query
+	*/
+	canOptimizeToRangeQuery(conditions) {
+		return Object.keys(conditions).every((op) => this.isNumericOperator(op)) && Object.keys(conditions).length > 0;
+	}
+	/**
+	* Creates a range query from numeric operators
+	*/
+	createRangeQuery(field, conditions) {
+		const rangeParams = Object.fromEntries(Object.entries(conditions).map(([op, val]) => [op.replace("$", ""), this.normalizeComparisonValue(val)]));
+		return { range: { [field]: rangeParams } };
+	}
 };
-
-// src/vector/index.ts
-var METRIC_MAPPING = {
-  cosine: "cosine",
-  euclidean: "l2_norm",
-  dotproduct: "dot_product"
+//#endregion
+//#region src/vector/index.ts
+const METRIC_MAPPING = {
+	cosine: "cosine",
+	euclidean: "l2_norm",
+	dotproduct: "dot_product"
 };
-var REVERSE_METRIC_MAPPING = {
-  cosine: "cosine",
-  l2_norm: "euclidean",
-  dot_product: "dotproduct"
+const REVERSE_METRIC_MAPPING = {
+	cosine: "cosine",
+	l2_norm: "euclidean",
+	dot_product: "dotproduct"
 };
-var ElasticSearchVector = class extends vector.MastraVector {
-  client;
-  /**
-   * Creates a new ElasticSearchVector client.
-   *
-   * Accepts either a pre-configured ElasticSearch client or connection parameters:
-   * - `{ id, client }` - Use an existing ElasticSearch client
-   * - `{ id, url, auth? }` - Create a new client from connection parameters
-   */
-  constructor(config) {
-    super({ id: config.id });
-    if ("client" in config && config.client) {
-      this.client = config.client;
-    } else if ("url" in config && config.url) {
-      this.client = new elasticsearch.Client({
-        node: config.url,
-        ...config.auth && { auth: config.auth },
-        name: "mastra-elasticsearch",
-        headers: { "user-agent": `mastra-es/${package_default.version}` }
-      });
-    } else {
-      throw new error.MastraError({
-        id: "ELASTIC_SEARCH_CONSTRUCTOR_ERROR",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.SYSTEM,
-        text: "Invalid config: provide either { client } or { url }."
-      });
-    }
-  }
-  /**
-   * 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("ELASTICSEARCH", "CREATE_INDEX", "INVALID_ARGS"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "Dimension must be a positive integer",
-        details: { indexName, dimension }
-      });
-    }
-    try {
-      await this.client.indices.create({
-        index: indexName,
-        mappings: {
-          properties: {
-            metadata: { type: "object" },
-            embedding: {
-              type: "dense_vector",
-              dims: dimension,
-              index: true,
-              similarity: METRIC_MAPPING[metric]
-            }
-          }
-        }
-      });
-    } catch (error$1) {
-      const message = error$1?.message || error$1?.toString();
-      if (message && message.toLowerCase().includes("already exists")) {
-        await this.validateExistingIndex(indexName, dimension, metric);
-        return;
-      }
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("ELASTICSEARCH", "CREATE_INDEX", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName, dimension, metric }
-        },
-        error$1
-      );
-    }
-  }
-  /**
-   * Lists all indexes.
-   *
-   * @returns {Promise<string[]>} A promise that resolves to an array of indexes.
-   */
-  async listIndexes() {
-    try {
-      const response = await this.client.cat.indices({ format: "json" });
-      const indexes = response.map((record) => record.index).filter((index) => index !== void 0 && !index.startsWith("."));
-      return indexes;
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("ELASTICSEARCH", "LIST_INDEXES", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
-        },
-        error$1
-      );
-    }
-  }
-  /**
-   * Validates that an existing index matches the requested dimension and metric.
-   * Throws an error if there's a mismatch, otherwise allows idempotent creation.
-   */
-  async validateExistingIndex(indexName, dimension, metric) {
-    let info;
-    try {
-      info = await this.describeIndex({ indexName });
-    } catch (infoError) {
-      const mastraError = new error.MastraError(
-        {
-          id: storage.createVectorErrorId("ELASTICSEARCH", "VALIDATE_INDEX", "FETCH_FAILED"),
-          text: `Index "${indexName}" already exists, but failed to fetch index info for dimension check.`,
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.SYSTEM,
-          details: { indexName }
-        },
-        infoError
-      );
-      this.logger?.trackException(mastraError);
-      this.logger?.error(mastraError.toString());
-      throw mastraError;
-    }
-    const existingDim = info?.dimension;
-    const existingMetric = info?.metric;
-    if (existingDim === dimension) {
-      this.logger?.info(
-        `Index "${indexName}" already exists with ${existingDim} dimensions and metric ${existingMetric}, skipping creation.`
-      );
-      if (existingMetric !== metric) {
-        this.logger?.warn(
-          `Attempted to create index with metric "${metric}", but index already exists with metric "${existingMetric}". To use a different metric, delete and recreate the index.`
-        );
-      }
-    } else if (info) {
-      const mastraError = new error.MastraError({
-        id: storage.createVectorErrorId("ELASTICSEARCH", "VALIDATE_INDEX", "DIMENSION_MISMATCH"),
-        text: `Index "${indexName}" already exists with ${existingDim} dimensions, but ${dimension} dimensions were requested`,
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        details: { indexName, existingDim, requestedDim: dimension }
-      });
-      this.logger?.trackException(mastraError);
-      this.logger?.error(mastraError.toString());
-      throw mastraError;
-    }
-  }
-  /**
-   * 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 indexInfo = await this.client.indices.get({ index: indexName });
-    const mappings = indexInfo[indexName]?.mappings;
-    const embedding = mappings?.properties?.embedding;
-    const similarity = embedding.similarity;
-    const countInfo = await this.client.count({ index: indexName });
-    return {
-      dimension: Number(embedding.dims),
-      count: Number(countInfo.count),
-      metric: REVERSE_METRIC_MAPPING[similarity]
-    };
-  }
-  /**
-   * Deletes the specified index.
-   *
-   * @param {string} indexName - The name of the index to delete.
-   * @returns {Promise<void>} A promise that resolves when the index is deleted.
-   */
-  async deleteIndex({ indexName }) {
-    try {
-      await this.client.indices.delete({ index: indexName }, { ignore: [404] });
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          id: storage.createVectorErrorId("ELASTICSEARCH", "DELETE_INDEX", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName }
-        },
-        error$1
-      );
-      this.logger?.error(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      throw mastraError;
-    }
-  }
-  /**
-   * 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 }) {
-    vector.validateUpsert("ELASTICSEARCH", vectors, metadata, ids, true);
-    const vectorIds = ids || vectors.map(() => crypto.randomUUID());
-    const operations = [];
-    try {
-      const indexInfo = await this.describeIndex({ indexName });
-      this.validateVectorDimensions(vectors, indexInfo.dimension);
-      for (let i = 0; i < vectors.length; i++) {
-        const operation = {
-          index: {
-            _index: indexName,
-            _id: vectorIds[i]
-          }
-        };
-        const document = {
-          embedding: vectors[i],
-          metadata: metadata[i] || {}
-        };
-        operations.push(operation);
-        operations.push(document);
-      }
-      if (operations.length > 0) {
-        const response = await this.client.bulk({ operations, refresh: true });
-        if (response.errors) {
-          const failedItems = [];
-          const successfulIds = [];
-          for (let i = 0; i < response.items.length; i++) {
-            const item = response.items[i];
-            if (!item) continue;
-            const operationType = Object.keys(item)[0];
-            const operationResult = item[operationType];
-            if (!operationResult) continue;
-            if (operationResult.error) {
-              const operationIndex = i * 2;
-              const operationDoc = operations[operationIndex];
-              const failedId = operationDoc?.index?._id || vectorIds[i] || `unknown-${i}`;
-              failedItems.push({
-                id: failedId,
-                status: operationResult.status || 0,
-                error: operationResult.error
-              });
-            } else if (operationResult?.status && operationResult.status < 300) {
-              const operationIndex = i * 2;
-              const operationDoc = operations[operationIndex];
-              const successId = operationDoc?.index?._id || vectorIds[i];
-              if (successId) {
-                successfulIds.push(successId);
-              }
-            }
-          }
-          if (failedItems.length > 0) {
-            const failedItemDetails = failedItems.map((item) => `${item.id}: ${item.error?.reason || item.error?.type || JSON.stringify(item.error)}`).join("; ");
-            const mastraError = new error.MastraError(
-              {
-                id: storage.createVectorErrorId("ELASTICSEARCH", "UPSERT", "BULK_PARTIAL_FAILURE"),
-                text: `Bulk upsert partially failed: ${failedItems.length} of ${response.items.length} operations failed. Failed items: ${failedItemDetails}`,
-                domain: error.ErrorDomain.STORAGE,
-                category: error.ErrorCategory.THIRD_PARTY,
-                details: {
-                  indexName,
-                  totalOperations: response.items.length,
-                  failedCount: failedItems.length,
-                  successfulCount: successfulIds.length,
-                  failedItemIds: failedItems.map((item) => item.id).join(","),
-                  failedItemErrors: failedItemDetails
-                }
-              },
-              new Error(`Bulk operation had ${failedItems.length} failures`)
-            );
-            this.logger?.error(mastraError.toString());
-            this.logger?.trackException(mastraError);
-            throw mastraError;
-          }
-        }
-      }
-      return vectorIds;
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("ELASTICSEARCH", "UPSERT", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName, vectorCount: vectors?.length || 0 }
-        },
-        error$1
-      );
-    }
-  }
-  /**
-   * 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.
-   * @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,
-    filter,
-    topK = 10,
-    includeVector = false
-  }) {
-    if (!queryVector) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("ELASTICSEARCH", "QUERY", "MISSING_VECTOR"),
-        text: "queryVector is required for Elasticsearch queries. Metadata-only queries are not supported by this vector store.",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        details: { indexName }
-      });
-    }
-    vector.validateTopK("ELASTICSEARCH", topK);
-    try {
-      const translatedFilter = this.transformFilter(filter);
-      const sourceFields = includeVector ? ["metadata", "embedding"] : ["metadata"];
-      const response = await this.client.search({
-        index: indexName,
-        knn: {
-          field: "embedding",
-          query_vector: queryVector,
-          k: topK,
-          num_candidates: topK * 2,
-          ...translatedFilter ? { filter: translatedFilter } : {}
-        },
-        _source: sourceFields
-      });
-      const results = response.hits.hits.map((hit) => {
-        const source = hit._source || {};
-        return {
-          id: String(hit._id),
-          score: typeof hit._score === "number" ? hit._score : 0,
-          metadata: source.metadata || {},
-          ...includeVector && { vector: source.embedding }
-        };
-      });
-      return results;
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("ELASTICSEARCH", "QUERY", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName, topK }
-        },
-        error$1
-      );
-    }
-  }
-  /**
-   * Validates the dimensions of the vectors.
-   *
-   * @param {number[][]} vectors - The vectors to validate.
-   * @param {number} dimension - The dimension of the vectors.
-   * @returns {void}
-   */
-  validateVectorDimensions(vectors, dimension) {
-    if (vectors.some((vector) => vector.length !== dimension)) {
-      throw new Error("Vector dimension does not match index dimension");
-    }
-  }
-  /**
-   * Transforms the filter to the ElasticSearch DSL.
-   *
-   * @param {ElasticSearchVectorFilter} filter - The filter to transform.
-   * @returns {Record<string, any>} The transformed filter.
-   */
-  transformFilter(filter) {
-    const translator = new ElasticSearchFilterTranslator();
-    return translator.translate(filter);
-  }
-  /**
-   * Updates vectors by ID or filter with the provided vector and/or metadata.
-   * @param params - Parameters containing either id or filter for targeting vectors to update
-   * @param params.indexName - The name of the index containing the vector(s).
-   * @param params.id - The ID of a single vector to update (mutually exclusive with filter).
-   * @param params.filter - A filter to match multiple vectors to update (mutually exclusive with id).
-   * @param params.update - An object containing the vector and/or metadata to update.
-   * @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(params) {
-    const { indexName, update } = params;
-    if ("id" in params && "filter" in params && params.id && params.filter) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("ELASTICSEARCH", "UPDATE_VECTOR", "MUTUALLY_EXCLUSIVE"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "id and filter are mutually exclusive",
-        details: { indexName }
-      });
-    }
-    if (!update.vector && !update.metadata) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("ELASTICSEARCH", "UPDATE_VECTOR", "NO_UPDATES"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "No updates provided",
-        details: { indexName }
-      });
-    }
-    if ("filter" in params && params.filter && Object.keys(params.filter).length === 0) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("ELASTICSEARCH", "UPDATE_VECTOR", "EMPTY_FILTER"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "Cannot update with empty filter",
-        details: { indexName }
-      });
-    }
-    if ("id" in params && params.id) {
-      await this.updateVectorById(indexName, params.id, update);
-    } else if ("filter" in params && params.filter) {
-      await this.updateVectorsByFilter(indexName, params.filter, update);
-    } else {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("ELASTICSEARCH", "UPDATE_VECTOR", "NO_TARGET"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "Either id or filter must be provided",
-        details: { indexName }
-      });
-    }
-  }
-  /**
-   * Updates a single vector by its ID.
-   */
-  async updateVectorById(indexName, id, update) {
-    let existingDoc;
-    try {
-      const result = await this.client.get({
-        index: indexName,
-        id,
-        _source: ["embedding", "metadata"]
-      }).catch(() => {
-        throw new Error(`Document with ID ${id} not found in index ${indexName}`);
-      });
-      if (!result || !result._source) {
-        throw new Error(`Document with ID ${id} has no source data in index ${indexName}`);
-      }
-      existingDoc = result;
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("ELASTICSEARCH", "UPDATE_VECTOR", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: {
-            indexName,
-            id
-          }
-        },
-        error$1
-      );
-    }
-    const source = existingDoc._source;
-    const updatedDoc = {};
-    try {
-      if (update.vector) {
-        const indexInfo = await this.describeIndex({ indexName });
-        this.validateVectorDimensions([update.vector], indexInfo.dimension);
-        updatedDoc.embedding = update.vector;
-      } else if (source?.embedding) {
-        updatedDoc.embedding = source.embedding;
-      }
-      if (update.metadata) {
-        updatedDoc.metadata = update.metadata;
-      } else {
-        updatedDoc.metadata = source?.metadata || {};
-      }
-      await this.client.index({
-        index: indexName,
-        id,
-        document: updatedDoc,
-        refresh: true
-      });
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("ELASTICSEARCH", "UPDATE_VECTOR", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            indexName,
-            id
-          }
-        },
-        error$1
-      );
-    }
-  }
-  /**
-   * Updates multiple vectors matching a filter.
-   */
-  async updateVectorsByFilter(indexName, filter, update) {
-    try {
-      const translator = new ElasticSearchFilterTranslator();
-      const translatedFilter = translator.translate(filter);
-      const scriptSource = [];
-      const scriptParams = {};
-      if (update.vector) {
-        scriptSource.push("ctx._source.embedding = params.embedding");
-        scriptParams.embedding = update.vector;
-      }
-      if (update.metadata) {
-        scriptSource.push("ctx._source.metadata = params.metadata");
-        scriptParams.metadata = update.metadata;
-      }
-      await this.client.updateByQuery({
-        index: indexName,
-        query: translatedFilter || { match_all: {} },
-        script: {
-          source: scriptSource.join("; "),
-          params: scriptParams,
-          lang: "painless"
-        },
-        refresh: true
-      });
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("ELASTICSEARCH", "UPDATE_VECTOR_BY_FILTER", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            indexName,
-            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 {
-      await this.client.delete({
-        index: indexName,
-        id,
-        refresh: true
-      });
-    } catch (error$1) {
-      if (error$1 && typeof error$1 === "object" && "statusCode" in error$1 && error$1.statusCode === 404) {
-        return;
-      }
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("ELASTICSEARCH", "DELETE_VECTOR", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            indexName,
-            ...id && { id }
-          }
-        },
-        error$1
-      );
-    }
-  }
-  async deleteVectors({ indexName, filter, ids }) {
-    if (ids && filter) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("ELASTICSEARCH", "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("ELASTICSEARCH", "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("ELASTICSEARCH", "DELETE_VECTORS", "EMPTY_IDS"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "Cannot delete with empty ids array",
-        details: { indexName }
-      });
-    }
-    if (filter && Object.keys(filter).length === 0) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("ELASTICSEARCH", "DELETE_VECTORS", "EMPTY_FILTER"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "Cannot delete with empty filter",
-        details: { indexName }
-      });
-    }
-    try {
-      if (ids) {
-        const bulkBody = ids.flatMap((id) => [{ delete: { _index: indexName, _id: id } }]);
-        const response = await this.client.bulk({
-          operations: bulkBody,
-          refresh: true
-        });
-        if (response.errors) {
-          const failedItems = [];
-          const successfulIds = [];
-          for (let i = 0; i < response.items.length; i++) {
-            const item = response.items[i];
-            if (!item) continue;
-            const operationType = Object.keys(item)[0];
-            const operationResult = item[operationType];
-            if (!operationResult) continue;
-            if (operationResult.error) {
-              const operationIndex = i;
-              const operationDoc = bulkBody[operationIndex];
-              const failedId = operationDoc?.delete?._id || ids[i] || `unknown-${i}`;
-              failedItems.push({
-                id: failedId,
-                status: operationResult.status || 0,
-                error: operationResult.error
-              });
-            } else if (operationResult?.status && operationResult.status < 300) {
-              const operationIndex = i;
-              const operationDoc = bulkBody[operationIndex];
-              const successId = operationDoc?.delete?._id || ids[i];
-              if (successId) {
-                successfulIds.push(successId);
-              }
-            }
-          }
-          if (failedItems.length > 0) {
-            const failedItemDetails = failedItems.map((item) => `${item.id}: ${item.error?.reason || item.error?.type || JSON.stringify(item.error)}`).join("; ");
-            const mastraError = new error.MastraError(
-              {
-                id: storage.createVectorErrorId("ELASTICSEARCH", "DELETE_VECTORS", "BULK_PARTIAL_FAILURE"),
-                text: `Bulk delete partially failed: ${failedItems.length} of ${response.items.length} operations failed. Failed items: ${failedItemDetails}`,
-                domain: error.ErrorDomain.STORAGE,
-                category: error.ErrorCategory.THIRD_PARTY,
-                details: {
-                  indexName,
-                  totalOperations: response.items.length,
-                  failedCount: failedItems.length,
-                  successfulCount: successfulIds.length,
-                  failedItemIds: failedItems.map((item) => item.id).join(","),
-                  failedItemErrors: failedItemDetails
-                }
-              },
-              new Error(`Bulk delete operation had ${failedItems.length} failures`)
-            );
-            this.logger?.error(mastraError.toString());
-            this.logger?.trackException(mastraError);
-            throw mastraError;
-          }
-        }
-      } else if (filter) {
-        const translator = new ElasticSearchFilterTranslator();
-        const translatedFilter = translator.translate(filter);
-        await this.client.deleteByQuery({
-          index: indexName,
-          query: translatedFilter || { match_all: {} },
-          refresh: true
-        });
-      }
-    } catch (error$1) {
-      if (error$1 instanceof error.MastraError) throw error$1;
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("ELASTICSEARCH", "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
-      );
-    }
-  }
+var ElasticSearchVector = class extends _mastra_core_vector.MastraVector {
+	client;
+	/**
+	* Creates a new ElasticSearchVector client.
+	*
+	* Accepts either a pre-configured ElasticSearch client or connection parameters:
+	* - `{ id, client }` - Use an existing ElasticSearch client
+	* - `{ id, url, auth? }` - Create a new client from connection parameters
+	*/
+	constructor(config) {
+		super({ id: config.id });
+		if ("client" in config && config.client) this.client = config.client;
+		else if ("url" in config && config.url) this.client = new _elastic_elasticsearch.Client({
+			node: config.url,
+			...config.auth && { auth: config.auth },
+			name: "mastra-elasticsearch",
+			headers: { "user-agent": `mastra-es/${version}` }
+		});
+		else throw new _mastra_core_error.MastraError({
+			id: "ELASTIC_SEARCH_CONSTRUCTOR_ERROR",
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.SYSTEM,
+			text: "Invalid config: provide either { client } or { url }."
+		});
+	}
+	/**
+	* 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)("ELASTICSEARCH", "CREATE_INDEX", "INVALID_ARGS"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			text: "Dimension must be a positive integer",
+			details: {
+				indexName,
+				dimension
+			}
+		});
+		try {
+			await this.client.indices.create({
+				index: indexName,
+				mappings: { properties: {
+					metadata: { type: "object" },
+					embedding: {
+						type: "dense_vector",
+						dims: dimension,
+						index: true,
+						similarity: METRIC_MAPPING[metric]
+					}
+				} }
+			});
+		} catch (error) {
+			const message = error?.message || error?.toString();
+			if (message && message.toLowerCase().includes("already exists")) {
+				await this.validateExistingIndex(indexName, dimension, metric);
+				return;
+			}
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("ELASTICSEARCH", "CREATE_INDEX", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					dimension,
+					metric
+				}
+			}, error);
+		}
+	}
+	/**
+	* Lists all indexes.
+	*
+	* @returns {Promise<string[]>} A promise that resolves to an array of indexes.
+	*/
+	async listIndexes() {
+		try {
+			return (await this.client.cat.indices({ format: "json" })).map((record) => record.index).filter((index) => index !== void 0 && !index.startsWith("."));
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("ELASTICSEARCH", "LIST_INDEXES", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY
+			}, error);
+		}
+	}
+	/**
+	* Validates that an existing index matches the requested dimension and metric.
+	* Throws an error if there's a mismatch, otherwise allows idempotent creation.
+	*/
+	async validateExistingIndex(indexName, dimension, metric) {
+		let info;
+		try {
+			info = await this.describeIndex({ indexName });
+		} catch (infoError) {
+			const mastraError = new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("ELASTICSEARCH", "VALIDATE_INDEX", "FETCH_FAILED"),
+				text: `Index "${indexName}" already exists, but failed to fetch index info for dimension check.`,
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.SYSTEM,
+				details: { indexName }
+			}, infoError);
+			this.logger?.trackException(mastraError);
+			this.logger?.error(mastraError.toString());
+			throw mastraError;
+		}
+		const existingDim = info?.dimension;
+		const existingMetric = info?.metric;
+		if (existingDim === dimension) {
+			this.logger?.info(`Index "${indexName}" already exists with ${existingDim} dimensions and metric ${existingMetric}, skipping creation.`);
+			if (existingMetric !== metric) this.logger?.warn(`Attempted to create index with metric "${metric}", but index already exists with metric "${existingMetric}". To use a different metric, delete and recreate the index.`);
+		} else if (info) {
+			const mastraError = new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("ELASTICSEARCH", "VALIDATE_INDEX", "DIMENSION_MISMATCH"),
+				text: `Index "${indexName}" already exists with ${existingDim} dimensions, but ${dimension} dimensions were requested`,
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.USER,
+				details: {
+					indexName,
+					existingDim,
+					requestedDim: dimension
+				}
+			});
+			this.logger?.trackException(mastraError);
+			this.logger?.error(mastraError.toString());
+			throw mastraError;
+		}
+	}
+	/**
+	* 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 embedding = ((await this.client.indices.get({ index: indexName }))[indexName]?.mappings)?.properties?.embedding;
+		const similarity = embedding.similarity;
+		const countInfo = await this.client.count({ index: indexName });
+		return {
+			dimension: Number(embedding.dims),
+			count: Number(countInfo.count),
+			metric: REVERSE_METRIC_MAPPING[similarity]
+		};
+	}
+	/**
+	* Deletes the specified index.
+	*
+	* @param {string} indexName - The name of the index to delete.
+	* @returns {Promise<void>} A promise that resolves when the index is deleted.
+	*/
+	async deleteIndex({ indexName }) {
+		try {
+			await this.client.indices.delete({ index: indexName }, { ignore: [404] });
+		} catch (error) {
+			const mastraError = new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("ELASTICSEARCH", "DELETE_INDEX", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { indexName }
+			}, error);
+			this.logger?.error(mastraError.toString());
+			this.logger?.trackException(mastraError);
+			throw mastraError;
+		}
+	}
+	/**
+	* 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 }) {
+		(0, _mastra_core_vector.validateUpsert)("ELASTICSEARCH", vectors, metadata, ids, true);
+		const vectorIds = ids || vectors.map(() => crypto.randomUUID());
+		const operations = [];
+		try {
+			const indexInfo = await this.describeIndex({ indexName });
+			this.validateVectorDimensions(vectors, indexInfo.dimension);
+			for (let i = 0; i < vectors.length; i++) {
+				const operation = { index: {
+					_index: indexName,
+					_id: vectorIds[i]
+				} };
+				const document = {
+					embedding: vectors[i],
+					metadata: metadata[i] || {}
+				};
+				operations.push(operation);
+				operations.push(document);
+			}
+			if (operations.length > 0) {
+				const response = await this.client.bulk({
+					operations,
+					refresh: true
+				});
+				if (response.errors) {
+					const failedItems = [];
+					const successfulIds = [];
+					for (let i = 0; i < response.items.length; i++) {
+						const item = response.items[i];
+						if (!item) continue;
+						const operationResult = item[Object.keys(item)[0]];
+						if (!operationResult) continue;
+						if (operationResult.error) {
+							const failedId = operations[i * 2]?.index?._id || vectorIds[i] || `unknown-${i}`;
+							failedItems.push({
+								id: failedId,
+								status: operationResult.status || 0,
+								error: operationResult.error
+							});
+						} else if (operationResult?.status && operationResult.status < 300) {
+							const successId = operations[i * 2]?.index?._id || vectorIds[i];
+							if (successId) successfulIds.push(successId);
+						}
+					}
+					if (failedItems.length > 0) {
+						const failedItemDetails = failedItems.map((item) => `${item.id}: ${item.error?.reason || item.error?.type || JSON.stringify(item.error)}`).join("; ");
+						const mastraError = new _mastra_core_error.MastraError({
+							id: (0, _mastra_core_storage.createVectorErrorId)("ELASTICSEARCH", "UPSERT", "BULK_PARTIAL_FAILURE"),
+							text: `Bulk upsert partially failed: ${failedItems.length} of ${response.items.length} operations failed. Failed items: ${failedItemDetails}`,
+							domain: _mastra_core_error.ErrorDomain.STORAGE,
+							category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+							details: {
+								indexName,
+								totalOperations: response.items.length,
+								failedCount: failedItems.length,
+								successfulCount: successfulIds.length,
+								failedItemIds: failedItems.map((item) => item.id).join(","),
+								failedItemErrors: failedItemDetails
+							}
+						}, /* @__PURE__ */ new Error(`Bulk operation had ${failedItems.length} failures`));
+						this.logger?.error(mastraError.toString());
+						this.logger?.trackException(mastraError);
+						throw mastraError;
+					}
+				}
+			}
+			return vectorIds;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("ELASTICSEARCH", "UPSERT", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					vectorCount: vectors?.length || 0
+				}
+			}, error);
+		}
+	}
+	/**
+	* 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.
+	* @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, filter, topK = 10, includeVector = false }) {
+		if (!queryVector) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("ELASTICSEARCH", "QUERY", "MISSING_VECTOR"),
+			text: "queryVector is required for Elasticsearch 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 }
+		});
+		(0, _mastra_core_vector.validateTopK)("ELASTICSEARCH", topK);
+		try {
+			const translatedFilter = this.transformFilter(filter);
+			const sourceFields = includeVector ? ["metadata", "embedding"] : ["metadata"];
+			return (await this.client.search({
+				index: indexName,
+				knn: {
+					field: "embedding",
+					query_vector: queryVector,
+					k: topK,
+					num_candidates: topK * 2,
+					...translatedFilter ? { filter: translatedFilter } : {}
+				},
+				_source: sourceFields
+			})).hits.hits.map((hit) => {
+				const source = hit._source || {};
+				return {
+					id: String(hit._id),
+					score: typeof hit._score === "number" ? hit._score : 0,
+					metadata: source.metadata || {},
+					...includeVector && { vector: source.embedding }
+				};
+			});
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("ELASTICSEARCH", "QUERY", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					topK
+				}
+			}, error);
+		}
+	}
+	/**
+	* Validates the dimensions of the vectors.
+	*
+	* @param {number[][]} vectors - The vectors to validate.
+	* @param {number} dimension - The dimension of the vectors.
+	* @returns {void}
+	*/
+	validateVectorDimensions(vectors, dimension) {
+		if (vectors.some((vector) => vector.length !== dimension)) throw new Error("Vector dimension does not match index dimension");
+	}
+	/**
+	* Transforms the filter to the ElasticSearch DSL.
+	*
+	* @param {ElasticSearchVectorFilter} filter - The filter to transform.
+	* @returns {Record<string, any>} The transformed filter.
+	*/
+	transformFilter(filter) {
+		return new ElasticSearchFilterTranslator().translate(filter);
+	}
+	/**
+	* Updates vectors by ID or filter with the provided vector and/or metadata.
+	* @param params - Parameters containing either id or filter for targeting vectors to update
+	* @param params.indexName - The name of the index containing the vector(s).
+	* @param params.id - The ID of a single vector to update (mutually exclusive with filter).
+	* @param params.filter - A filter to match multiple vectors to update (mutually exclusive with id).
+	* @param params.update - An object containing the vector and/or metadata to update.
+	* @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(params) {
+		const { indexName, update } = params;
+		if ("id" in params && "filter" in params && params.id && params.filter) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("ELASTICSEARCH", "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 (!update.vector && !update.metadata) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("ELASTICSEARCH", "UPDATE_VECTOR", "NO_UPDATES"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			text: "No updates provided",
+			details: { indexName }
+		});
+		if ("filter" in params && params.filter && Object.keys(params.filter).length === 0) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("ELASTICSEARCH", "UPDATE_VECTOR", "EMPTY_FILTER"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			text: "Cannot update with empty filter",
+			details: { indexName }
+		});
+		if ("id" in params && params.id) await this.updateVectorById(indexName, params.id, update);
+		else if ("filter" in params && params.filter) await this.updateVectorsByFilter(indexName, params.filter, update);
+		else throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("ELASTICSEARCH", "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 }
+		});
+	}
+	/**
+	* Updates a single vector by its ID.
+	*/
+	async updateVectorById(indexName, id, update) {
+		let existingDoc;
+		try {
+			const result = await this.client.get({
+				index: indexName,
+				id,
+				_source: ["embedding", "metadata"]
+			}).catch(() => {
+				throw new Error(`Document with ID ${id} not found in index ${indexName}`);
+			});
+			if (!result || !result._source) throw new Error(`Document with ID ${id} has no source data in index ${indexName}`);
+			existingDoc = result;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("ELASTICSEARCH", "UPDATE_VECTOR", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.USER,
+				details: {
+					indexName,
+					id
+				}
+			}, error);
+		}
+		const source = existingDoc._source;
+		const updatedDoc = {};
+		try {
+			if (update.vector) {
+				const indexInfo = await this.describeIndex({ indexName });
+				this.validateVectorDimensions([update.vector], indexInfo.dimension);
+				updatedDoc.embedding = update.vector;
+			} else if (source?.embedding) updatedDoc.embedding = source.embedding;
+			if (update.metadata) updatedDoc.metadata = update.metadata;
+			else updatedDoc.metadata = source?.metadata || {};
+			await this.client.index({
+				index: indexName,
+				id,
+				document: updatedDoc,
+				refresh: true
+			});
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("ELASTICSEARCH", "UPDATE_VECTOR", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					id
+				}
+			}, error);
+		}
+	}
+	/**
+	* Updates multiple vectors matching a filter.
+	*/
+	async updateVectorsByFilter(indexName, filter, update) {
+		try {
+			const translatedFilter = new ElasticSearchFilterTranslator().translate(filter);
+			const scriptSource = [];
+			const scriptParams = {};
+			if (update.vector) {
+				scriptSource.push("ctx._source.embedding = params.embedding");
+				scriptParams.embedding = update.vector;
+			}
+			if (update.metadata) {
+				scriptSource.push("ctx._source.metadata = params.metadata");
+				scriptParams.metadata = update.metadata;
+			}
+			await this.client.updateByQuery({
+				index: indexName,
+				query: translatedFilter || { match_all: {} },
+				script: {
+					source: scriptSource.join("; "),
+					params: scriptParams,
+					lang: "painless"
+				},
+				refresh: true
+			});
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("ELASTICSEARCH", "UPDATE_VECTOR_BY_FILTER", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					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.delete({
+				index: indexName,
+				id,
+				refresh: true
+			});
+		} catch (error) {
+			if (error && typeof error === "object" && "statusCode" in error && error.statusCode === 404) return;
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("ELASTICSEARCH", "DELETE_VECTOR", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					...id && { id }
+				}
+			}, error);
+		}
+	}
+	async deleteVectors({ indexName, filter, ids }) {
+		if (ids && filter) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("ELASTICSEARCH", "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)("ELASTICSEARCH", "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)("ELASTICSEARCH", "DELETE_VECTORS", "EMPTY_IDS"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			text: "Cannot delete with empty ids array",
+			details: { indexName }
+		});
+		if (filter && Object.keys(filter).length === 0) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("ELASTICSEARCH", "DELETE_VECTORS", "EMPTY_FILTER"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			text: "Cannot delete with empty filter",
+			details: { indexName }
+		});
+		try {
+			if (ids) {
+				const bulkBody = ids.flatMap((id) => [{ delete: {
+					_index: indexName,
+					_id: id
+				} }]);
+				const response = await this.client.bulk({
+					operations: bulkBody,
+					refresh: true
+				});
+				if (response.errors) {
+					const failedItems = [];
+					const successfulIds = [];
+					for (let i = 0; i < response.items.length; i++) {
+						const item = response.items[i];
+						if (!item) continue;
+						const operationResult = item[Object.keys(item)[0]];
+						if (!operationResult) continue;
+						if (operationResult.error) {
+							const failedId = bulkBody[i]?.delete?._id || ids[i] || `unknown-${i}`;
+							failedItems.push({
+								id: failedId,
+								status: operationResult.status || 0,
+								error: operationResult.error
+							});
+						} else if (operationResult?.status && operationResult.status < 300) {
+							const successId = bulkBody[i]?.delete?._id || ids[i];
+							if (successId) successfulIds.push(successId);
+						}
+					}
+					if (failedItems.length > 0) {
+						const failedItemDetails = failedItems.map((item) => `${item.id}: ${item.error?.reason || item.error?.type || JSON.stringify(item.error)}`).join("; ");
+						const mastraError = new _mastra_core_error.MastraError({
+							id: (0, _mastra_core_storage.createVectorErrorId)("ELASTICSEARCH", "DELETE_VECTORS", "BULK_PARTIAL_FAILURE"),
+							text: `Bulk delete partially failed: ${failedItems.length} of ${response.items.length} operations failed. Failed items: ${failedItemDetails}`,
+							domain: _mastra_core_error.ErrorDomain.STORAGE,
+							category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+							details: {
+								indexName,
+								totalOperations: response.items.length,
+								failedCount: failedItems.length,
+								successfulCount: successfulIds.length,
+								failedItemIds: failedItems.map((item) => item.id).join(","),
+								failedItemErrors: failedItemDetails
+							}
+						}, /* @__PURE__ */ new Error(`Bulk delete operation had ${failedItems.length} failures`));
+						this.logger?.error(mastraError.toString());
+						this.logger?.trackException(mastraError);
+						throw mastraError;
+					}
+				}
+			} else if (filter) {
+				const translatedFilter = new ElasticSearchFilterTranslator().translate(filter);
+				await this.client.deleteByQuery({
+					index: indexName,
+					query: translatedFilter || { match_all: {} },
+					refresh: true
+				});
+			}
+		} catch (error) {
+			if (error instanceof _mastra_core_error.MastraError) throw error;
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("ELASTICSEARCH", "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.ElasticSearchVector = ElasticSearchVector;
-//# sourceMappingURL=index.cjs.map
+
 //# sourceMappingURL=index.cjs.map