@mastra/rag 1.3.4 → 2.0.0-beta.1

package/dist/index.cjs

@@ -4143,17 +4143,18 @@ var TitleExtractor = class extends BaseExtractor {
       let title = "";
       if (this.llm.specificationVersion === "v2") {
         const miniAgent = new agent.Agent({
+          id: "title-extractor",
           model: this.llm,
           name: "title-extractor",
           instructions: "You are a title extractor. You are given a list of nodes and you need to extract the title from the nodes."
         });
-        const result = await miniAgent.generate(
-          [{ role: "user", content: this.combineTemplate.format({ context: combinedTitles }) }],
-          { format: "mastra" }
-        );
+        const result = await miniAgent.generate([
+          { role: "user", content: this.combineTemplate.format({ context: combinedTitles }) }
+        ]);
         title = result.text;
       } else {
         const miniAgent = new agent.Agent({
+          id: "title-extractor-v1",
           model: this.llm,
           name: "title-extractor",
           instructions: "You are a title extractor. You are given a list of nodes and you need to extract the title from the nodes."
@@ -4172,6 +4173,7 @@ var TitleExtractor = class extends BaseExtractor {
   }
   async getTitlesCandidates(nodes) {
     const miniAgent = new agent.Agent({
+      id: "titles-candidates-extractor",
       model: this.llm,
       name: "titles-candidates-extractor",
       instructions: "You are a titles candidates extractor. You are given a list of nodes and you need to extract the titles candidates from the nodes."
@@ -4179,10 +4181,9 @@ var TitleExtractor = class extends BaseExtractor {
     const titleJobs = nodes.map(async (node) => {
       let completion;
       if (this.llm.specificationVersion === "v2") {
-        const result = await miniAgent.generate(
-          [{ role: "user", content: this.nodeTemplate.format({ context: node.getContent() }) }],
-          { format: "mastra" }
-        );
+        const result = await miniAgent.generate([
+          { role: "user", content: this.nodeTemplate.format({ context: node.getContent() }) }
+        ]);
         completion = result.text;
       } else {
         const result = await miniAgent.generateLegacy([
@@ -4239,13 +4240,14 @@ var SummaryExtractor = class extends BaseExtractor {
       context
     });
     const miniAgent = new agent.Agent({
+      id: "summary-extractor",
       model: this.llm,
       name: "summary-extractor",
       instructions: "You are a summary extractor. You are given a node and you need to extract the summary from the node."
     });
     let summary = "";
     if (this.llm.specificationVersion === "v2") {
-      const result = await miniAgent.generate([{ role: "user", content: prompt }], { format: "mastra" });
+      const result = await miniAgent.generate([{ role: "user", content: prompt }]);
       summary = result.text;
     } else {
       const result = await miniAgent.generateLegacy([{ role: "user", content: prompt }]);
@@ -4324,13 +4326,14 @@ var QuestionsAnsweredExtractor = class extends BaseExtractor {
       numQuestions: this.questions.toString()
     });
     const miniAgent = new agent.Agent({
+      id: "question-extractor",
       model: this.llm,
       name: "question-extractor",
       instructions: "You are a question extractor. You are given a node and you need to extract the questions from the node."
     });
     let questionsText = "";
     if (this.llm.specificationVersion === "v2") {
-      const result2 = await miniAgent.generate([{ role: "user", content: prompt }], { format: "mastra" });
+      const result2 = await miniAgent.generate([{ role: "user", content: prompt }]);
       questionsText = result2.text;
     } else {
       const result2 = await miniAgent.generateLegacy([{ role: "user", content: prompt }]);
@@ -4396,23 +4399,21 @@ var KeywordExtractor = class extends BaseExtractor {
     let keywords = "";
     try {
       const miniAgent = new agent.Agent({
+        id: "keyword-extractor",
         model: this.llm,
         name: "keyword-extractor",
         instructions: "You are a keyword extractor. You are given a node and you need to extract the keywords from the node."
       });
       if (this.llm.specificationVersion === "v2") {
-        const result = await miniAgent.generate(
-          [
-            {
-              role: "user",
-              content: this.promptTemplate.format({
-                context: node.getContent(),
-                maxKeywords: this.keywords.toString()
-              })
-            }
-          ],
-          { format: "mastra" }
-        );
+        const result = await miniAgent.generate([
+          {
+            role: "user",
+            content: this.promptTemplate.format({
+              context: node.getContent(),
+              maxKeywords: this.keywords.toString()
+            })
+          }
+        ]);
         keywords = result.text;
       } else {
         const result = await miniAgent.generateLegacy([
@@ -6140,20 +6141,7 @@ var TokenTransformer = class _TokenTransformer extends TextTransformer {
     });
   }
 };
-function handleDeprecatedSize(data) {
-  if (data.size !== void 0) {
-    console.warn(
-      "[DEPRECATION] `size` is deprecated. Use `maxSize` instead. This will be removed in the next major version."
-    );
-    if (data.maxSize === void 0) {
-      data.maxSize = data.size;
-    }
-  }
-  const { size, ...rest } = data;
-  return rest;
-}
 var baseChunkOptionsSchema = zod.z.object({
-  size: zod.z.number().positive().optional(),
   maxSize: zod.z.number().positive().optional(),
   overlap: zod.z.number().min(0).optional(),
   lengthFunction: zod.z.function().optional(),
@@ -6214,15 +6202,15 @@ var semanticMarkdownChunkOptionsSchema = baseChunkOptionsSchema.extend({
 }).strict();
 var latexChunkOptionsSchema = baseChunkOptionsSchema.strict();
 var validationSchemas = {
-  character: characterChunkOptionsSchema.transform(handleDeprecatedSize),
-  recursive: recursiveChunkOptionsSchema.transform(handleDeprecatedSize),
-  sentence: sentenceChunkOptionsSchema.transform(handleDeprecatedSize),
-  token: tokenChunkOptionsSchema.transform(handleDeprecatedSize),
-  json: jsonChunkOptionsSchema.transform(handleDeprecatedSize),
-  html: htmlChunkOptionsSchema.transform(handleDeprecatedSize),
-  markdown: markdownChunkOptionsSchema.transform(handleDeprecatedSize),
-  "semantic-markdown": semanticMarkdownChunkOptionsSchema.transform(handleDeprecatedSize),
-  latex: latexChunkOptionsSchema.transform(handleDeprecatedSize)
+  character: characterChunkOptionsSchema,
+  recursive: recursiveChunkOptionsSchema,
+  sentence: sentenceChunkOptionsSchema,
+  token: tokenChunkOptionsSchema,
+  json: jsonChunkOptionsSchema,
+  html: htmlChunkOptionsSchema,
+  markdown: markdownChunkOptionsSchema,
+  "semantic-markdown": semanticMarkdownChunkOptionsSchema,
+  latex: latexChunkOptionsSchema
 };
 function validateChunkParams(strategy, params) {
   const schema = validationSchemas[strategy];
@@ -6538,6 +6526,7 @@ var MastraAgentRelevanceScorer = class {
   agent;
   constructor(name14, model) {
     this.agent = new agent.Agent({
+      id: `relevance-scorer-${name14}`,
       name: `Relevance Scorer ${name14}`,
       instructions: `You are a specialized agent for evaluating the relevance of text to queries.
 Your task is to rate how well a text passage answers a given query.
@@ -7057,26 +7046,26 @@ var convertToSources = (results) => {
   return results.map((result) => {
     if ("content" in result) {
       return {
-        id: result.id,
+        id: result.id || "",
         vector: result.embedding || [],
-        score: result.score,
+        score: result.score || 0,
         metadata: result.metadata,
         document: result.content || ""
       };
     }
     if ("result" in result) {
       return {
-        id: result.result.id,
+        id: result.result.id || "",
         vector: result.result.vector || [],
-        score: result.score,
+        score: result.score || 0,
         metadata: result.result.metadata,
         document: result.result.document || ""
       };
     }
     return {
-      id: result.id,
+      id: result.id || "",
       vector: result.vector || [],
-      score: result.score,
+      score: result.score || 0,
       metadata: result.metadata,
       document: result.document || ""
     };
@@ -7108,19 +7097,20 @@ var createGraphRAGTool = (options) => {
     inputSchema,
     outputSchema,
     description: toolDescription,
-    execute: async ({ context, mastra, runtimeContext }) => {
-      const indexName = runtimeContext.get("indexName") ?? options.indexName;
-      const vectorStoreName = runtimeContext.get("vectorStoreName") ?? options.vectorStoreName;
+    execute: async (inputData, context) => {
+      const { requestContext, mastra } = context || {};
+      const indexName = requestContext?.get("indexName") ?? options.indexName;
+      const vectorStoreName = requestContext?.get("vectorStoreName") ?? options.vectorStoreName;
       if (!indexName) throw new Error(`indexName is required, got: ${indexName}`);
       if (!vectorStoreName) throw new Error(`vectorStoreName is required, got: ${vectorStoreName}`);
-      const includeSources = runtimeContext.get("includeSources") ?? options.includeSources ?? true;
-      const randomWalkSteps = runtimeContext.get("randomWalkSteps") ?? graphOptions.randomWalkSteps;
-      const restartProb = runtimeContext.get("restartProb") ?? graphOptions.restartProb;
-      const topK = runtimeContext.get("topK") ?? context.topK ?? 10;
-      const filter = runtimeContext.get("filter") ?? context.filter;
-      const queryText = context.queryText;
-      const providerOptions = runtimeContext.get("providerOptions") ?? options.providerOptions;
-      const enableFilter = !!runtimeContext.get("filter") || (options.enableFilter ?? false);
+      const includeSources = requestContext?.get("includeSources") ?? options.includeSources ?? true;
+      const randomWalkSteps = requestContext?.get("randomWalkSteps") ?? graphOptions.randomWalkSteps;
+      const restartProb = requestContext?.get("restartProb") ?? graphOptions.restartProb;
+      const topK = requestContext?.get("topK") ?? inputData.topK ?? 10;
+      const filter = requestContext?.get("filter") ?? inputData.filter;
+      const queryText = inputData.queryText;
+      const providerOptions = requestContext?.get("providerOptions") ?? options.providerOptions;
+      const enableFilter = !!requestContext?.get("filter") || (options.enableFilter ?? false);
       const logger = mastra?.getLogger();
       if (!logger) {
         console.warn(
@@ -7227,21 +7217,22 @@ var createVectorQueryTool = (options) => {
     description: toolDescription,
     inputSchema,
     outputSchema,
-    execute: async ({ context, mastra, runtimeContext }) => {
-      const indexName = runtimeContext.get("indexName") ?? options.indexName;
-      const vectorStoreName = "vectorStore" in options ? storeName : runtimeContext.get("vectorStoreName") ?? storeName;
-      const includeVectors = runtimeContext.get("includeVectors") ?? options.includeVectors ?? false;
-      const includeSources = runtimeContext.get("includeSources") ?? options.includeSources ?? true;
-      const reranker = runtimeContext.get("reranker") ?? options.reranker;
-      const databaseConfig = runtimeContext.get("databaseConfig") ?? options.databaseConfig;
-      const model = runtimeContext.get("model") ?? options.model;
-      const providerOptions = runtimeContext.get("providerOptions") ?? options.providerOptions;
+    execute: async (inputData, context) => {
+      const { requestContext, mastra } = context || {};
+      const indexName = requestContext?.get("indexName") ?? options.indexName;
+      const vectorStoreName = "vectorStore" in options ? storeName : requestContext?.get("vectorStoreName") ?? storeName;
+      const includeVectors = requestContext?.get("includeVectors") ?? options.includeVectors ?? false;
+      const includeSources = requestContext?.get("includeSources") ?? options.includeSources ?? true;
+      const reranker = requestContext?.get("reranker") ?? options.reranker;
+      const databaseConfig = requestContext?.get("databaseConfig") ?? options.databaseConfig;
+      const model = requestContext?.get("model") ?? options.model;
+      const providerOptions = requestContext?.get("providerOptions") ?? options.providerOptions;
       if (!indexName) throw new Error(`indexName is required, got: ${indexName}`);
       if (!vectorStoreName) throw new Error(`vectorStoreName is required, got: ${vectorStoreName}`);
-      const topK = runtimeContext.get("topK") ?? context.topK ?? 10;
-      const filter = runtimeContext.get("filter") ?? context.filter;
-      const queryText = context.queryText;
-      const enableFilter = !!runtimeContext.get("filter") || (options.enableFilter ?? false);
+      const topK = requestContext?.get("topK") ?? inputData.topK ?? 10;
+      const filter = requestContext?.get("filter") ?? inputData.filter;
+      const queryText = inputData.queryText;
+      const enableFilter = !!requestContext?.get("filter") || (options.enableFilter ?? false);
       const logger = mastra?.getLogger();
       if (!logger) {
         console.warn(
@@ -7350,823 +7341,11 @@ var createVectorQueryTool = (options) => {
   });
 };
 
-// src/utils/vector-prompts.ts
-var ASTRA_PROMPT = `When querying Astra, you can ONLY use the operators listed below. Any other operators will be rejected.
-Important: Don't explain how to construct the filter - use the specified operators and fields to search the content and return relevant results.
-If a user tries to give an explicit operator that is not supported, reject the filter entirely and let them know that the operator is not supported.
-
-Basic Comparison Operators:
-- $eq: Exact match (default when using field: value)
-  Example: { "category": "electronics" }
-- $ne: Not equal
-  Example: { "category": { "$ne": "electronics" } }
-- $gt: Greater than
-  Example: { "price": { "$gt": 100 } }
-- $gte: Greater than or equal
-  Example: { "price": { "$gte": 100 } }
-- $lt: Less than
-  Example: { "price": { "$lt": 100 } }
-- $lte: Less than or equal
-  Example: { "price": { "$lte": 100 } }
-
-Array Operators:
-- $in: Match any value in array
-  Example: { "category": { "$in": ["electronics", "books"] } }
-- $nin: Does not match any value in array
-  Example: { "category": { "$nin": ["electronics", "books"] } }
-- $all: Match all values in array
-  Example: { "tags": { "$all": ["premium", "sale"] } }
-
-Logical Operators:
-- $and: Logical AND (can be implicit or explicit)
-  Implicit Example: { "price": { "$gt": 100 }, "category": "electronics" }
-  Explicit Example: { "$and": [{ "price": { "$gt": 100 } }, { "category": "electronics" }] }
-- $or: Logical OR
-  Example: { "$or": [{ "price": { "$lt": 50 } }, { "category": "books" }] }
-- $not: Logical NOT
-  Example: { "$not": { "category": "electronics" } }
-
-Element Operators:
-- $exists: Check if field exists
-  Example: { "rating": { "$exists": true } }
-
-Special Operators:
-- $size: Array length check
-  Example: { "tags": { "$size": 2 } }
-
-Restrictions:
-- Regex patterns are not supported
-- Only $and, $or, and $not logical operators are supported
-- Nested fields are supported using dot notation
-- Multiple conditions on the same field are supported with both implicit and explicit $and
-- Empty arrays in $in/$nin will return no results
-- A non-empty array is required for $all operator
-- Only logical operators ($and, $or, $not) can be used at the top level
-- All other operators must be used within a field condition
-  Valid: { "field": { "$gt": 100 } }
-  Valid: { "$and": [...] }
-  Invalid: { "$gt": 100 }
-- Logical operators must contain field conditions, not direct operators
-  Valid: { "$and": [{ "field": { "$gt": 100 } }] }
-  Invalid: { "$and": [{ "$gt": 100 }] }
-- $not operator:
-  - Must be an object
-  - Cannot be empty
-  - Can be used at field level or top level
-  - Valid: { "$not": { "field": "value" } }
-  - Valid: { "field": { "$not": { "$eq": "value" } } }
-- Other logical operators ($and, $or):
-  - Can only be used at top level or nested within other logical operators
-  - Can not be used on a field level, or be nested inside a field
-  - Can not be used inside an operator
-  - Valid: { "$and": [{ "field": { "$gt": 100 } }] }
-  - Valid: { "$or": [{ "$and": [{ "field": { "$gt": 100 } }] }] }
-  - Invalid: { "field": { "$and": [{ "$gt": 100 }] } }
-  - Invalid: { "field": { "$or": [{ "$gt": 100 }] } }
-  - Invalid: { "field": { "$gt": { "$and": [{...}] } } }
-
-Example Complex Query:
-{
-  "$and": [
-    { "category": { "$in": ["electronics", "computers"] } },
-    { "price": { "$gte": 100, "$lte": 1000 } },
-    { "tags": { "$all": ["premium"] } },
-    { "rating": { "$exists": true, "$gt": 4 } },
-    { "$or": [
-      { "stock": { "$gt": 0 } },
-      { "preorder": true }
-    ]}
-  ]
-}`;
-var CHROMA_PROMPT = `When querying Chroma, 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.
-
-Basic Comparison Operators:
-- $eq: Exact match (default when using field: value)
-  Example: { "category": "electronics" }
-- $ne: Not equal
-  Example: { "category": { "$ne": "electronics" } }
-- $gt: Greater than
-  Example: { "price": { "$gt": 100 } }
-- $gte: Greater than or equal
-  Example: { "price": { "$gte": 100 } }
-- $lt: Less than
-  Example: { "price": { "$lt": 100 } }
-- $lte: Less than or equal
-  Example: { "price": { "$lte": 100 } }
-
-Array Operators:
-- $in: Match any value in array
-  Example: { "category": { "$in": ["electronics", "books"] } }
-- $nin: Does not match any value in array
-  Example: { "category": { "$nin": ["electronics", "books"] } }
-
-Logical Operators:
-- $and: Logical AND
-  Example: { "$and": [{ "price": { "$gt": 100 } }, { "category": "electronics" }] }
-- $or: Logical OR
-  Example: { "$or": [{ "price": { "$lt": 50 } }, { "category": "books" }] }
-
-Restrictions:
-- Regex patterns are not supported
-- Element operators are not supported
-- Only $and and $or logical operators are supported
-- Nested fields are supported using dot notation
-- Multiple conditions on the same field are supported with both implicit and explicit $and
-- Empty arrays in $in/$nin will return no results
-- If multiple top-level fields exist, they're wrapped in $and
-- Only logical operators ($and, $or) can be used at the top level
-- All other operators must be used within a field condition
-  Valid: { "field": { "$gt": 100 } }
-  Valid: { "$and": [...] }
-  Invalid: { "$gt": 100 }
-  Invalid: { "$in": [...] }
-- Logical operators must contain field conditions, not direct operators
-  Valid: { "$and": [{ "field": { "$gt": 100 } }] }
-  Invalid: { "$and": [{ "$gt": 100 }] }
-- Logical operators ($and, $or):
-  - Can only be used at top level or nested within other logical operators
-  - Can not be used on a field level, or be nested inside a field
-  - Can not be used inside an operator
-  - Valid: { "$and": [{ "field": { "$gt": 100 } }] }
-  - Valid: { "$or": [{ "$and": [{ "field": { "$gt": 100 } }] }] }
-  - Invalid: { "field": { "$and": [{ "$gt": 100 }] } }
-  - Invalid: { "field": { "$or": [{ "$gt": 100 }] } }
-  - Invalid: { "field": { "$gt": { "$and": [{...}] } } }
-Example Complex Query:
-{
-  "$and": [
-    { "category": { "$in": ["electronics", "computers"] } },
-    { "price": { "$gte": 100, "$lte": 1000 } },
-    { "$or": [
-      { "inStock": true },
-      { "preorder": true }
-    ]}
-  ]
-}`;
-var LIBSQL_PROMPT = `When querying LibSQL Vector, 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.
-
-Basic Comparison Operators:
-- $eq: Exact match (default when using field: value)
-  Example: { "category": "electronics" }
-- $ne: Not equal
-  Example: { "category": { "$ne": "electronics" } }
-- $gt: Greater than
-  Example: { "price": { "$gt": 100 } }
-- $gte: Greater than or equal
-  Example: { "price": { "$gte": 100 } }
-- $lt: Less than
-  Example: { "price": { "$lt": 100 } }
-- $lte: Less than or equal
-  Example: { "price": { "$lte": 100 } }
-
-Array Operators:
-- $in: Match any value in array
-  Example: { "category": { "$in": ["electronics", "books"] } }
-- $nin: Does not match any value in array
-  Example: { "category": { "$nin": ["electronics", "books"] } }
-- $all: Match all values in array
-  Example: { "tags": { "$all": ["premium", "sale"] } }
-- $elemMatch: Match array elements that meet all specified conditions
-  Example: { "items": { "$elemMatch": { "price": { "$gt": 100 } } } }
-- $contains: Check if array contains value
-  Example: { "tags": { "$contains": "premium" } }
-
-Logical Operators:
-- $and: Logical AND (implicit when using multiple conditions)
-  Example: { "$and": [{ "price": { "$gt": 100 } }, { "category": "electronics" }] }
-- $or: Logical OR
-  Example: { "$or": [{ "price": { "$lt": 50 } }, { "category": "books" }] }
-- $not: Logical NOT
-  Example: { "$not": { "category": "electronics" } }
-- $nor: Logical NOR
-  Example: { "$nor": [{ "price": { "$lt": 50 } }, { "category": "books" }] }
-
-Element Operators:
-- $exists: Check if field exists
-  Example: { "rating": { "$exists": true } }
-
-Special Operators:
-- $size: Array length check
-  Example: { "tags": { "$size": 2 } }
-
-Restrictions:
-- Regex patterns are not supported
-- Direct RegExp patterns will throw an error
-- Nested fields are supported using dot notation
-- Multiple conditions on the same field are supported with both implicit and explicit $and
-- Array operations work on array fields only
-- Basic operators handle array values as JSON strings
-- Empty arrays in conditions are handled gracefully
-- Only logical operators ($and, $or, $not, $nor) can be used at the top level
-- All other operators must be used within a field condition
-  Valid: { "field": { "$gt": 100 } }
-  Valid: { "$and": [...] }
-  Invalid: { "$gt": 100 }
-  Invalid: { "$contains": "value" }
-- Logical operators must contain field conditions, not direct operators
-  Valid: { "$and": [{ "field": { "$gt": 100 } }] }
-  Invalid: { "$and": [{ "$gt": 100 }] }
-- $not operator:
-  - Must be an object
-  - Cannot be empty
-  - Can be used at field level or top level
-  - Valid: { "$not": { "field": "value" } }
-  - Valid: { "field": { "$not": { "$eq": "value" } } }
-- Other logical operators ($and, $or, $nor):
-  - Can only be used at top level or nested within other logical operators
-  - Can not be used on a field level, or be nested inside a field
-  - Can not be used inside an operator
-  - Valid: { "$and": [{ "field": { "$gt": 100 } }] }
-  - Valid: { "$or": [{ "$and": [{ "field": { "$gt": 100 } }] }] }
-  - Invalid: { "field": { "$and": [{ "$gt": 100 }] } }
-  - Invalid: { "field": { "$or": [{ "$gt": 100 }] } }
-  - Invalid: { "field": { "$gt": { "$and": [{...}] } } }
-- $elemMatch requires an object with conditions
-  Valid: { "array": { "$elemMatch": { "field": "value" } } }
-  Invalid: { "array": { "$elemMatch": "value" } }
-
-Example Complex Query:
-{
-  "$and": [
-    { "category": { "$in": ["electronics", "computers"] } },
-    { "price": { "$gte": 100, "$lte": 1000 } },
-    { "tags": { "$all": ["premium", "sale"] } },
-    { "items": { "$elemMatch": { "price": { "$gt": 50 }, "inStock": true } } },
-    { "$or": [
-      { "stock": { "$gt": 0 } },
-      { "preorder": true }
-    ]}
-  ]
-}`;
-var PGVECTOR_PROMPT = `When querying PG Vector, 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.
-
-Basic Comparison Operators:
-- $eq: Exact match (default when using field: value)
-  Example: { "category": "electronics" }
-- $ne: Not equal
-  Example: { "category": { "$ne": "electronics" } }
-- $gt: Greater than
-  Example: { "price": { "$gt": 100 } }
-- $gte: Greater than or equal
-  Example: { "price": { "$gte": 100 } }
-- $lt: Less than
-  Example: { "price": { "$lt": 100 } }
-- $lte: Less than or equal
-  Example: { "price": { "$lte": 100 } }
-
-Array Operators:
-- $in: Match any value in array
-  Example: { "category": { "$in": ["electronics", "books"] } }
-- $nin: Does not match any value in array
-  Example: { "category": { "$nin": ["electronics", "books"] } }
-- $all: Match all values in array
-  Example: { "tags": { "$all": ["premium", "sale"] } }
-- $elemMatch: Match array elements that meet all specified conditions
-  Example: { "items": { "$elemMatch": { "price": { "$gt": 100 } } } }
-- $contains: Check if array contains value
-  Example: { "tags": { "$contains": "premium" } }
-
-Logical Operators:
-- $and: Logical AND
-  Example: { "$and": [{ "price": { "$gt": 100 } }, { "category": "electronics" }] }
-- $or: Logical OR
-  Example: { "$or": [{ "price": { "$lt": 50 } }, { "category": "books" }] }
-- $not: Logical NOT
-  Example: { "$not": { "category": "electronics" } }
-- $nor: Logical NOR
-  Example: { "$nor": [{ "price": { "$lt": 50 } }, { "category": "books" }] }
-
-Element Operators:
-- $exists: Check if field exists
-  Example: { "rating": { "$exists": true } }
-
-Special Operators:
-- $size: Array length check
-  Example: { "tags": { "$size": 2 } }
-- $regex: Pattern matching (PostgreSQL regex syntax)
-  Example: { "name": { "$regex": "^iphone" } }
-- $options: Regex options (used with $regex)
-  Example: { "name": { "$regex": "iphone", "$options": "i" } }
-
-Restrictions:
-- Direct RegExp patterns are supported
-- Nested fields are supported using dot notation
-- Multiple conditions on the same field are supported with both implicit and explicit $and
-- Array operations work on array fields only
-- Regex patterns must follow PostgreSQL syntax
-- Empty arrays in conditions are handled gracefully
-- Only logical operators ($and, $or, $not, $nor) can be used at the top level
-- All other operators must be used within a field condition
-  Valid: { "field": { "$gt": 100 } }
-  Valid: { "$and": [...] }
-  Invalid: { "$gt": 100 }
-  Invalid: { "$regex": "pattern" }
-- Logical operators must contain field conditions, not direct operators
-  Valid: { "$and": [{ "field": { "$gt": 100 } }] }
-  Invalid: { "$and": [{ "$gt": 100 }] }
-- $not operator:
-  - Must be an object
-  - Cannot be empty
-  - Can be used at field level or top level
-  - Valid: { "$not": { "field": "value" } }
-  - Valid: { "field": { "$not": { "$eq": "value" } } }
-- Other logical operators ($and, $or, $nor):
-  - Can only be used at top level or nested within other logical operators
-  - Can not be used on a field level, or be nested inside a field
-  - Can not be used inside an operator
-  - Valid: { "$and": [{ "field": { "$gt": 100 } }] }
-  - Valid: { "$or": [{ "$and": [{ "field": { "$gt": 100 } }] }] }
-  - Invalid: { "field": { "$and": [{ "$gt": 100 }] } }
-  - Invalid: { "field": { "$or": [{ "$gt": 100 }] } }
-  - Invalid: { "field": { "$gt": { "$and": [{...}] } } }
-- $elemMatch requires an object with conditions
-  Valid: { "array": { "$elemMatch": { "field": "value" } } }
-  Invalid: { "array": { "$elemMatch": "value" } }
-
-Example Complex Query:
-{
-  "$and": [
-    { "category": { "$in": ["electronics", "computers"] } },
-    { "price": { "$gte": 100, "$lte": 1000 } },
-    { "tags": { "$all": ["premium", "sale"] } },
-    { "items": { "$elemMatch": { "price": { "$gt": 50 }, "inStock": true } } },
-    { "$or": [
-      { "name": { "$regex": "^iphone", "$options": "i" } },
-      { "description": { "$regex": ".*apple.*" } }
-    ]}
-  ]
-}`;
-var 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.
-
-Basic Comparison Operators:
-- $eq: Exact match (default when using field: value)
-  Example: { "category": "electronics" }
-- $ne: Not equal
-  Example: { "category": { "$ne": "electronics" } }
-- $gt: Greater than
-  Example: { "price": { "$gt": 100 } }
-- $gte: Greater than or equal
-  Example: { "price": { "$gte": 100 } }
-- $lt: Less than
-  Example: { "price": { "$lt": 100 } }
-- $lte: Less than or equal
-  Example: { "price": { "$lte": 100 } }
-
-Array Operators:
-- $in: Match any value in array
-  Example: { "category": { "$in": ["electronics", "books"] } }
-- $nin: Does not match any value in array
-  Example: { "category": { "$nin": ["electronics", "books"] } }
-- $all: Match all values in array
-  Example: { "tags": { "$all": ["premium", "sale"] } }
-
-Logical Operators:
-- $and: Logical AND (can be implicit or explicit)
-  Implicit Example: { "price": { "$gt": 100 }, "category": "electronics" }
-  Explicit Example: { "$and": [{ "price": { "$gt": 100 } }, { "category": "electronics" }] }
-- $or: Logical OR
-  Example: { "$or": [{ "price": { "$lt": 50 } }, { "category": "books" }] }
-
-Element Operators:
-- $exists: Check if field exists
-  Example: { "rating": { "$exists": true } }
-
-Restrictions:
-- Regex patterns are not supported
-- Only $and and $or logical operators are supported at the top level
-- Empty arrays in $in/$nin will return no results
-- A non-empty array is required for $all operator
-- Nested fields are supported using dot notation
-- Multiple conditions on the same field are supported with both implicit and explicit $and
-- At least one key-value pair is required in filter object
-- Empty objects and undefined values are treated as no filter
-- Invalid types in comparison operators will throw errors
-- All non-logical operators must be used within a field condition
-  Valid: { "field": { "$gt": 100 } }
-  Valid: { "$and": [...] }
-  Invalid: { "$gt": 100 }
-- Logical operators must contain field conditions, not direct operators
-  Valid: { "$and": [{ "field": { "$gt": 100 } }] }
-  Invalid: { "$and": [{ "$gt": 100 }] }
-- Logical operators ($and, $or):
-  - Can only be used at top level or nested within other logical operators
-  - Can not be used on a field level, or be nested inside a field
-  - Can not be used inside an operator
-  - Valid: { "$and": [{ "field": { "$gt": 100 } }] }
-  - Valid: { "$or": [{ "$and": [{ "field": { "$gt": 100 } }] }] }
-  - Invalid: { "field": { "$and": [{ "$gt": 100 }] } }
-  - Invalid: { "field": { "$or": [{ "$gt": 100 }] } }
-  - Invalid: { "field": { "$gt": { "$and": [{...}] } } }
-Example Complex Query:
-{
-  "$and": [
-    { "category": { "$in": ["electronics", "computers"] } },
-    { "price": { "$gte": 100, "$lte": 1000 } },
-    { "tags": { "$all": ["premium", "sale"] } },
-    { "rating": { "$exists": true, "$gt": 4 } },
-    { "$or": [
-      { "stock": { "$gt": 0 } },
-      { "preorder": true }
-    ]}
-  ]
-}`;
-var QDRANT_PROMPT = `When querying Qdrant, 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.
-
-Basic Comparison Operators:
-- $eq: Exact match (default when using field: value)
-  Example: { "category": "electronics" }
-- $ne: Not equal
-  Example: { "category": { "$ne": "electronics" } }
-- $gt: Greater than
-  Example: { "price": { "$gt": 100 } }
-- $gte: Greater than or equal
-  Example: { "price": { "$gte": 100 } }
-- $lt: Less than
-  Example: { "price": { "$lt": 100 } }
-- $lte: Less than or equal
-  Example: { "price": { "$lte": 100 } }
-
-Array Operators:
-- $in: Match any value in array
-  Example: { "category": { "$in": ["electronics", "books"] } }
-- $nin: Does not match any value in array
-  Example: { "category": { "$nin": ["electronics", "books"] } }
-
-Logical Operators:
-- $and: Logical AND (implicit when using multiple conditions)
-  Example: { "$and": [{ "price": { "$gt": 100 } }, { "category": "electronics" }] }
-- $or: Logical OR
-  Example: { "$or": [{ "price": { "$lt": 50 } }, { "category": "books" }] }
-- $not: Logical NOT
-  Example: { "$not": { "category": "electronics" } }
-
-Element Operators:
-- $exists: Check if field exists
-  Example: { "rating": { "$exists": true } }
-
-Special Operators:
-- $regex: Pattern matching
-  Example: { "name": { "$regex": "iphone.*" } }
-- $count: Array length/value count
-  Example: { "tags": { "$count": { "$gt": 2 } } }
-- $geo: Geographical filters (supports radius, box, polygon)
-  Example: {
-    "location": {
-      "$geo": {
-        "type": "radius",
-        "center": { "lat": 52.5, "lon": 13.4 },
-        "radius": 10000
-      }
-    }
-  }
-- $hasId: Match specific document IDs
-  Example: { "$hasId": ["doc1", "doc2"] }
-- $hasVector: Check vector existence
-  Example: { "$hasVector": "" }
-- $datetime: RFC 3339 datetime range
-  Example: {
-    "created_at": {
-      "$datetime": {
-        "range": {
-          "gt": "2024-01-01T00:00:00Z",
-          "lt": "2024-12-31T23:59:59Z"
-        }
-      }
-    }
-  }
-- $null: Check for null values
-  Example: { "field": { "$null": true } }
-- $empty: Check for empty values
-  Example: { "array": { "$empty": true } }
-- $nested: Nested object filters
-  Example: {
-    "items[]": {
-      "$nested": {
-        "price": { "$gt": 100 },
-        "stock": { "$gt": 0 }
-      }
-    }
-  }
-
-Restrictions:
-- Only logical operators ($and, $or, $not) and collection operators ($hasId, $hasVector) can be used at the top level
-- All other operators must be used within a field condition
-  Valid: { "field": { "$gt": 100 } }
-  Valid: { "$and": [...] }
-  Valid: { "$hasId": [...] }
-  Invalid: { "$gt": 100 }
-- Nested fields are supported using dot notation
-- Array fields with nested objects use [] suffix: "items[]"
-- Geo filtering requires specific format for radius, box, or polygon
-- Datetime values must be in RFC 3339 format
-- Empty arrays in conditions are handled as empty values
-- Null values are handled with $null operator
-- Empty values are handled with $empty operator
-- $regex uses standard regex syntax
-- $count can only be used with numeric comparison operators
-- $nested requires an object with conditions
-- Logical operators must contain field conditions, not direct operators
-  Valid: { "$and": [{ "field": { "$gt": 100 } }] }
-  Invalid: { "$and": [{ "$gt": 100 }] }
-- $not operator:
-  - Must be an object
-  - Cannot be empty
-  - Can be used at field level or top level
-  - Valid: { "$not": { "field": "value" } }
-  - Valid: { "field": { "$not": { "$eq": "value" } } }
-- Other logical operators ($and, $or):
-  - Can only be used at top level or nested within other logical operators
-  - Can not be used on a field level, or be nested inside a field
-  - Can not be used inside an operator
-  - Valid: { "$and": [{ "field": { "$gt": 100 } }] }
-  - Valid: { "$or": [{ "$and": [{ "field": { "$gt": 100 } }] }] }
-  - Invalid: { "field": { "$and": [{ "$gt": 100 }] } }
-  - Invalid: { "field": { "$or": [{ "$gt": 100 }] } }
-  - Invalid: { "field": { "$gt": { "$and": [{...}] } } }
-Example Complex Query:
-{
-  "$and": [
-    { "category": { "$in": ["electronics"] } },
-    { "price": { "$gt": 100 } },
-    { "location": {
-      "$geo": {
-        "type": "radius",
-        "center": { "lat": 52.5, "lon": 13.4 },
-        "radius": 5000
-      }
-    }},
-    { "items[]": {
-      "$nested": {
-        "price": { "$gt": 50 },
-        "stock": { "$gt": 0 }
-      }
-    }},
-    { "created_at": {
-      "$datetime": {
-        "range": {
-          "gt": "2024-01-01T00:00:00Z"
-        }
-      }
-    }},
-    { "$or": [
-      { "status": { "$ne": "discontinued" } },
-      { "clearance": true }
-    ]}
-  ]
-}`;
-var UPSTASH_PROMPT = `When querying Upstash Vector, 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.
-
-Basic Comparison Operators:
-- $eq: Exact match (default when using field: value)
-  Example: { "category": "electronics" } or { "category": { "$eq": "electronics" } }
-- $ne: Not equal
-  Example: { "category": { "$ne": "electronics" } }
-- $gt: Greater than
-  Example: { "price": { "$gt": 100 } }
-- $gte: Greater than or equal
-  Example: { "price": { "$gte": 100 } }
-- $lt: Less than
-  Example: { "price": { "$lt": 100 } }
-- $lte: Less than or equal
-  Example: { "price": { "$lte": 100 } }
-
-Array Operators:
-- $in: Match any value in array
-  Example: { "category": { "$in": ["electronics", "books"] } }
-- $nin: Does not match any value in array
-  Example: { "category": { "$nin": ["electronics", "books"] } }
-- $all: Matches all values in array
-  Example: { "tags": { "$all": ["premium", "new"] } }
-
-Logical Operators:
-- $and: Logical AND (implicit when using multiple conditions)
-  Example: { "$and": [{ "price": { "$gt": 100 } }, { "category": "electronics" }] }
-- $or: Logical OR
-  Example: { "$or": [{ "price": { "$lt": 50 } }, { "category": "books" }] }
-- $not: Logical NOT
-  Example: { "$not": { "category": "electronics" } }
-- $nor: Logical NOR
-  Example: { "$nor": [{ "price": { "$lt": 50 } }, { "category": "books" }] }
-
-Element Operators:
-- $exists: Check if field exists
-  Example: { "rating": { "$exists": true } }
-
-Special Operators:
-- $regex: Pattern matching using glob syntax (only as operator, not direct RegExp)
-  Example: { "name": { "$regex": "iphone*" } }
-- $contains: Check if array/string contains value
-  Example: { "tags": { "$contains": "premium" } }
-
-Restrictions:
-- Null/undefined values are not supported in any operator
-- Empty arrays are only supported in $in/$nin operators
-- Direct RegExp patterns are not supported, use $regex with glob syntax
-- Nested fields are supported using dot notation
-- Multiple conditions on same field are combined with AND
-- String values with quotes are automatically escaped
-- Only logical operators ($and, $or, $not, $nor) can be used at the top level
-- All other operators must be used within a field condition
-  Valid: { "field": { "$gt": 100 } }
-  Valid: { "$and": [...] }
-  Invalid: { "$gt": 100 }
-- $regex uses glob syntax (*, ?) not standard regex patterns
-- $contains works on both arrays and string fields
-- Logical operators must contain field conditions, not direct operators
-  Valid: { "$and": [{ "field": { "$gt": 100 } }] }
-  Invalid: { "$and": [{ "$gt": 100 }] }
-- $not operator:
-  - Must be an object
-  - Cannot be empty
-  - Can be used at field level or top level
-  - Valid: { "$not": { "field": "value" } }
-  - Valid: { "field": { "$not": { "$eq": "value" } } }
-- Other logical operators ($and, $or, $nor):
-  - Can only be used at top level or nested within other logical operators
-  - Can not be used on a field level, or be nested inside a field
-  - Can not be used inside an operator
-  - Valid: { "$and": [{ "field": { "$gt": 100 } }] }
-  - Valid: { "$or": [{ "$and": [{ "field": { "$gt": 100 } }] }] }
-  - Invalid: { "field": { "$and": [{ "$gt": 100 }] } }
-  - Invalid: { "field": { "$or": [{ "$gt": 100 }] } }
-  - Invalid: { "field": { "$gt": { "$and": [{...}] } } }
-Example Complex Query:
-{
-  "$and": [
-    { "category": { "$in": ["electronics", "computers"] } },
-    { "price": { "$gt": 100, "$lt": 1000 } },
-    { "tags": { "$all": ["premium", "new"] } },
-    { "name": { "$regex": "iphone*" } },
-    { "description": { "$contains": "latest" } },
-    { "$or": [
-      { "brand": "Apple" },
-      { "rating": { "$gte": 4.5 } }
-    ]}
-  ]
-}`;
-var VECTORIZE_PROMPT = `When querying Vectorize, you can ONLY use the operators listed below. Any other operators will be rejected.
-Important: Don't explain how to construct the filter - use the specified operators and fields to search the content and return relevant results.
-If a user tries to give an explicit operator that is not supported, reject the filter entirely and let them know that the operator is not supported.
-
-Basic Comparison Operators:
-- $eq: Exact match (default when using field: value)
-  Example: { "category": "electronics" }
-- $ne: Not equal
-  Example: { "category": { "$ne": "electronics" } }
-- $gt: Greater than
-  Example: { "price": { "$gt": 100 } }
-- $gte: Greater than or equal
-  Example: { "price": { "$gte": 100 } }
-- $lt: Less than
-  Example: { "price": { "$lt": 100 } }
-- $lte: Less than or equal
-  Example: { "price": { "$lte": 100 } }
-
-Array Operators:
-- $in: Match any value in array
-  Example: { "category": { "$in": ["electronics", "books"] } }
-- $nin: Does not match any value in array
-  Example: { "category": { "$nin": ["electronics", "books"] } }
-
-Restrictions:
-- Regex patterns are not supported
-- Logical operators are not supported
-- Element operators are not supported
-- Fields must have a flat structure, as nested fields are not supported
-- Multiple conditions on the same field are supported
-- Empty arrays in $in/$nin will return no results
-- Filter keys cannot be longer than 512 characters
-- Filter keys cannot contain invalid characters ($, ", empty)
-- Filter size is limited to prevent oversized queries
-- Invalid types in operators return no results instead of throwing errors
-- Empty objects are accepted in filters
-- Metadata must use flat structure with dot notation (no nested objects)
-- Must explicitly create metadata indexes for filterable fields (limit 10 per index)
-- Can only effectively filter on indexed metadata fields
-- Metadata values can be strings, numbers, booleans, or homogeneous arrays
-- No operators can be used at the top level (no logical operators supported)
-- All operators must be used within a field condition
-  Valid: { "field": { "$gt": 100 } }
-  Invalid: { "$gt": 100 }
-  Invalid: { "$in": [...] }
-
-Example Complex Query:
-{
-  "category": { "$in": ["electronics", "computers"] },
-  "price": { "$gte": 100, "$lte": 1000 },
-  "inStock": true
-}`;
-var MONGODB_PROMPT = `When querying MongoDB, 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.
-
-Basic Comparison Operators:
-- $eq: Exact match (default when using field: value)
-  Example: { "category": "electronics" }
-- $ne: Not equal
-  Example: { "category": { "$ne": "electronics" } }
-- $gt: Greater than
-  Example: { "price": { "$gt": 100 } }
-- $gte: Greater than or equal
-  Example: { "price": { "$gte": 100 } }
-- $lt: Less than
-  Example: { "price": { "$lt": 100 } }
-- $lte: Less than or equal
-  Example: { "price": { "$lte": 100 } }
-
-Array Operators:
-- $in: Match any value in array
-  Example: { "category": { "$in": ["electronics", "books"] } }
-- $nin: Does not match any value in array
-  Example: { "category": { "$nin": ["electronics", "books"] } }
-- $all: Match all values in array
-  Example: { "tags": { "$all": ["premium", "sale"] } }
-- $elemMatch: Match array elements by criteria
-  Example: { "scores": { "$elemMatch": { "$gt": 80 } } }
-
-Logical Operators:
-- $and: Logical AND (can be implicit or explicit)
-  Implicit Example: { "price": { "$gt": 100 }, "category": "electronics" }
-  Explicit Example: { "$and": [{ "price": { "$gt": 100 } }, { "category": "electronics" }] }
-- $or: Logical OR
-  Example: { "$or": [{ "price": { "$lt": 50 } }, { "category": "books" }] }
-- $not: Logical NOT
-  Example: { "field": { "$not": { "$eq": "value" } } }
-- $nor: Logical NOR
-  Example: { "$nor": [{ "price": { "$lt": 50 } }, { "category": "books" }] }
-
-Element Operators:
-- $exists: Check if field exists
-  Example: { "rating": { "$exists": true } }
-
-Special Operators:
-- $regex: Regular expression match
-  Example: { "title": { "$regex": "^laptop", "$options": "i" } }
-- $size: Array length check
-  Example: { "tags": { "$size": 2 } }
-
-Usage Notes:
-- You can use both 'filter' (for metadata fields) and 'documentFilter' (for document content fields).
-- Nested fields are supported using dot notation (e.g., "metadata.author.name").
-- Multiple conditions on the same field are supported with both implicit and explicit $and.
-- Empty arrays in $in/$nin will return no results.
-- All logical operators ($and, $or, $not, $nor) can be used at the top level or nested.
-- All other operators must be used within a field condition.
-  Valid: { "field": { "$gt": 100 } }
-  Valid: { "$and": [...] }
-  Invalid: { "$gt": 100 }
-- $not operator:
-  - Must be an object
-  - Cannot be empty
-  - Can be used at field level or top level
-  - Valid: { "$not": { "field": "value" } }
-  - Valid: { "field": { "$not": { "$eq": "value" } } }
-- Logical operators must contain field conditions, not direct operators
-  Valid: { "$and": [{ "field": { "$gt": 100 } }] }
-  Invalid: { "$and": [{ "$gt": 100 }] }
-- Regex uses standard MongoDB regex syntax (with optional $options).
-- Metadata values can be strings, numbers, booleans, or arrays.
-- Metadata and document fields can be filtered in the same query.
-
-Example Complex Query:
-{
-  "category": { "$in": ["electronics", "computers"] },
-  "price": { "$gte": 100, "$lte": 1000 },
-  "inStock": true,
-  "title": { "$regex": "laptop", "$options": "i" },
-  "$or": [
-    { "brand": "Apple" },
-    { "rating": { "$gte": 4.5 } }
-  ]
-}
-`;
-
-exports.ASTRA_PROMPT = ASTRA_PROMPT;
-exports.CHROMA_PROMPT = CHROMA_PROMPT;
 exports.CohereRelevanceScorer = CohereRelevanceScorer;
 exports.GraphRAG = GraphRAG;
-exports.LIBSQL_PROMPT = LIBSQL_PROMPT;
 exports.Language = Language;
 exports.MDocument = MDocument;
-exports.MONGODB_PROMPT = MONGODB_PROMPT;
 exports.MastraAgentRelevanceScorer = MastraAgentRelevanceScorer;
-exports.PGVECTOR_PROMPT = PGVECTOR_PROMPT;
-exports.PINECONE_PROMPT = PINECONE_PROMPT;
-exports.QDRANT_PROMPT = QDRANT_PROMPT;
-exports.UPSTASH_PROMPT = UPSTASH_PROMPT;
-exports.VECTORIZE_PROMPT = VECTORIZE_PROMPT;
 exports.ZeroEntropyRelevanceScorer = ZeroEntropyRelevanceScorer;
 exports.createDocumentChunkerTool = createDocumentChunkerTool;
 exports.createGraphRAGTool = createGraphRAGTool;