@mastra/pinecone 1.1.0 → 1.1.1-alpha.1

package/dist/index.cjs

@@ -1,526 +1,442 @@
-'use strict';
-
-var error = require('@mastra/core/error');
-var storage = require('@mastra/core/storage');
-var vector = require('@mastra/core/vector');
-var pinecone = require('@pinecone-database/pinecone');
-var filter = require('@mastra/core/vector/filter');
-
-// src/vector/index.ts
-var PineconeFilterTranslator = class extends filter.BaseFilterTranslator {
-  getSupportedOperators() {
-    return {
-      ...filter.BaseFilterTranslator.DEFAULT_OPERATORS,
-      logical: ["$and", "$or"],
-      array: ["$in", "$all", "$nin"],
-      element: ["$exists"],
-      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 Pinecone");
-    }
-    if (this.isPrimitive(node)) return 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;
-      const translated = this.translateOperator(operator, value, currentPath);
-      return this.isLogicalOperator(operator) ? { [operator]: translated } : translated;
-    }
-    const result = {};
-    for (const [key, value] of entries) {
-      const newPath = currentPath ? `${currentPath}.${key}` : key;
-      if (this.isOperator(key)) {
-        result[key] = this.translateOperator(key, value, currentPath);
-        continue;
-      }
-      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-        if (Object.keys(value).length === 1 && "$all" in value) {
-          const translated = this.translateNode(value, key);
-          if (translated.$and) {
-            return translated;
-          }
-        }
-        if (Object.keys(value).length === 0) {
-          result[newPath] = this.translateNode(value);
-        } else {
-          const hasOperators = Object.keys(value).some((k) => this.isOperator(k));
-          if (hasOperators) {
-            const normalizedValue = {};
-            for (const [op, opValue] of Object.entries(value)) {
-              normalizedValue[op] = this.isOperator(op) ? this.translateOperator(op, opValue) : opValue;
-            }
-            result[newPath] = normalizedValue;
-          } else {
-            Object.assign(result, this.translateNode(value, newPath));
-          }
-        }
-      } else {
-        result[newPath] = this.translateNode(value);
-      }
-    }
-    return result;
-  }
-  translateOperator(operator, value, currentPath = "") {
-    if (operator === "$all") {
-      if (!Array.isArray(value) || value.length === 0) {
-        throw new Error("A non-empty array is required for the $all operator");
-      }
-      return this.simulateAllOperator(currentPath, value);
-    }
-    if (this.isLogicalOperator(operator)) {
-      return Array.isArray(value) ? value.map((item) => this.translateNode(item)) : this.translateNode(value);
-    }
-    return this.normalizeComparisonValue(value);
-  }
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _mastra_core_error = require("@mastra/core/error");
+let _mastra_core_storage = require("@mastra/core/storage");
+let _mastra_core_vector = require("@mastra/core/vector");
+let _pinecone_database_pinecone = require("@pinecone-database/pinecone");
+let _mastra_core_vector_filter = require("@mastra/core/vector/filter");
+//#region src/vector/filter.ts
+var PineconeFilterTranslator = class extends _mastra_core_vector_filter.BaseFilterTranslator {
+	getSupportedOperators() {
+		return {
+			..._mastra_core_vector_filter.BaseFilterTranslator.DEFAULT_OPERATORS,
+			logical: ["$and", "$or"],
+			array: [
+				"$in",
+				"$all",
+				"$nin"
+			],
+			element: ["$exists"],
+			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 Pinecone");
+		if (this.isPrimitive(node)) return 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;
+			const translated = this.translateOperator(operator, value, currentPath);
+			return this.isLogicalOperator(operator) ? { [operator]: translated } : translated;
+		}
+		const result = {};
+		for (const [key, value] of entries) {
+			const newPath = currentPath ? `${currentPath}.${key}` : key;
+			if (this.isOperator(key)) {
+				result[key] = this.translateOperator(key, value, currentPath);
+				continue;
+			}
+			if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+				if (Object.keys(value).length === 1 && "$all" in value) {
+					const translated = this.translateNode(value, key);
+					if (translated.$and) return translated;
+				}
+				if (Object.keys(value).length === 0) result[newPath] = this.translateNode(value);
+				else if (Object.keys(value).some((k) => this.isOperator(k))) {
+					const normalizedValue = {};
+					for (const [op, opValue] of Object.entries(value)) normalizedValue[op] = this.isOperator(op) ? this.translateOperator(op, opValue) : opValue;
+					result[newPath] = normalizedValue;
+				} else Object.assign(result, this.translateNode(value, newPath));
+			} else result[newPath] = this.translateNode(value);
+		}
+		return result;
+	}
+	translateOperator(operator, value, currentPath = "") {
+		if (operator === "$all") {
+			if (!Array.isArray(value) || value.length === 0) throw new Error("A non-empty array is required for the $all operator");
+			return this.simulateAllOperator(currentPath, value);
+		}
+		if (this.isLogicalOperator(operator)) return Array.isArray(value) ? value.map((item) => this.translateNode(item)) : this.translateNode(value);
+		return this.normalizeComparisonValue(value);
+	}
 };
-
-// src/vector/index.ts
-var PineconeVector = class extends vector.MastraVector {
-  client;
-  cloud;
-  region;
-  /**
-   * Creates a new PineconeVector client.
-   *
-   * @param config - Configuration options for the Pinecone client.
-   * @see {@link PineconeVectorConfig} for all available options.
-   */
-  constructor({ id, cloud, region, ...pineconeConfig }) {
-    super({ id });
-    this.client = new pinecone.Pinecone(pineconeConfig);
-    this.cloud = cloud || "aws";
-    this.region = region || "us-east-1";
-  }
-  get indexSeparator() {
-    return "-";
-  }
-  async createIndex({ indexName, dimension, metric = "cosine" }) {
-    try {
-      if (!Number.isInteger(dimension) || dimension <= 0) {
-        throw new Error("Dimension must be a positive integer");
-      }
-      if (metric && !["cosine", "euclidean", "dotproduct"].includes(metric)) {
-        throw new Error("Metric must be one of: cosine, euclidean, dotproduct");
-      }
-    } catch (validationError) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("PINECONE", "CREATE_INDEX", "INVALID_ARGS"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: { indexName, dimension, metric }
-        },
-        validationError
-      );
-    }
-    try {
-      await this.client.createIndex({
-        name: indexName,
-        dimension,
-        metric,
-        spec: {
-          serverless: {
-            cloud: this.cloud,
-            region: this.region
-          }
-        }
-      });
-    } 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("PINECONE", "CREATE_INDEX", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName, dimension, metric }
-        },
-        error$1
-      );
-    }
-  }
-  async upsert({
-    indexName,
-    vectors,
-    metadata,
-    ids,
-    namespace,
-    sparseVectors
-  }) {
-    const index = this.client.Index(indexName).namespace(namespace || "");
-    const vectorIds = ids || vectors.map(() => crypto.randomUUID());
-    const records = vectors.map((vector, i) => ({
-      id: vectorIds[i],
-      values: vector,
-      ...sparseVectors?.[i] && { sparseValues: sparseVectors?.[i] },
-      metadata: metadata?.[i] || {}
-    }));
-    const batchSize = 100;
-    try {
-      for (let i = 0; i < records.length; i += batchSize) {
-        const batch = records.slice(i, i + batchSize);
-        await index.upsert(batch);
-      }
-      return vectorIds;
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("PINECONE", "UPSERT", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName, vectorCount: vectors.length }
-        },
-        error$1
-      );
-    }
-  }
-  transformFilter(filter) {
-    const translator = new PineconeFilterTranslator();
-    return translator.translate(filter);
-  }
-  async query({
-    indexName,
-    queryVector,
-    topK = 10,
-    filter,
-    includeVector = false,
-    namespace,
-    sparseVector
-  }) {
-    if (!queryVector) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("PINECONE", "QUERY", "MISSING_VECTOR"),
-        text: "queryVector is required for Pinecone queries. Metadata-only queries are not supported by this vector store.",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        details: { indexName }
-      });
-    }
-    const index = this.client.Index(indexName).namespace(namespace || "");
-    const translatedFilter = this.transformFilter(filter) ?? void 0;
-    const queryParams = {
-      vector: queryVector,
-      topK,
-      includeMetadata: true,
-      includeValues: includeVector,
-      filter: translatedFilter
-    };
-    if (sparseVector) {
-      queryParams.sparseVector = sparseVector;
-    }
-    try {
-      const results = await index.query(queryParams);
-      return results.matches.map((match) => ({
-        id: match.id,
-        score: match.score || 0,
-        metadata: match.metadata,
-        ...includeVector && { vector: match.values || [] }
-      }));
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("PINECONE", "QUERY", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName, topK }
-        },
-        error$1
-      );
-    }
-  }
-  async listIndexes() {
-    try {
-      const indexesResult = await this.client.listIndexes();
-      return indexesResult?.indexes?.map((index) => index.name) || [];
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("PINECONE", "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 = this.client.Index(indexName);
-      const stats = await index.describeIndexStats();
-      const description = await this.client.describeIndex(indexName);
-      return {
-        dimension: description.dimension,
-        count: stats.totalRecordCount || 0,
-        metric: description.metric,
-        namespaces: stats.namespaces
-      };
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("PINECONE", "DESCRIBE_INDEX", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName }
-        },
-        error$1
-      );
-    }
-  }
-  async deleteIndex({ indexName }) {
-    try {
-      await this.client.deleteIndex(indexName);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("PINECONE", "DELETE_INDEX", "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.
-   * Note: Pinecone only supports update by ID, not by filter.
-   * @param params - Parameters containing the id for targeting the vector to update
-   * @param params.indexName - The name of the index containing the vector.
-   * @param params.id - The ID of the vector to update.
-   * @param params.update - An object containing the vector and/or metadata to update.
-   * @param namespace - The namespace of the index (optional, Pinecone-specific).
-   * @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 && params.id && "filter" in params && params.filter) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("PINECONE", "UPDATE_VECTOR", "MUTUALLY_EXCLUSIVE"),
-        text: "Cannot specify both id and filter - they are mutually exclusive",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        details: { indexName }
-      });
-    }
-    if (!("id" in params && params.id) && !("filter" in params && params.filter)) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("PINECONE", "UPDATE_VECTOR", "NO_TARGET"),
-        text: "Either id or filter must be provided",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        details: { indexName }
-      });
-    }
-    if (!update.vector && !update.metadata) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("PINECONE", "UPDATE_VECTOR", "NO_PAYLOAD"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "No updates provided",
-        details: { indexName }
-      });
-    }
-    const namespace = params.namespace;
-    try {
-      const index = this.client.Index(indexName).namespace(namespace || "");
-      if ("id" in params && params.id) {
-        const updateObj = { id: params.id };
-        if (update.vector) {
-          updateObj.values = update.vector;
-        }
-        if (update.metadata) {
-          updateObj.metadata = update.metadata;
-        }
-        await index.update(updateObj);
-      } else if ("filter" in params && params.filter) {
-        if (Object.keys(params.filter).length === 0) {
-          throw new error.MastraError({
-            id: storage.createVectorErrorId("PINECONE", "UPDATE_VECTOR", "EMPTY_FILTER"),
-            text: "Filter cannot be an empty filter object",
-            domain: error.ErrorDomain.STORAGE,
-            category: error.ErrorCategory.USER,
-            details: { indexName }
-          });
-        }
-        const translatedFilter = this.transformFilter(params.filter);
-        if (translatedFilter) {
-          const stats = await this.describeIndex({ indexName });
-          const dummyVector = new Array(stats.dimension).fill(1 / Math.sqrt(stats.dimension));
-          const results = await index.query({
-            vector: dummyVector,
-            topK: 1e4,
-            filter: translatedFilter,
-            includeMetadata: false,
-            includeValues: false
-          });
-          const idsToUpdate = results.matches.map((m) => m.id);
-          for (const id of idsToUpdate) {
-            const updateObj = { id };
-            if (update.vector) {
-              updateObj.values = update.vector;
-            }
-            if (update.metadata) {
-              updateObj.metadata = update.metadata;
-            }
-            await index.update(updateObj);
-          }
-        }
-      }
-    } catch (error$1) {
-      if (error$1 instanceof error.MastraError) throw error$1;
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("PINECONE", "UPDATE_VECTOR", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            indexName,
-            ..."id" in params && params.id && { id: params.id },
-            ..."filter" in params && params.filter && { filter: JSON.stringify(params.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.
-   * @param namespace - The namespace of the index (optional).
-   * @returns A promise that resolves when the deletion is complete.
-   * @throws Will throw an error if the deletion operation fails.
-   */
-  async deleteVector({ indexName, id, namespace }) {
-    try {
-      const index = this.client.Index(indexName).namespace(namespace || "");
-      await index.deleteOne(id);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("PINECONE", "DELETE_VECTOR", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            indexName,
-            ...id && { id }
-          }
-        },
-        error$1
-      );
-    }
-  }
-  /**
-   * Deletes multiple vectors by IDs or filter.
-   * @param indexName - The name of the index containing the vectors.
-   * @param ids - Array of vector IDs to delete (mutually exclusive with filter).
-   * @param filter - Filter to match vectors to delete (mutually exclusive with ids).
-   * @param namespace - The namespace of the index (optional, Pinecone-specific).
-   * @returns A promise that resolves when the deletion is complete.
-   * @throws Will throw an error if both ids and filter are provided, or if neither is provided.
-   */
-  async deleteVectors(params) {
-    const { indexName, filter, ids } = params;
-    const namespace = params.namespace;
-    if (ids && filter) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("PINECONE", "DELETE_VECTORS", "MUTUALLY_EXCLUSIVE"),
-        text: "Cannot specify both ids and filter - they are mutually exclusive",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        details: { indexName }
-      });
-    }
-    if (!ids && !filter) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("PINECONE", "DELETE_VECTORS", "NO_TARGET"),
-        text: "Either filter or ids must be provided",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        details: { indexName }
-      });
-    }
-    if (ids && ids.length === 0) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("PINECONE", "DELETE_VECTORS", "EMPTY_IDS"),
-        text: "Cannot delete with empty ids array",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        details: { indexName }
-      });
-    }
-    if (filter && Object.keys(filter).length === 0) {
-      throw new error.MastraError({
-        id: storage.createVectorErrorId("PINECONE", "DELETE_VECTORS", "EMPTY_FILTER"),
-        text: "Cannot delete with empty filter object",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        details: { indexName }
-      });
-    }
-    try {
-      const index = this.client.Index(indexName).namespace(namespace || "");
-      if (ids) {
-        await index.deleteMany(ids);
-      } else if (filter) {
-        const translatedFilter = this.transformFilter(filter);
-        if (translatedFilter) {
-          const stats = await this.describeIndex({ indexName });
-          const dummyVector = new Array(stats.dimension).fill(1 / Math.sqrt(stats.dimension));
-          const results = await index.query({
-            vector: dummyVector,
-            topK: 1e4,
-            filter: translatedFilter,
-            includeMetadata: false,
-            includeValues: false
-          });
-          const idsToDelete = results.matches.map((m) => m.id);
-          if (idsToDelete.length > 0) {
-            await index.deleteMany(idsToDelete);
-          }
-        }
-      }
-    } catch (error$1) {
-      if (error$1 instanceof error.MastraError) throw error$1;
-      throw new error.MastraError(
-        {
-          id: storage.createVectorErrorId("PINECONE", "DELETE_VECTORS", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            indexName,
-            ...filter && { filter: JSON.stringify(filter) },
-            ...ids && { idsCount: ids.length }
-          }
-        },
-        error$1
-      );
-    }
-  }
+//#endregion
+//#region src/vector/index.ts
+var PineconeVector = class extends _mastra_core_vector.MastraVector {
+	client;
+	cloud;
+	region;
+	/**
+	* Creates a new PineconeVector client.
+	*
+	* @param config - Configuration options for the Pinecone client.
+	* @see {@link PineconeVectorConfig} for all available options.
+	*/
+	constructor({ id, cloud, region, ...pineconeConfig }) {
+		super({ id });
+		this.client = new _pinecone_database_pinecone.Pinecone(pineconeConfig);
+		this.cloud = cloud || "aws";
+		this.region = region || "us-east-1";
+	}
+	get indexSeparator() {
+		return "-";
+	}
+	async createIndex({ indexName, dimension, metric = "cosine" }) {
+		try {
+			if (!Number.isInteger(dimension) || dimension <= 0) throw new Error("Dimension must be a positive integer");
+			if (metric && ![
+				"cosine",
+				"euclidean",
+				"dotproduct"
+			].includes(metric)) throw new Error("Metric must be one of: cosine, euclidean, dotproduct");
+		} catch (validationError) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("PINECONE", "CREATE_INDEX", "INVALID_ARGS"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.USER,
+				details: {
+					indexName,
+					dimension,
+					metric
+				}
+			}, validationError);
+		}
+		try {
+			await this.client.createIndex({
+				name: indexName,
+				dimension,
+				metric,
+				spec: { serverless: {
+					cloud: this.cloud,
+					region: this.region
+				} }
+			});
+		} 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)("PINECONE", "CREATE_INDEX", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					dimension,
+					metric
+				}
+			}, error);
+		}
+	}
+	async upsert({ indexName, vectors, metadata, ids, namespace, sparseVectors }) {
+		const index = this.client.Index(indexName).namespace(namespace || "");
+		const vectorIds = ids || vectors.map(() => crypto.randomUUID());
+		const records = vectors.map((vector, i) => ({
+			id: vectorIds[i],
+			values: vector,
+			...sparseVectors?.[i] && { sparseValues: sparseVectors?.[i] },
+			metadata: metadata?.[i] || {}
+		}));
+		const batchSize = 100;
+		try {
+			for (let i = 0; i < records.length; i += batchSize) {
+				const batch = records.slice(i, i + batchSize);
+				await index.upsert(batch);
+			}
+			return vectorIds;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("PINECONE", "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 PineconeFilterTranslator().translate(filter);
+	}
+	async query({ indexName, queryVector, topK = 10, filter, includeVector = false, namespace, sparseVector }) {
+		if (!queryVector) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("PINECONE", "QUERY", "MISSING_VECTOR"),
+			text: "queryVector is required for Pinecone 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 }
+		});
+		const index = this.client.Index(indexName).namespace(namespace || "");
+		const queryParams = {
+			vector: queryVector,
+			topK,
+			includeMetadata: true,
+			includeValues: includeVector,
+			filter: this.transformFilter(filter) ?? void 0
+		};
+		if (sparseVector) queryParams.sparseVector = sparseVector;
+		try {
+			return (await index.query(queryParams)).matches.map((match) => ({
+				id: match.id,
+				score: match.score || 0,
+				metadata: match.metadata,
+				...includeVector && { vector: match.values || [] }
+			}));
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("PINECONE", "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.listIndexes())?.indexes?.map((index) => index.name) || [];
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("PINECONE", "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 stats = await this.client.Index(indexName).describeIndexStats();
+			const description = await this.client.describeIndex(indexName);
+			return {
+				dimension: description.dimension,
+				count: stats.totalRecordCount || 0,
+				metric: description.metric,
+				namespaces: stats.namespaces
+			};
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("PINECONE", "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.deleteIndex(indexName);
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("PINECONE", "DELETE_INDEX", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { indexName }
+			}, error);
+		}
+	}
+	/**
+	* Updates a vector by its ID with the provided vector and/or metadata.
+	* Note: Pinecone only supports update by ID, not by filter.
+	* @param params - Parameters containing the id for targeting the vector to update
+	* @param params.indexName - The name of the index containing the vector.
+	* @param params.id - The ID of the vector to update.
+	* @param params.update - An object containing the vector and/or metadata to update.
+	* @param namespace - The namespace of the index (optional, Pinecone-specific).
+	* @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 && params.id && "filter" in params && params.filter) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("PINECONE", "UPDATE_VECTOR", "MUTUALLY_EXCLUSIVE"),
+			text: "Cannot specify both id and filter - they are mutually exclusive",
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			details: { indexName }
+		});
+		if (!("id" in params && params.id) && !("filter" in params && params.filter)) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("PINECONE", "UPDATE_VECTOR", "NO_TARGET"),
+			text: "Either id or filter must be provided",
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			details: { indexName }
+		});
+		if (!update.vector && !update.metadata) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("PINECONE", "UPDATE_VECTOR", "NO_PAYLOAD"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			text: "No updates provided",
+			details: { indexName }
+		});
+		const namespace = params.namespace;
+		try {
+			const index = this.client.Index(indexName).namespace(namespace || "");
+			if ("id" in params && params.id) {
+				const updateObj = { id: params.id };
+				if (update.vector) updateObj.values = update.vector;
+				if (update.metadata) updateObj.metadata = update.metadata;
+				await index.update(updateObj);
+			} else if ("filter" in params && params.filter) {
+				if (Object.keys(params.filter).length === 0) throw new _mastra_core_error.MastraError({
+					id: (0, _mastra_core_storage.createVectorErrorId)("PINECONE", "UPDATE_VECTOR", "EMPTY_FILTER"),
+					text: "Filter cannot be an empty filter object",
+					domain: _mastra_core_error.ErrorDomain.STORAGE,
+					category: _mastra_core_error.ErrorCategory.USER,
+					details: { indexName }
+				});
+				const translatedFilter = this.transformFilter(params.filter);
+				if (translatedFilter) {
+					const stats = await this.describeIndex({ indexName });
+					const dummyVector = new Array(stats.dimension).fill(1 / Math.sqrt(stats.dimension));
+					const idsToUpdate = (await index.query({
+						vector: dummyVector,
+						topK: 1e4,
+						filter: translatedFilter,
+						includeMetadata: false,
+						includeValues: false
+					})).matches.map((m) => m.id);
+					for (const id of idsToUpdate) {
+						const updateObj = { id };
+						if (update.vector) updateObj.values = update.vector;
+						if (update.metadata) updateObj.metadata = update.metadata;
+						await index.update(updateObj);
+					}
+				}
+			}
+		} catch (error) {
+			if (error instanceof _mastra_core_error.MastraError) throw error;
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("PINECONE", "UPDATE_VECTOR", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					..."id" in params && params.id && { id: params.id },
+					..."filter" in params && params.filter && { filter: JSON.stringify(params.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.
+	* @param namespace - The namespace of the index (optional).
+	* @returns A promise that resolves when the deletion is complete.
+	* @throws Will throw an error if the deletion operation fails.
+	*/
+	async deleteVector({ indexName, id, namespace }) {
+		try {
+			await this.client.Index(indexName).namespace(namespace || "").deleteOne(id);
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("PINECONE", "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 IDs or filter.
+	* @param indexName - The name of the index containing the vectors.
+	* @param ids - Array of vector IDs to delete (mutually exclusive with filter).
+	* @param filter - Filter to match vectors to delete (mutually exclusive with ids).
+	* @param namespace - The namespace of the index (optional, Pinecone-specific).
+	* @returns A promise that resolves when the deletion is complete.
+	* @throws Will throw an error if both ids and filter are provided, or if neither is provided.
+	*/
+	async deleteVectors(params) {
+		const { indexName, filter, ids } = params;
+		const namespace = params.namespace;
+		if (ids && filter) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("PINECONE", "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 (!ids && !filter) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("PINECONE", "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 && ids.length === 0) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("PINECONE", "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 }
+		});
+		if (filter && Object.keys(filter).length === 0) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createVectorErrorId)("PINECONE", "DELETE_VECTORS", "EMPTY_FILTER"),
+			text: "Cannot delete with empty filter object",
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.USER,
+			details: { indexName }
+		});
+		try {
+			const index = this.client.Index(indexName).namespace(namespace || "");
+			if (ids) await index.deleteMany(ids);
+			else if (filter) {
+				const translatedFilter = this.transformFilter(filter);
+				if (translatedFilter) {
+					const stats = await this.describeIndex({ indexName });
+					const dummyVector = new Array(stats.dimension).fill(1 / Math.sqrt(stats.dimension));
+					const idsToDelete = (await index.query({
+						vector: dummyVector,
+						topK: 1e4,
+						filter: translatedFilter,
+						includeMetadata: false,
+						includeValues: false
+					})).matches.map((m) => m.id);
+					if (idsToDelete.length > 0) await index.deleteMany(idsToDelete);
+				}
+			}
+		} catch (error) {
+			if (error instanceof _mastra_core_error.MastraError) throw error;
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createVectorErrorId)("PINECONE", "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);
+		}
+	}
 };
-
-// src/vector/prompt.ts
-var PINECONE_PROMPT = `When querying Pinecone, you can ONLY use the operators listed below. Any other operators will be rejected.
+//#endregion
+//#region src/vector/prompt.ts
+/**
+* Vector store specific prompt that details supported operators and examples.
+* This prompt helps users construct valid filters for Pinecone Vector.
+*/
+const PINECONE_PROMPT = `When querying Pinecone, 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.
 
@@ -597,8 +513,8 @@ Example Complex Query:
     ]}
   ]
 }`;
-
+//#endregion
 exports.PINECONE_PROMPT = PINECONE_PROMPT;
 exports.PineconeVector = PineconeVector;
-//# sourceMappingURL=index.cjs.map
+
 //# sourceMappingURL=index.cjs.map