@mastra/rag 0.10.1-alpha.0 → 0.10.1-alpha.1

package/dist/_tsup-dts-rollup.d.ts

@@ -6,8 +6,7 @@ import type { QueryResult } from '@mastra/core/vector';
 import type { QueryResult as QueryResult_2 } from '@mastra/core';
 import type { TiktokenEncoding } from 'js-tiktoken';
 import type { TiktokenModel } from 'js-tiktoken';
-import { Tool } from '@mastra/core/tools';
-import { ToolExecutionContext } from '@mastra/core';
+import type { Tool } from '@mastra/core/tools';
 import type { VectorFilter } from '@mastra/core/vector/filter';
 import { z } from 'zod';
 
@@ -77,6 +76,13 @@ export declare type BasePromptTemplateOptions<TemplatesVar extends readonly stri
     options?: Partial<Record<TemplatesVar[number] | (string & {}), string>>;
 };
 
+declare const baseSchema: {
+    queryText: z.ZodString;
+    topK: z.ZodNumber;
+};
+export { baseSchema }
+export { baseSchema as baseSchema_alias_1 }
+
 export declare class CharacterTransformer extends TextTransformer {
     protected separator: string;
     protected isSeparatorRegex: boolean;
@@ -182,125 +188,28 @@ declare const createGraphRAGTool: ({ vectorStoreName, indexName, model, enableFi
     };
     id?: string;
     description?: string;
-}) => Tool<z.ZodObject<{
-queryText: z.ZodString;
-topK: z.ZodNumber;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-queryText: z.ZodString;
-topK: z.ZodNumber;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-queryText: z.ZodString;
-topK: z.ZodNumber;
-}, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
-relevantContext: z.ZodAny;
-sources: z.ZodArray<z.ZodObject<{
-id: z.ZodString;
-metadata: z.ZodAny;
-vector: z.ZodArray<z.ZodNumber, "many">;
-score: z.ZodNumber;
-document: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-id: string;
-vector: number[];
-score: number;
-document: string;
-metadata?: any;
-}, {
-id: string;
-vector: number[];
-score: number;
-document: string;
-metadata?: any;
-}>, "many">;
+}) => RagTool<z.ZodObject<{
+    filter: z.ZodString;
+    queryText: z.ZodString;
+    topK: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
-sources: {
-id: string;
-vector: number[];
-score: number;
-document: string;
-metadata?: any;
-}[];
-relevantContext?: any;
+    filter: string;
+    topK: number;
+    queryText: string;
 }, {
-sources: {
-id: string;
-vector: number[];
-score: number;
-document: string;
-metadata?: any;
-}[];
-relevantContext?: any;
-}>, ToolExecutionContext<z.ZodObject<{
-queryText: z.ZodString;
-topK: z.ZodNumber;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-queryText: z.ZodString;
-topK: z.ZodNumber;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-queryText: z.ZodString;
-topK: z.ZodNumber;
-}, z.ZodTypeAny, "passthrough">>>> & {
-    inputSchema: z.ZodObject<{
-        queryText: z.ZodString;
-        topK: z.ZodNumber;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        queryText: z.ZodString;
-        topK: z.ZodNumber;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        queryText: z.ZodString;
-        topK: z.ZodNumber;
-    }, z.ZodTypeAny, "passthrough">>;
-    outputSchema: z.ZodObject<{
-        relevantContext: z.ZodAny;
-        sources: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            metadata: z.ZodAny;
-            vector: z.ZodArray<z.ZodNumber, "many">;
-            score: z.ZodNumber;
-            document: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            id: string;
-            vector: number[];
-            score: number;
-            document: string;
-            metadata?: any;
-        }, {
-            id: string;
-            vector: number[];
-            score: number;
-            document: string;
-            metadata?: any;
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        sources: {
-            id: string;
-            vector: number[];
-            score: number;
-            document: string;
-            metadata?: any;
-        }[];
-        relevantContext?: any;
-    }, {
-        sources: {
-            id: string;
-            vector: number[];
-            score: number;
-            document: string;
-            metadata?: any;
-        }[];
-        relevantContext?: any;
-    }>;
-    execute: (context: ToolExecutionContext<z.ZodObject<{
+    filter: string;
+    topK: number;
+    queryText: string;
+}> | z.ZodObject<{
     queryText: z.ZodString;
     topK: z.ZodNumber;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
     queryText: z.ZodString;
     topK: z.ZodNumber;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
     queryText: z.ZodString;
     topK: z.ZodNumber;
-    }, z.ZodTypeAny, "passthrough">>>) => Promise<any>;
-};
+}, z.ZodTypeAny, "passthrough">>, any>;
 export { createGraphRAGTool }
 export { createGraphRAGTool as createGraphRAGTool_alias_1 }
 export { createGraphRAGTool as createGraphRAGTool_alias_2 }
@@ -315,125 +224,28 @@ declare const createVectorQueryTool: ({ vectorStoreName, indexName, model, enabl
     reranker?: RerankConfig;
     id?: string;
     description?: string;
-}) => Tool<z.ZodObject<{
-queryText: z.ZodString;
-topK: z.ZodNumber;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-queryText: z.ZodString;
-topK: z.ZodNumber;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-queryText: z.ZodString;
-topK: z.ZodNumber;
-}, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
-relevantContext: z.ZodAny;
-sources: z.ZodArray<z.ZodObject<{
-id: z.ZodString;
-metadata: z.ZodAny;
-vector: z.ZodArray<z.ZodNumber, "many">;
-score: z.ZodNumber;
-document: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-id: string;
-vector: number[];
-score: number;
-document: string;
-metadata?: any;
-}, {
-id: string;
-vector: number[];
-score: number;
-document: string;
-metadata?: any;
-}>, "many">;
+}) => RagTool<z.ZodObject<{
+    filter: z.ZodString;
+    queryText: z.ZodString;
+    topK: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
-sources: {
-id: string;
-vector: number[];
-score: number;
-document: string;
-metadata?: any;
-}[];
-relevantContext?: any;
+    filter: string;
+    topK: number;
+    queryText: string;
 }, {
-sources: {
-id: string;
-vector: number[];
-score: number;
-document: string;
-metadata?: any;
-}[];
-relevantContext?: any;
-}>, ToolExecutionContext<z.ZodObject<{
-queryText: z.ZodString;
-topK: z.ZodNumber;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-queryText: z.ZodString;
-topK: z.ZodNumber;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-queryText: z.ZodString;
-topK: z.ZodNumber;
-}, z.ZodTypeAny, "passthrough">>>> & {
-    inputSchema: z.ZodObject<{
-        queryText: z.ZodString;
-        topK: z.ZodNumber;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        queryText: z.ZodString;
-        topK: z.ZodNumber;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        queryText: z.ZodString;
-        topK: z.ZodNumber;
-    }, z.ZodTypeAny, "passthrough">>;
-    outputSchema: z.ZodObject<{
-        relevantContext: z.ZodAny;
-        sources: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            metadata: z.ZodAny;
-            vector: z.ZodArray<z.ZodNumber, "many">;
-            score: z.ZodNumber;
-            document: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            id: string;
-            vector: number[];
-            score: number;
-            document: string;
-            metadata?: any;
-        }, {
-            id: string;
-            vector: number[];
-            score: number;
-            document: string;
-            metadata?: any;
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        sources: {
-            id: string;
-            vector: number[];
-            score: number;
-            document: string;
-            metadata?: any;
-        }[];
-        relevantContext?: any;
-    }, {
-        sources: {
-            id: string;
-            vector: number[];
-            score: number;
-            document: string;
-            metadata?: any;
-        }[];
-        relevantContext?: any;
-    }>;
-    execute: (context: ToolExecutionContext<z.ZodObject<{
+    filter: string;
+    topK: number;
+    queryText: string;
+}> | z.ZodObject<{
     queryText: z.ZodString;
     topK: z.ZodNumber;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
     queryText: z.ZodString;
     topK: z.ZodNumber;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
     queryText: z.ZodString;
     topK: z.ZodNumber;
-    }, z.ZodTypeAny, "passthrough">>>) => Promise<any>;
-};
+}, z.ZodTypeAny, "passthrough">>, any>;
 export { createVectorQueryTool }
 export { createVectorQueryTool as createVectorQueryTool_alias_1 }
 export { createVectorQueryTool as createVectorQueryTool_alias_2 }
@@ -516,6 +328,22 @@ export { filterDescription }
 export { filterDescription as filterDescription_alias_1 }
 export { filterDescription as filterDescription_alias_2 }
 
+declare const filterSchema: z.ZodObject<{
+    filter: z.ZodString;
+    queryText: z.ZodString;
+    topK: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    filter: string;
+    topK: number;
+    queryText: string;
+}, {
+    filter: string;
+    topK: number;
+    queryText: string;
+}>;
+export { filterSchema }
+export { filterSchema as filterSchema_alias_1 }
+
 /**
  * Formats a string by replacing placeholders with values from the provided parameters.
  * @param str The string to format.
@@ -798,6 +626,49 @@ declare enum ObjectType {
 export { ObjectType }
 export { ObjectType as ObjectType_alias_1 }
 
+declare const outputSchema: z.ZodObject<{
+    relevantContext: z.ZodAny;
+    sources: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        metadata: z.ZodAny;
+        vector: z.ZodArray<z.ZodNumber, "many">;
+        score: z.ZodNumber;
+        document: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        vector: number[];
+        score: number;
+        document: string;
+        metadata?: any;
+    }, {
+        id: string;
+        vector: number[];
+        score: number;
+        document: string;
+        metadata?: any;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    sources: {
+        id: string;
+        vector: number[];
+        score: number;
+        document: string;
+        metadata?: any;
+    }[];
+    relevantContext?: any;
+}, {
+    sources: {
+        id: string;
+        vector: number[];
+        score: number;
+        document: string;
+        metadata?: any;
+    }[];
+    relevantContext?: any;
+}>;
+export { outputSchema }
+export { outputSchema as outputSchema_alias_1 }
+
 /** @deprecated Import from @mastra/pg instead */
 declare const PGVECTOR_PROMPT = "When querying PG Vector, you can ONLY use the operators listed below. Any other operators will be rejected.\nImportant: Don't explain how to construct the filter - use the specified operators and fields to search the content and return relevant results.\nIf 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.\n\nBasic Comparison Operators:\n- $eq: Exact match (default when using field: value)\n  Example: { \"category\": \"electronics\" }\n- $ne: Not equal\n  Example: { \"category\": { \"$ne\": \"electronics\" } }\n- $gt: Greater than\n  Example: { \"price\": { \"$gt\": 100 } }\n- $gte: Greater than or equal\n  Example: { \"price\": { \"$gte\": 100 } }\n- $lt: Less than\n  Example: { \"price\": { \"$lt\": 100 } }\n- $lte: Less than or equal\n  Example: { \"price\": { \"$lte\": 100 } }\n\nArray Operators:\n- $in: Match any value in array\n  Example: { \"category\": { \"$in\": [\"electronics\", \"books\"] } }\n- $nin: Does not match any value in array\n  Example: { \"category\": { \"$nin\": [\"electronics\", \"books\"] } }\n- $all: Match all values in array\n  Example: { \"tags\": { \"$all\": [\"premium\", \"sale\"] } }\n- $elemMatch: Match array elements that meet all specified conditions\n  Example: { \"items\": { \"$elemMatch\": { \"price\": { \"$gt\": 100 } } } }\n- $contains: Check if array contains value\n  Example: { \"tags\": { \"$contains\": \"premium\" } }\n\nLogical Operators:\n- $and: Logical AND\n  Example: { \"$and\": [{ \"price\": { \"$gt\": 100 } }, { \"category\": \"electronics\" }] }\n- $or: Logical OR\n  Example: { \"$or\": [{ \"price\": { \"$lt\": 50 } }, { \"category\": \"books\" }] }\n- $not: Logical NOT\n  Example: { \"$not\": { \"category\": \"electronics\" } }\n- $nor: Logical NOR\n  Example: { \"$nor\": [{ \"price\": { \"$lt\": 50 } }, { \"category\": \"books\" }] }\n\nElement Operators:\n- $exists: Check if field exists\n  Example: { \"rating\": { \"$exists\": true } }\n\nSpecial Operators:\n- $size: Array length check\n  Example: { \"tags\": { \"$size\": 2 } }\n- $regex: Pattern matching (PostgreSQL regex syntax)\n  Example: { \"name\": { \"$regex\": \"^iphone\" } }\n- $options: Regex options (used with $regex)\n  Example: { \"name\": { \"$regex\": \"iphone\", \"$options\": \"i\" } }\n\nRestrictions:\n- Direct RegExp patterns are supported\n- Nested fields are supported using dot notation\n- Multiple conditions on the same field are supported with both implicit and explicit $and\n- Array operations work on array fields only\n- Regex patterns must follow PostgreSQL syntax\n- Empty arrays in conditions are handled gracefully\n- Only logical operators ($and, $or, $not, $nor) can be used at the top level\n- All other operators must be used within a field condition\n  Valid: { \"field\": { \"$gt\": 100 } }\n  Valid: { \"$and\": [...] }\n  Invalid: { \"$gt\": 100 }\n  Invalid: { \"$regex\": \"pattern\" }\n- Logical operators must contain field conditions, not direct operators\n  Valid: { \"$and\": [{ \"field\": { \"$gt\": 100 } }] }\n  Invalid: { \"$and\": [{ \"$gt\": 100 }] }\n- $not operator:\n  - Must be an object\n  - Cannot be empty\n  - Can be used at field level or top level\n  - Valid: { \"$not\": { \"field\": \"value\" } }\n  - Valid: { \"field\": { \"$not\": { \"$eq\": \"value\" } } }\n- Other logical operators ($and, $or, $nor):\n  - Can only be used at top level or nested within other logical operators\n  - Can not be used on a field level, or be nested inside a field\n  - Can not be used inside an operator\n  - Valid: { \"$and\": [{ \"field\": { \"$gt\": 100 } }] }\n  - Valid: { \"$or\": [{ \"$and\": [{ \"field\": { \"$gt\": 100 } }] }] }\n  - Invalid: { \"field\": { \"$and\": [{ \"$gt\": 100 }] } }\n  - Invalid: { \"field\": { \"$or\": [{ \"$gt\": 100 }] } }\n  - Invalid: { \"field\": { \"$gt\": { \"$and\": [{...}] } } }\n- $elemMatch requires an object with conditions\n  Valid: { \"array\": { \"$elemMatch\": { \"field\": \"value\" } } }\n  Invalid: { \"array\": { \"$elemMatch\": \"value\" } }\n\nExample Complex Query:\n{\n  \"$and\": [\n    { \"category\": { \"$in\": [\"electronics\", \"computers\"] } },\n    { \"price\": { \"$gte\": 100, \"$lte\": 1000 } },\n    { \"tags\": { \"$all\": [\"premium\", \"sale\"] } },\n    { \"items\": { \"$elemMatch\": { \"price\": { \"$gt\": 50 }, \"inStock\": true } } },\n    { \"$or\": [\n      { \"name\": { \"$regex\": \"^iphone\", \"$options\": \"i\" } },\n      { \"description\": { \"$regex\": \".*apple.*\" } }\n    ]}\n  ]\n}";
 export { PGVECTOR_PROMPT }
@@ -878,6 +749,12 @@ declare class QuestionsAnsweredExtractor extends BaseExtractor {
 export { QuestionsAnsweredExtractor }
 export { QuestionsAnsweredExtractor as QuestionsAnsweredExtractor_alias_1 }
 
+declare type RagTool<TInput extends z.ZodType<any, z.ZodTypeDef, any> | undefined, TOutput extends z.ZodType<any, z.ZodTypeDef, any> | undefined> = Tool<TInput, TOutput> & {
+    execute: NonNullable<Tool<TInput, TOutput>['execute']>;
+};
+export { RagTool }
+export { RagTool as RagTool_alias_1 }
+
 export declare interface RankedNode extends GraphNode {
     score: number;
 }

package/dist/index.cjs

@@ -6275,6 +6275,33 @@ var filterDescription = `JSON-formatted criteria to refine search results.
 - Do NOT use single quotes or unquoted properties
 - IMPORTANT: Always ensure JSON is properly closed with matching brackets
 - Multiple filters can be combined`;
+var baseSchema = {
+  queryText: zod.z.string().describe(queryTextDescription),
+  topK: zod.z.coerce.number().describe(topKDescription)
+};
+var outputSchema = zod.z.object({
+  // Array of metadata or content for compatibility with prior usage
+  relevantContext: zod.z.any(),
+  // Array of full retrieval result objects
+  sources: zod.z.array(
+    zod.z.object({
+      id: zod.z.string(),
+      // Unique chunk/document identifier
+      metadata: zod.z.any(),
+      // All metadata fields (document ID, etc.)
+      vector: zod.z.array(zod.z.number()),
+      // Embedding vector (if available)
+      score: zod.z.number(),
+      // Similarity score for this retrieval
+      document: zod.z.string()
+      // Full chunk/document text (if available)
+    })
+  )
+});
+var filterSchema = zod.z.object({
+  ...baseSchema,
+  filter: zod.z.coerce.string().describe(filterDescription)
+});
 
 // src/utils/convert-sources.ts
 var convertToSources = (results) => {
@@ -6327,39 +6354,11 @@ var createGraphRAGTool = ({
   const toolDescription = description || defaultGraphRagDescription();
   const graphRag = new GraphRAG(graphOptions.dimension, graphOptions.threshold);
   let isInitialized = false;
-  const baseSchema = {
-    queryText: zod.z.string().describe(queryTextDescription),
-    topK: zod.z.coerce.number().describe(topKDescription)
-  };
-  const inputSchema = enableFilter ? zod.z.object({
-    ...baseSchema,
-    filter: zod.z.coerce.string().describe(filterDescription)
-  }).passthrough() : zod.z.object(baseSchema).passthrough();
+  const inputSchema = enableFilter ? filterSchema : zod.z.object(baseSchema).passthrough();
   return tools.createTool({
     id: toolId,
     inputSchema,
-    // Output schema includes `sources`, which exposes the full set of retrieved chunks (QueryResult objects)
-    // Each source contains all information needed to reference
-    // the original document, chunk, and similarity score.
-    outputSchema: zod.z.object({
-      // Array of metadata or content for compatibility with prior usage
-      relevantContext: zod.z.any(),
-      // Array of full retrieval result objects
-      sources: zod.z.array(
-        zod.z.object({
-          id: zod.z.string(),
-          // Unique chunk/document identifier
-          metadata: zod.z.any(),
-          // All metadata fields (document ID, etc.)
-          vector: zod.z.array(zod.z.number()),
-          // Embedding vector (if available)
-          score: zod.z.number(),
-          // Similarity score for this retrieval
-          document: zod.z.string()
-          // Full chunk/document text (if available)
-        })
-      )
-    }),
+    outputSchema,
     description: toolDescription,
     execute: async ({ context: { queryText, topK, filter }, mastra }) => {
       const logger = mastra?.getLogger();
@@ -6453,6 +6452,7 @@ var createGraphRAGTool = ({
         return { relevantContext: [], sources: [] };
       }
     }
+    // Use any for output schema as the structure of the output causes type inference issues
   });
 };
 var createVectorQueryTool = ({
@@ -6468,39 +6468,11 @@ var createVectorQueryTool = ({
 }) => {
   const toolId = id || `VectorQuery ${vectorStoreName} ${indexName} Tool`;
   const toolDescription = description || defaultVectorQueryDescription();
-  const baseSchema = {
-    queryText: zod.z.string().describe(queryTextDescription),
-    topK: zod.z.coerce.number().describe(topKDescription)
-  };
-  const inputSchema = enableFilter ? zod.z.object({
-    ...baseSchema,
-    filter: zod.z.coerce.string().describe(filterDescription)
-  }).passthrough() : zod.z.object(baseSchema).passthrough();
+  const inputSchema = enableFilter ? filterSchema : zod.z.object(baseSchema).passthrough();
   return tools.createTool({
     id: toolId,
     inputSchema,
-    // Output schema includes `sources`, which exposes the full set of retrieved chunks (QueryResult objects)
-    // Each source contains all information needed to reference
-    // the original document, chunk, and similarity score.
-    outputSchema: zod.z.object({
-      // Array of metadata or content for compatibility with prior usage
-      relevantContext: zod.z.any(),
-      // Array of full retrieval result objects
-      sources: zod.z.array(
-        zod.z.object({
-          id: zod.z.string(),
-          // Unique chunk/document identifier
-          metadata: zod.z.any(),
-          // All metadata fields (document ID, etc.)
-          vector: zod.z.array(zod.z.number()),
-          // Embedding vector (if available)
-          score: zod.z.number(),
-          // Similarity score for this retrieval
-          document: zod.z.string()
-          // Full chunk/document text (if available)
-        })
-      )
-    }),
+    outputSchema,
     description: toolDescription,
     execute: async ({ context: { queryText, topK, filter }, mastra }) => {
       const logger = mastra?.getLogger();
@@ -6587,6 +6559,7 @@ var createVectorQueryTool = ({
         return { relevantContext: [], sources: [] };
       }
     }
+    // Use any for output schema as the structure of the output causes type inference issues
   });
 };
 

package/dist/index.js

@@ -6273,6 +6273,33 @@ var filterDescription = `JSON-formatted criteria to refine search results.
 - Do NOT use single quotes or unquoted properties
 - IMPORTANT: Always ensure JSON is properly closed with matching brackets
 - Multiple filters can be combined`;
+var baseSchema = {
+  queryText: z.string().describe(queryTextDescription),
+  topK: z.coerce.number().describe(topKDescription)
+};
+var outputSchema = z.object({
+  // Array of metadata or content for compatibility with prior usage
+  relevantContext: z.any(),
+  // Array of full retrieval result objects
+  sources: z.array(
+    z.object({
+      id: z.string(),
+      // Unique chunk/document identifier
+      metadata: z.any(),
+      // All metadata fields (document ID, etc.)
+      vector: z.array(z.number()),
+      // Embedding vector (if available)
+      score: z.number(),
+      // Similarity score for this retrieval
+      document: z.string()
+      // Full chunk/document text (if available)
+    })
+  )
+});
+var filterSchema = z.object({
+  ...baseSchema,
+  filter: z.coerce.string().describe(filterDescription)
+});
 
 // src/utils/convert-sources.ts
 var convertToSources = (results) => {
@@ -6325,39 +6352,11 @@ var createGraphRAGTool = ({
   const toolDescription = description || defaultGraphRagDescription();
   const graphRag = new GraphRAG(graphOptions.dimension, graphOptions.threshold);
   let isInitialized = false;
-  const baseSchema = {
-    queryText: z.string().describe(queryTextDescription),
-    topK: z.coerce.number().describe(topKDescription)
-  };
-  const inputSchema = enableFilter ? z.object({
-    ...baseSchema,
-    filter: z.coerce.string().describe(filterDescription)
-  }).passthrough() : z.object(baseSchema).passthrough();
+  const inputSchema = enableFilter ? filterSchema : z.object(baseSchema).passthrough();
   return createTool({
     id: toolId,
     inputSchema,
-    // Output schema includes `sources`, which exposes the full set of retrieved chunks (QueryResult objects)
-    // Each source contains all information needed to reference
-    // the original document, chunk, and similarity score.
-    outputSchema: z.object({
-      // Array of metadata or content for compatibility with prior usage
-      relevantContext: z.any(),
-      // Array of full retrieval result objects
-      sources: z.array(
-        z.object({
-          id: z.string(),
-          // Unique chunk/document identifier
-          metadata: z.any(),
-          // All metadata fields (document ID, etc.)
-          vector: z.array(z.number()),
-          // Embedding vector (if available)
-          score: z.number(),
-          // Similarity score for this retrieval
-          document: z.string()
-          // Full chunk/document text (if available)
-        })
-      )
-    }),
+    outputSchema,
     description: toolDescription,
     execute: async ({ context: { queryText, topK, filter }, mastra }) => {
       const logger = mastra?.getLogger();
@@ -6451,6 +6450,7 @@ var createGraphRAGTool = ({
         return { relevantContext: [], sources: [] };
       }
     }
+    // Use any for output schema as the structure of the output causes type inference issues
   });
 };
 var createVectorQueryTool = ({
@@ -6466,39 +6466,11 @@ var createVectorQueryTool = ({
 }) => {
   const toolId = id || `VectorQuery ${vectorStoreName} ${indexName} Tool`;
   const toolDescription = description || defaultVectorQueryDescription();
-  const baseSchema = {
-    queryText: z.string().describe(queryTextDescription),
-    topK: z.coerce.number().describe(topKDescription)
-  };
-  const inputSchema = enableFilter ? z.object({
-    ...baseSchema,
-    filter: z.coerce.string().describe(filterDescription)
-  }).passthrough() : z.object(baseSchema).passthrough();
+  const inputSchema = enableFilter ? filterSchema : z.object(baseSchema).passthrough();
   return createTool({
     id: toolId,
     inputSchema,
-    // Output schema includes `sources`, which exposes the full set of retrieved chunks (QueryResult objects)
-    // Each source contains all information needed to reference
-    // the original document, chunk, and similarity score.
-    outputSchema: z.object({
-      // Array of metadata or content for compatibility with prior usage
-      relevantContext: z.any(),
-      // Array of full retrieval result objects
-      sources: z.array(
-        z.object({
-          id: z.string(),
-          // Unique chunk/document identifier
-          metadata: z.any(),
-          // All metadata fields (document ID, etc.)
-          vector: z.array(z.number()),
-          // Embedding vector (if available)
-          score: z.number(),
-          // Similarity score for this retrieval
-          document: z.string()
-          // Full chunk/document text (if available)
-        })
-      )
-    }),
+    outputSchema,
     description: toolDescription,
     execute: async ({ context: { queryText, topK, filter }, mastra }) => {
       const logger = mastra?.getLogger();
@@ -6585,6 +6557,7 @@ var createVectorQueryTool = ({
         return { relevantContext: [], sources: [] };
       }
     }
+    // Use any for output schema as the structure of the output causes type inference issues
   });
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/rag",
-  "version": "0.10.1-alpha.0",
+  "version": "0.10.1-alpha.1",
   "description": "",
   "type": "module",
   "main": "dist/index.js",