@mastra/rag 1.0.1 → 1.0.2-alpha.0

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/rag@1.0.1-alpha.0 build /home/runner/work/mastra/mastra/packages/rag
+> @mastra/rag@1.0.2-alpha.0 build /home/runner/work/mastra/mastra/packages/rag
 > tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.5.0
 TSC Build start
-TSC ⚡️ Build success in 14155ms
+TSC ⚡️ Build success in 14378ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/packages/rag/dist/_tsup-dts-rollup.d.ts
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/packages/rag/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 13672ms
+DTS ⚡️ Build success in 12936ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 242.08 KB
-ESM ⚡️ Build success in 4294ms
-CJS dist/index.cjs 243.79 KB
-CJS ⚡️ Build success in 4295ms
+CJS dist/index.cjs 247.58 KB
+CJS ⚡️ Build success in 4578ms
+ESM dist/index.js 245.51 KB
+ESM ⚡️ Build success in 4580ms

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @mastra/rag
 
+## 1.0.2-alpha.0
+
+### Patch Changes
+
+- 43da563: Refactor relevance provider
+- Updated dependencies [c7bbf1e]
+- Updated dependencies [8722d53]
+- Updated dependencies [132027f]
+- Updated dependencies [0c85311]
+- Updated dependencies [cb16baf]
+  - @mastra/core@0.10.11-alpha.3
+
 ## 1.0.1
 
 ### Patch Changes

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

@@ -4,6 +4,7 @@ import type { MastraLanguageModel } from '@mastra/core/agent';
 import type { MastraVector } from '@mastra/core/vector';
 import type { QueryResult } from '@mastra/core/vector';
 import type { QueryResult as QueryResult_2 } from '@mastra/core';
+import type { RelevanceScoreProvider } from '@mastra/core/relevance';
 import type { TiktokenEncoding } from 'js-tiktoken';
 import type { TiktokenModel } from 'js-tiktoken';
 import type { Tool } from '@mastra/core/tools';
@@ -162,6 +163,16 @@ declare type ChunkStrategy = 'recursive' | 'character' | 'token' | 'markdown' |
 export { ChunkStrategy }
 export { ChunkStrategy as ChunkStrategy_alias_1 }
 
+declare class CohereRelevanceScorer implements RelevanceScoreProvider {
+    private client;
+    private model;
+    constructor(model: string, apiKey?: string);
+    getRelevanceScore(query: string, text: string): Promise<number>;
+}
+export { CohereRelevanceScorer }
+export { CohereRelevanceScorer as CohereRelevanceScorer_alias_1 }
+export { CohereRelevanceScorer as CohereRelevanceScorer_alias_2 }
+
 /**
  * Convert an array of source inputs (QueryResult, RankedNode, or RerankResult) to an array of sources.
  * @param results Array of source inputs to convert.
@@ -593,6 +604,15 @@ export declare class MarkdownTransformer extends RecursiveCharacterTransformer {
     });
 }
 
+declare class MastraAgentRelevanceScorer implements RelevanceScoreProvider {
+    private agent;
+    constructor(name: string, model: MastraLanguageModel);
+    getRelevanceScore(query: string, text: string): Promise<number>;
+}
+export { MastraAgentRelevanceScorer }
+export { MastraAgentRelevanceScorer as MastraAgentRelevanceScorer_alias_1 }
+export { MastraAgentRelevanceScorer as MastraAgentRelevanceScorer_alias_2 }
+
 declare class MDocument {
     private chunks;
     private type;
@@ -950,7 +970,7 @@ export { rerank as rerank_alias_1 }
 
 declare interface RerankConfig {
     options?: RerankerOptions;
-    model: MastraLanguageModel;
+    model: MastraLanguageModel | RelevanceScoreProvider;
 }
 export { RerankConfig }
 export { RerankConfig as RerankConfig_alias_1 }
@@ -978,6 +998,15 @@ declare interface RerankResult {
 export { RerankResult }
 export { RerankResult as RerankResult_alias_1 }
 
+declare function rerankWithScorer({ results, query, scorer, options, }: {
+    results: QueryResult[];
+    query: string;
+    scorer: RelevanceScoreProvider;
+    options: RerankerFunctionOptions;
+}): Promise<RerankResult[]>;
+export { rerankWithScorer }
+export { rerankWithScorer as rerankWithScorer_alias_1 }
+
 declare interface ScoringDetails {
     semantic: number;
     vector: number;
@@ -1256,4 +1285,14 @@ declare type WhereDocumentOperator = '$contains' | '$not_contains' | LogicalOper
 
 declare type WhereOperator = '$gt' | '$gte' | '$lt' | '$lte' | '$ne' | '$eq';
 
+declare class ZeroEntropyRelevanceScorer implements RelevanceScoreProvider {
+    private client;
+    private model;
+    constructor(model?: string, apiKey?: string);
+    getRelevanceScore(query: string, text: string): Promise<number>;
+}
+export { ZeroEntropyRelevanceScorer }
+export { ZeroEntropyRelevanceScorer as ZeroEntropyRelevanceScorer_alias_1 }
+export { ZeroEntropyRelevanceScorer as ZeroEntropyRelevanceScorer_alias_2 }
+
 export { }

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

@@ -4,6 +4,7 @@ import type { MastraLanguageModel } from '@mastra/core/agent';
 import type { MastraVector } from '@mastra/core/vector';
 import type { QueryResult } from '@mastra/core/vector';
 import type { QueryResult as QueryResult_2 } from '@mastra/core';
+import type { RelevanceScoreProvider } from '@mastra/core/relevance';
 import type { TiktokenEncoding } from 'js-tiktoken';
 import type { TiktokenModel } from 'js-tiktoken';
 import type { Tool } from '@mastra/core/tools';
@@ -162,6 +163,16 @@ declare type ChunkStrategy = 'recursive' | 'character' | 'token' | 'markdown' |
 export { ChunkStrategy }
 export { ChunkStrategy as ChunkStrategy_alias_1 }
 
+declare class CohereRelevanceScorer implements RelevanceScoreProvider {
+    private client;
+    private model;
+    constructor(model: string, apiKey?: string);
+    getRelevanceScore(query: string, text: string): Promise<number>;
+}
+export { CohereRelevanceScorer }
+export { CohereRelevanceScorer as CohereRelevanceScorer_alias_1 }
+export { CohereRelevanceScorer as CohereRelevanceScorer_alias_2 }
+
 /**
  * Convert an array of source inputs (QueryResult, RankedNode, or RerankResult) to an array of sources.
  * @param results Array of source inputs to convert.
@@ -593,6 +604,15 @@ export declare class MarkdownTransformer extends RecursiveCharacterTransformer {
     });
 }
 
+declare class MastraAgentRelevanceScorer implements RelevanceScoreProvider {
+    private agent;
+    constructor(name: string, model: MastraLanguageModel);
+    getRelevanceScore(query: string, text: string): Promise<number>;
+}
+export { MastraAgentRelevanceScorer }
+export { MastraAgentRelevanceScorer as MastraAgentRelevanceScorer_alias_1 }
+export { MastraAgentRelevanceScorer as MastraAgentRelevanceScorer_alias_2 }
+
 declare class MDocument {
     private chunks;
     private type;
@@ -950,7 +970,7 @@ export { rerank as rerank_alias_1 }
 
 declare interface RerankConfig {
     options?: RerankerOptions;
-    model: MastraLanguageModel;
+    model: MastraLanguageModel | RelevanceScoreProvider;
 }
 export { RerankConfig }
 export { RerankConfig as RerankConfig_alias_1 }
@@ -978,6 +998,15 @@ declare interface RerankResult {
 export { RerankResult }
 export { RerankResult as RerankResult_alias_1 }
 
+declare function rerankWithScorer({ results, query, scorer, options, }: {
+    results: QueryResult[];
+    query: string;
+    scorer: RelevanceScoreProvider;
+    options: RerankerFunctionOptions;
+}): Promise<RerankResult[]>;
+export { rerankWithScorer }
+export { rerankWithScorer as rerankWithScorer_alias_1 }
+
 declare interface ScoringDetails {
     semantic: number;
     vector: number;
@@ -1256,4 +1285,14 @@ declare type WhereDocumentOperator = '$contains' | '$not_contains' | LogicalOper
 
 declare type WhereOperator = '$gt' | '$gte' | '$lt' | '$lte' | '$ne' | '$eq';
 
+declare class ZeroEntropyRelevanceScorer implements RelevanceScoreProvider {
+    private client;
+    private model;
+    constructor(model?: string, apiKey?: string);
+    getRelevanceScore(query: string, text: string): Promise<number>;
+}
+export { ZeroEntropyRelevanceScorer }
+export { ZeroEntropyRelevanceScorer as ZeroEntropyRelevanceScorer_alias_1 }
+export { ZeroEntropyRelevanceScorer as ZeroEntropyRelevanceScorer_alias_2 }
+
 export { }

package/dist/index.cjs

@@ -4,11 +4,18 @@ var crypto = require('crypto');
 var zod = require('zod');
 var nodeHtmlBetterParser = require('node-html-better-parser');
 var jsTiktoken = require('js-tiktoken');
-var relevance = require('@mastra/core/relevance');
 var big_js = require('big.js');
+var cohereAi = require('cohere-ai');
+var agent = require('@mastra/core/agent');
+var relevance = require('@mastra/core/relevance');
+var ZeroEntropy = require('zeroentropy');
 var tools = require('@mastra/core/tools');
 var ai = require('ai');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var ZeroEntropy__default = /*#__PURE__*/_interopDefault(ZeroEntropy);
+
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -3394,15 +3401,16 @@ var OpenAIResponsesLanguageModel = class {
   async doGenerate(options) {
     var _a15, _b, _c, _d, _e, _f, _g;
     const { args: body, warnings } = this.getArgs(options);
+    const url = this.config.url({
+      path: "/responses",
+      modelId: this.modelId
+    });
     const {
       responseHeaders,
       value: response,
       rawValue: rawResponse
     } = await postJsonToApi({
-      url: this.config.url({
-        path: "/responses",
-        modelId: this.modelId
-      }),
+      url,
       headers: combineHeaders(this.config.headers(), options.headers),
       body,
       failedResponseHandler: openaiFailedResponseHandler,
@@ -3410,6 +3418,10 @@ var OpenAIResponsesLanguageModel = class {
         zod.z.object({
           id: zod.z.string(),
           created_at: zod.z.number(),
+          error: zod.z.object({
+            message: zod.z.string(),
+            code: zod.z.string()
+          }).nullish(),
           model: zod.z.string(),
           output: zod.z.array(
             zod.z.discriminatedUnion("type", [
@@ -3462,6 +3474,17 @@ var OpenAIResponsesLanguageModel = class {
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
+    if (response.error) {
+      throw new APICallError({
+        message: response.error.message,
+        url,
+        requestBodyValues: body,
+        statusCode: 400,
+        responseHeaders,
+        responseBody: rawResponse,
+        isRetryable: false
+      });
+    }
     const outputTextElements = response.output.filter((output) => output.type === "message").flatMap((output) => output.content).filter((content) => content.type === "output_text");
     const toolCalls = response.output.filter((output) => output.type === "function_call").map((output) => ({
       toolCallType: "function",
@@ -3633,6 +3656,8 @@ var OpenAIResponsesLanguageModel = class {
                   title: value.annotation.title
                 }
               });
+            } else if (isErrorChunk(value)) {
+              controller.enqueue({ type: "error", error: value });
             }
           },
           flush(controller) {
@@ -3742,6 +3767,13 @@ var responseReasoningSummaryTextDeltaSchema = zod.z.object({
   summary_index: zod.z.number(),
   delta: zod.z.string()
 });
+var errorChunkSchema = zod.z.object({
+  type: zod.z.literal("error"),
+  code: zod.z.string(),
+  message: zod.z.string(),
+  param: zod.z.string().nullish(),
+  sequence_number: zod.z.number()
+});
 var openaiResponsesChunkSchema = zod.z.union([
   textDeltaChunkSchema,
   responseFinishedChunkSchema,
@@ -3751,6 +3783,7 @@ var openaiResponsesChunkSchema = zod.z.union([
   responseOutputItemAddedSchema,
   responseAnnotationAddedSchema,
   responseReasoningSummaryTextDeltaSchema,
+  errorChunkSchema,
   zod.z.object({ type: zod.z.string() }).passthrough()
   // fallback for unknown chunks
 ]);
@@ -3778,6 +3811,9 @@ function isResponseAnnotationAddedChunk(chunk) {
 function isResponseReasoningSummaryTextDeltaChunk(chunk) {
   return chunk.type === "response.reasoning_summary_text.delta";
 }
+function isErrorChunk(chunk) {
+  return chunk.type === "error";
+}
 function getResponsesModelConfig(modelId) {
   if (modelId.startsWith("o")) {
     if (modelId.startsWith("o1-mini") || modelId.startsWith("o1-preview")) {
@@ -5940,6 +5976,70 @@ var MDocument = class _MDocument {
     return this.chunks.map((doc) => doc.metadata);
   }
 };
+var CohereRelevanceScorer = class {
+  client;
+  model;
+  constructor(model, apiKey) {
+    this.client = new cohereAi.CohereClient({
+      token: apiKey || process.env.COHERE_API_KEY || ""
+    });
+    this.model = model;
+  }
+  async getRelevanceScore(query, text) {
+    const response = await this.client.rerank({
+      query,
+      documents: [text],
+      model: this.model,
+      topN: 1
+    });
+    return response.results[0].relevanceScore;
+  }
+};
+var MastraAgentRelevanceScorer = class {
+  agent;
+  constructor(name14, model) {
+    this.agent = new agent.Agent({
+      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.
+Output only a number between 0 and 1, where:
+1.0 = Perfectly relevant, directly answers the query
+0.0 = Completely irrelevant
+Consider:
+- Direct relevance to the question
+- Completeness of information
+- Quality and specificity
+Always return just the number, no explanation.`,
+      model
+    });
+  }
+  async getRelevanceScore(query, text) {
+    const prompt = relevance.createSimilarityPrompt(query, text);
+    const response = await this.agent.generate(prompt);
+    return parseFloat(response.text);
+  }
+};
+var ZeroEntropyRelevanceScorer = class {
+  client;
+  model;
+  constructor(model, apiKey) {
+    this.client = new ZeroEntropy__default.default({
+      apiKey: apiKey || process.env.ZEROENTROPY_API_KEY || ""
+    });
+    this.model = model || "zerank-1";
+  }
+  async getRelevanceScore(query, text) {
+    const response = await this.client.models.rerank({
+      query,
+      documents: [text],
+      model: this.model,
+      top_n: 1
+    });
+    return response.results[0]?.relevance_score ?? 0;
+  }
+};
+
+// src/rerank/index.ts
 var DEFAULT_WEIGHTS = {
   semantic: 0.4,
   vector: 0.4,
@@ -5958,13 +6058,12 @@ function adjustScores(score, queryAnalysis) {
   const featureStrengthAdjustment = queryAnalysis.magnitude > 5 ? 1.05 : 1;
   return score * magnitudeAdjustment * featureStrengthAdjustment;
 }
-async function rerank(results, query, model, options) {
-  let semanticProvider;
-  if (model.modelId === "rerank-v3.5") {
-    semanticProvider = new relevance.CohereRelevanceScorer(model.modelId);
-  } else {
-    semanticProvider = new relevance.MastraAgentRelevanceScorer(model.provider, model);
-  }
+async function executeRerank({
+  results,
+  query,
+  scorer,
+  options
+}) {
   const { queryEmbedding, topK = 3 } = options;
   const weights = {
     ...DEFAULT_WEIGHTS,
@@ -5980,7 +6079,7 @@ async function rerank(results, query, model, options) {
     results.map(async (result, index) => {
       let semanticScore = 0;
       if (result?.metadata?.text) {
-        semanticScore = await semanticProvider.getRelevanceScore(query, result?.metadata?.text);
+        semanticScore = await scorer.getRelevanceScore(query, result?.metadata?.text);
       }
       const vectorScore = result.score;
       const positionScore = calculatePositionScore(index, resultLength);
@@ -6007,6 +6106,33 @@ async function rerank(results, query, model, options) {
   );
   return scoredResults.sort((a, b) => b.score - a.score).slice(0, topK);
 }
+async function rerankWithScorer({
+  results,
+  query,
+  scorer,
+  options
+}) {
+  return executeRerank({
+    results,
+    query,
+    scorer,
+    options
+  });
+}
+async function rerank(results, query, model, options) {
+  let semanticProvider;
+  if (model.modelId === "rerank-v3.5") {
+    semanticProvider = new CohereRelevanceScorer(model.modelId);
+  } else {
+    semanticProvider = new MastraAgentRelevanceScorer(model.provider, model);
+  }
+  return executeRerank({
+    results,
+    query,
+    scorer: semanticProvider,
+    options
+  });
+}
 
 // src/graph-rag/index.ts
 var GraphRAG = class {
@@ -6605,10 +6731,23 @@ var createVectorQueryTool = (options) => {
           if (logger) {
             logger.debug("Reranking results", { rerankerModel: reranker.model, rerankerOptions: reranker.options });
           }
-          const rerankedResults = await rerank(results, queryText, reranker.model, {
-            ...reranker.options,
-            topK: reranker.options?.topK || topKValue
-          });
+          let rerankedResults = [];
+          if (typeof reranker?.model === "object" && "getRelevanceScore" in reranker?.model) {
+            rerankedResults = await rerankWithScorer({
+              results,
+              query: queryText,
+              scorer: reranker.model,
+              options: {
+                ...reranker.options,
+                topK: reranker.options?.topK || topKValue
+              }
+            });
+          } else {
+            rerankedResults = await rerank(results, queryText, reranker.model, {
+              ...reranker.options,
+              topK: reranker.options?.topK || topKValue
+            });
+          }
           if (logger) {
             logger.debug("Reranking complete", { rerankedCount: rerankedResults.length });
           }
@@ -7448,15 +7587,18 @@ Example Complex Query:
 
 exports.ASTRA_PROMPT = ASTRA_PROMPT;
 exports.CHROMA_PROMPT = CHROMA_PROMPT;
+exports.CohereRelevanceScorer = CohereRelevanceScorer;
 exports.GraphRAG = GraphRAG;
 exports.LIBSQL_PROMPT = LIBSQL_PROMPT;
 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;
 exports.createVectorQueryTool = createVectorQueryTool;
@@ -7465,4 +7607,5 @@ exports.defaultVectorQueryDescription = defaultVectorQueryDescription;
 exports.filterDescription = filterDescription;
 exports.queryTextDescription = queryTextDescription;
 exports.rerank = rerank;
+exports.rerankWithScorer = rerankWithScorer;
 exports.topKDescription = topKDescription;

package/dist/index.d.cts

@@ -1,10 +1,14 @@
 export { GraphRAG } from './_tsup-dts-rollup.cjs';
 export { MDocument } from './_tsup-dts-rollup.cjs';
+export { rerankWithScorer } from './_tsup-dts-rollup.cjs';
 export { rerank } from './_tsup-dts-rollup.cjs';
 export { RerankResult } from './_tsup-dts-rollup.cjs';
 export { RerankerOptions } from './_tsup-dts-rollup.cjs';
 export { RerankerFunctionOptions } from './_tsup-dts-rollup.cjs';
 export { RerankConfig } from './_tsup-dts-rollup.cjs';
+export { CohereRelevanceScorer } from './_tsup-dts-rollup.cjs';
+export { MastraAgentRelevanceScorer } from './_tsup-dts-rollup.cjs';
+export { ZeroEntropyRelevanceScorer } from './_tsup-dts-rollup.cjs';
 export { createDocumentChunkerTool } from './_tsup-dts-rollup.cjs';
 export { createGraphRAGTool } from './_tsup-dts-rollup.cjs';
 export { createVectorQueryTool } from './_tsup-dts-rollup.cjs';

package/dist/index.d.ts

@@ -1,10 +1,14 @@
 export { GraphRAG } from './_tsup-dts-rollup.js';
 export { MDocument } from './_tsup-dts-rollup.js';
+export { rerankWithScorer } from './_tsup-dts-rollup.js';
 export { rerank } from './_tsup-dts-rollup.js';
 export { RerankResult } from './_tsup-dts-rollup.js';
 export { RerankerOptions } from './_tsup-dts-rollup.js';
 export { RerankerFunctionOptions } from './_tsup-dts-rollup.js';
 export { RerankConfig } from './_tsup-dts-rollup.js';
+export { CohereRelevanceScorer } from './_tsup-dts-rollup.js';
+export { MastraAgentRelevanceScorer } from './_tsup-dts-rollup.js';
+export { ZeroEntropyRelevanceScorer } from './_tsup-dts-rollup.js';
 export { createDocumentChunkerTool } from './_tsup-dts-rollup.js';
 export { createGraphRAGTool } from './_tsup-dts-rollup.js';
 export { createVectorQueryTool } from './_tsup-dts-rollup.js';

package/dist/index.js

@@ -2,8 +2,11 @@ import { randomUUID, createHash } from 'crypto';
 import { z } from 'zod';
 import { parse } from 'node-html-better-parser';
 import { encodingForModel, getEncoding } from 'js-tiktoken';
-import { CohereRelevanceScorer, MastraAgentRelevanceScorer } from '@mastra/core/relevance';
 import { Big } from 'big.js';
+import { CohereClient } from 'cohere-ai';
+import { Agent } from '@mastra/core/agent';
+import { createSimilarityPrompt } from '@mastra/core/relevance';
+import ZeroEntropy from 'zeroentropy';
 import { createTool } from '@mastra/core/tools';
 import { embed } from 'ai';
 
@@ -3392,15 +3395,16 @@ var OpenAIResponsesLanguageModel = class {
   async doGenerate(options) {
     var _a15, _b, _c, _d, _e, _f, _g;
     const { args: body, warnings } = this.getArgs(options);
+    const url = this.config.url({
+      path: "/responses",
+      modelId: this.modelId
+    });
     const {
       responseHeaders,
       value: response,
       rawValue: rawResponse
     } = await postJsonToApi({
-      url: this.config.url({
-        path: "/responses",
-        modelId: this.modelId
-      }),
+      url,
       headers: combineHeaders(this.config.headers(), options.headers),
       body,
       failedResponseHandler: openaiFailedResponseHandler,
@@ -3408,6 +3412,10 @@ var OpenAIResponsesLanguageModel = class {
         z.object({
           id: z.string(),
           created_at: z.number(),
+          error: z.object({
+            message: z.string(),
+            code: z.string()
+          }).nullish(),
           model: z.string(),
           output: z.array(
             z.discriminatedUnion("type", [
@@ -3460,6 +3468,17 @@ var OpenAIResponsesLanguageModel = class {
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
+    if (response.error) {
+      throw new APICallError({
+        message: response.error.message,
+        url,
+        requestBodyValues: body,
+        statusCode: 400,
+        responseHeaders,
+        responseBody: rawResponse,
+        isRetryable: false
+      });
+    }
     const outputTextElements = response.output.filter((output) => output.type === "message").flatMap((output) => output.content).filter((content) => content.type === "output_text");
     const toolCalls = response.output.filter((output) => output.type === "function_call").map((output) => ({
       toolCallType: "function",
@@ -3631,6 +3650,8 @@ var OpenAIResponsesLanguageModel = class {
                   title: value.annotation.title
                 }
               });
+            } else if (isErrorChunk(value)) {
+              controller.enqueue({ type: "error", error: value });
             }
           },
           flush(controller) {
@@ -3740,6 +3761,13 @@ var responseReasoningSummaryTextDeltaSchema = z.object({
   summary_index: z.number(),
   delta: z.string()
 });
+var errorChunkSchema = z.object({
+  type: z.literal("error"),
+  code: z.string(),
+  message: z.string(),
+  param: z.string().nullish(),
+  sequence_number: z.number()
+});
 var openaiResponsesChunkSchema = z.union([
   textDeltaChunkSchema,
   responseFinishedChunkSchema,
@@ -3749,6 +3777,7 @@ var openaiResponsesChunkSchema = z.union([
   responseOutputItemAddedSchema,
   responseAnnotationAddedSchema,
   responseReasoningSummaryTextDeltaSchema,
+  errorChunkSchema,
   z.object({ type: z.string() }).passthrough()
   // fallback for unknown chunks
 ]);
@@ -3776,6 +3805,9 @@ function isResponseAnnotationAddedChunk(chunk) {
 function isResponseReasoningSummaryTextDeltaChunk(chunk) {
   return chunk.type === "response.reasoning_summary_text.delta";
 }
+function isErrorChunk(chunk) {
+  return chunk.type === "error";
+}
 function getResponsesModelConfig(modelId) {
   if (modelId.startsWith("o")) {
     if (modelId.startsWith("o1-mini") || modelId.startsWith("o1-preview")) {
@@ -5938,6 +5970,70 @@ var MDocument = class _MDocument {
     return this.chunks.map((doc) => doc.metadata);
   }
 };
+var CohereRelevanceScorer = class {
+  client;
+  model;
+  constructor(model, apiKey) {
+    this.client = new CohereClient({
+      token: apiKey || process.env.COHERE_API_KEY || ""
+    });
+    this.model = model;
+  }
+  async getRelevanceScore(query, text) {
+    const response = await this.client.rerank({
+      query,
+      documents: [text],
+      model: this.model,
+      topN: 1
+    });
+    return response.results[0].relevanceScore;
+  }
+};
+var MastraAgentRelevanceScorer = class {
+  agent;
+  constructor(name14, model) {
+    this.agent = new Agent({
+      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.
+Output only a number between 0 and 1, where:
+1.0 = Perfectly relevant, directly answers the query
+0.0 = Completely irrelevant
+Consider:
+- Direct relevance to the question
+- Completeness of information
+- Quality and specificity
+Always return just the number, no explanation.`,
+      model
+    });
+  }
+  async getRelevanceScore(query, text) {
+    const prompt = createSimilarityPrompt(query, text);
+    const response = await this.agent.generate(prompt);
+    return parseFloat(response.text);
+  }
+};
+var ZeroEntropyRelevanceScorer = class {
+  client;
+  model;
+  constructor(model, apiKey) {
+    this.client = new ZeroEntropy({
+      apiKey: apiKey || process.env.ZEROENTROPY_API_KEY || ""
+    });
+    this.model = model || "zerank-1";
+  }
+  async getRelevanceScore(query, text) {
+    const response = await this.client.models.rerank({
+      query,
+      documents: [text],
+      model: this.model,
+      top_n: 1
+    });
+    return response.results[0]?.relevance_score ?? 0;
+  }
+};
+
+// src/rerank/index.ts
 var DEFAULT_WEIGHTS = {
   semantic: 0.4,
   vector: 0.4,
@@ -5956,13 +6052,12 @@ function adjustScores(score, queryAnalysis) {
   const featureStrengthAdjustment = queryAnalysis.magnitude > 5 ? 1.05 : 1;
   return score * magnitudeAdjustment * featureStrengthAdjustment;
 }
-async function rerank(results, query, model, options) {
-  let semanticProvider;
-  if (model.modelId === "rerank-v3.5") {
-    semanticProvider = new CohereRelevanceScorer(model.modelId);
-  } else {
-    semanticProvider = new MastraAgentRelevanceScorer(model.provider, model);
-  }
+async function executeRerank({
+  results,
+  query,
+  scorer,
+  options
+}) {
   const { queryEmbedding, topK = 3 } = options;
   const weights = {
     ...DEFAULT_WEIGHTS,
@@ -5978,7 +6073,7 @@ async function rerank(results, query, model, options) {
     results.map(async (result, index) => {
       let semanticScore = 0;
       if (result?.metadata?.text) {
-        semanticScore = await semanticProvider.getRelevanceScore(query, result?.metadata?.text);
+        semanticScore = await scorer.getRelevanceScore(query, result?.metadata?.text);
       }
       const vectorScore = result.score;
       const positionScore = calculatePositionScore(index, resultLength);
@@ -6005,6 +6100,33 @@ async function rerank(results, query, model, options) {
   );
   return scoredResults.sort((a, b) => b.score - a.score).slice(0, topK);
 }
+async function rerankWithScorer({
+  results,
+  query,
+  scorer,
+  options
+}) {
+  return executeRerank({
+    results,
+    query,
+    scorer,
+    options
+  });
+}
+async function rerank(results, query, model, options) {
+  let semanticProvider;
+  if (model.modelId === "rerank-v3.5") {
+    semanticProvider = new CohereRelevanceScorer(model.modelId);
+  } else {
+    semanticProvider = new MastraAgentRelevanceScorer(model.provider, model);
+  }
+  return executeRerank({
+    results,
+    query,
+    scorer: semanticProvider,
+    options
+  });
+}
 
 // src/graph-rag/index.ts
 var GraphRAG = class {
@@ -6603,10 +6725,23 @@ var createVectorQueryTool = (options) => {
           if (logger) {
             logger.debug("Reranking results", { rerankerModel: reranker.model, rerankerOptions: reranker.options });
           }
-          const rerankedResults = await rerank(results, queryText, reranker.model, {
-            ...reranker.options,
-            topK: reranker.options?.topK || topKValue
-          });
+          let rerankedResults = [];
+          if (typeof reranker?.model === "object" && "getRelevanceScore" in reranker?.model) {
+            rerankedResults = await rerankWithScorer({
+              results,
+              query: queryText,
+              scorer: reranker.model,
+              options: {
+                ...reranker.options,
+                topK: reranker.options?.topK || topKValue
+              }
+            });
+          } else {
+            rerankedResults = await rerank(results, queryText, reranker.model, {
+              ...reranker.options,
+              topK: reranker.options?.topK || topKValue
+            });
+          }
           if (logger) {
             logger.debug("Reranking complete", { rerankedCount: rerankedResults.length });
           }
@@ -7444,4 +7579,4 @@ Example Complex Query:
 }
 `;
 
-export { ASTRA_PROMPT, CHROMA_PROMPT, GraphRAG, LIBSQL_PROMPT, MDocument, MONGODB_PROMPT, PGVECTOR_PROMPT, PINECONE_PROMPT, QDRANT_PROMPT, UPSTASH_PROMPT, VECTORIZE_PROMPT, createDocumentChunkerTool, createGraphRAGTool, createVectorQueryTool, defaultGraphRagDescription, defaultVectorQueryDescription, filterDescription, queryTextDescription, rerank, topKDescription };
+export { ASTRA_PROMPT, CHROMA_PROMPT, CohereRelevanceScorer, GraphRAG, LIBSQL_PROMPT, MDocument, MONGODB_PROMPT, MastraAgentRelevanceScorer, PGVECTOR_PROMPT, PINECONE_PROMPT, QDRANT_PROMPT, UPSTASH_PROMPT, VECTORIZE_PROMPT, ZeroEntropyRelevanceScorer, createDocumentChunkerTool, createGraphRAGTool, createVectorQueryTool, defaultGraphRagDescription, defaultVectorQueryDescription, filterDescription, queryTextDescription, rerank, rerankWithScorer, topKDescription };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/rag",
-  "version": "1.0.1",
+  "version": "1.0.2-alpha.0",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -23,9 +23,11 @@
   "dependencies": {
     "@paralleldrive/cuid2": "^2.2.2",
     "big.js": "^7.0.1",
+    "cohere-ai": "^7.17.1",
     "js-tiktoken": "^1.0.20",
     "node-html-better-parser": "^1.4.11",
     "pathe": "^2.0.3",
+    "zeroentropy": "0.1.0-alpha.6",
     "zod": "^3.25.67"
   },
   "peerDependencies": {
@@ -39,13 +41,13 @@
     "@types/big.js": "^6.2.2",
     "@types/node": "^20.19.0",
     "ai": "^4.3.16",
-    "dotenv": "^16.5.0",
+    "dotenv": "^17.0.0",
     "eslint": "^9.29.0",
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
-    "vitest": "^3.2.3",
-    "@mastra/core": "0.10.7",
-    "@internal/lint": "0.0.14"
+    "vitest": "^3.2.4",
+    "@internal/lint": "0.0.17",
+    "@mastra/core": "0.10.11-alpha.3"
   },
   "keywords": [
     "rag",
@@ -66,6 +68,7 @@
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",
     "buld:watch": "pnpm build --watch",
+    "vitest": "vitest",
     "test": "vitest run",
     "lint": "eslint ."
   }

package/src/index.ts

@@ -1,5 +1,6 @@
 export * from './document/document';
 export * from './rerank';
+export * from './rerank/relevance';
 export { GraphRAG } from './graph-rag';
 export * from './tools';
 export * from './utils/vector-prompts';

package/src/rerank/index.test.ts

@@ -1,6 +1,6 @@
 import { cohere } from '@ai-sdk/cohere';
-import { CohereRelevanceScorer } from '@mastra/core/relevance';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { CohereRelevanceScorer } from './relevance';
 
 import { rerank } from '.';
 

package/src/rerank/index.ts

@@ -1,8 +1,8 @@
 import type { MastraLanguageModel } from '@mastra/core/agent';
-import { MastraAgentRelevanceScorer, CohereRelevanceScorer } from '@mastra/core/relevance';
 import type { RelevanceScoreProvider } from '@mastra/core/relevance';
 import type { QueryResult } from '@mastra/core/vector';
 import { Big } from 'big.js';
+import { MastraAgentRelevanceScorer, CohereRelevanceScorer } from './relevance';
 
 // Default weights for different scoring components (must add up to 1)
 const DEFAULT_WEIGHTS = {
@@ -48,7 +48,7 @@ export interface RerankerFunctionOptions {
 
 export interface RerankConfig {
   options?: RerankerOptions;
-  model: MastraLanguageModel;
+  model: MastraLanguageModel | RelevanceScoreProvider;
 }
 
 // Calculate position score based on position in original list
@@ -83,19 +83,17 @@ function adjustScores(score: number, queryAnalysis: { magnitude: number; dominan
   return score * magnitudeAdjustment * featureStrengthAdjustment;
 }
 
-// Takes in a list of results from a vector store and reranks them based on semantic, vector, and position scores
-export async function rerank(
-  results: QueryResult[],
-  query: string,
-  model: MastraLanguageModel,
-  options: RerankerFunctionOptions,
-): Promise<RerankResult[]> {
-  let semanticProvider: RelevanceScoreProvider;
-  if (model.modelId === 'rerank-v3.5') {
-    semanticProvider = new CohereRelevanceScorer(model.modelId);
-  } else {
-    semanticProvider = new MastraAgentRelevanceScorer(model.provider, model);
-  }
+async function executeRerank({
+  results,
+  query,
+  scorer,
+  options,
+}: {
+  results: QueryResult[];
+  query: string;
+  scorer: RelevanceScoreProvider;
+  options: RerankerFunctionOptions;
+}) {
   const { queryEmbedding, topK = 3 } = options;
   const weights = {
     ...DEFAULT_WEIGHTS,
@@ -118,7 +116,7 @@ export async function rerank(
       // Get semantic score from chosen provider
       let semanticScore = 0;
       if (result?.metadata?.text) {
-        semanticScore = await semanticProvider.getRelevanceScore(query, result?.metadata?.text);
+        semanticScore = await scorer.getRelevanceScore(query, result?.metadata?.text);
       }
 
       // Get existing vector score from result
@@ -156,3 +154,45 @@ export async function rerank(
   // Sort by score and take top K
   return scoredResults.sort((a, b) => b.score - a.score).slice(0, topK);
 }
+
+export async function rerankWithScorer({
+  results,
+  query,
+  scorer,
+  options,
+}: {
+  results: QueryResult[];
+  query: string;
+  scorer: RelevanceScoreProvider;
+  options: RerankerFunctionOptions;
+}): Promise<RerankResult[]> {
+  return executeRerank({
+    results,
+    query,
+    scorer,
+    options,
+  });
+}
+
+// Takes in a list of results from a vector store and reranks them based on semantic, vector, and position scores
+export async function rerank(
+  results: QueryResult[],
+  query: string,
+  model: MastraLanguageModel,
+  options: RerankerFunctionOptions,
+): Promise<RerankResult[]> {
+  let semanticProvider: RelevanceScoreProvider;
+
+  if (model.modelId === 'rerank-v3.5') {
+    semanticProvider = new CohereRelevanceScorer(model.modelId);
+  } else {
+    semanticProvider = new MastraAgentRelevanceScorer(model.provider, model);
+  }
+
+  return executeRerank({
+    results,
+    query,
+    scorer: semanticProvider,
+    options,
+  });
+}

package/src/rerank/relevance/cohere/index.ts

@@ -0,0 +1,26 @@
+import type { RelevanceScoreProvider } from '@mastra/core/relevance';
+import { CohereClient } from 'cohere-ai';
+
+// Cohere implementation
+export class CohereRelevanceScorer implements RelevanceScoreProvider {
+  private client: any;
+  private model: string;
+  constructor(model: string, apiKey?: string) {
+    this.client = new CohereClient({
+      token: apiKey || process.env.COHERE_API_KEY || '',
+    });
+
+    this.model = model;
+  }
+
+  async getRelevanceScore(query: string, text: string): Promise<number> {
+    const response = await this.client.rerank({
+      query,
+      documents: [text],
+      model: this.model,
+      topN: 1,
+    });
+
+    return response.results[0].relevanceScore;
+  }
+}

package/src/rerank/relevance/index.ts

@@ -0,0 +1,3 @@
+export * from './cohere';
+export * from './mastra-agent';
+export * from './zeroentropy';

package/src/rerank/relevance/mastra-agent/index.ts

@@ -0,0 +1,32 @@
+import { Agent } from '@mastra/core/agent';
+import type { MastraLanguageModel } from '@mastra/core/agent';
+import { createSimilarityPrompt } from '@mastra/core/relevance';
+import type { RelevanceScoreProvider } from '@mastra/core/relevance';
+
+// Mastra Agent implementation
+export class MastraAgentRelevanceScorer implements RelevanceScoreProvider {
+  private agent: Agent;
+
+  constructor(name: string, model: MastraLanguageModel) {
+    this.agent = new Agent({
+      name: `Relevance Scorer ${name}`,
+      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.
+Output only a number between 0 and 1, where:
+1.0 = Perfectly relevant, directly answers the query
+0.0 = Completely irrelevant
+Consider:
+- Direct relevance to the question
+- Completeness of information
+- Quality and specificity
+Always return just the number, no explanation.`,
+      model,
+    });
+  }
+
+  async getRelevanceScore(query: string, text: string): Promise<number> {
+    const prompt = createSimilarityPrompt(query, text);
+    const response = await this.agent.generate(prompt);
+    return parseFloat(response.text);
+  }
+}

package/src/rerank/relevance/zeroentropy/index.ts

@@ -0,0 +1,26 @@
+import type { RelevanceScoreProvider } from '@mastra/core/relevance';
+import ZeroEntropy from 'zeroentropy';
+
+// ZeroEntropy implementation
+export class ZeroEntropyRelevanceScorer implements RelevanceScoreProvider {
+  private client: ZeroEntropy;
+  private model: string;
+
+  constructor(model?: string, apiKey?: string) {
+    this.client = new ZeroEntropy({
+      apiKey: apiKey || process.env.ZEROENTROPY_API_KEY || '',
+    });
+    this.model = model || 'zerank-1';
+  }
+
+  async getRelevanceScore(query: string, text: string): Promise<number> {
+    const response = await this.client.models.rerank({
+      query,
+      documents: [text],
+      model: this.model,
+      top_n: 1,
+    });
+
+    return response.results[0]?.relevance_score ?? 0;
+  }
+}

package/src/tools/vector-query.test.ts

@@ -44,11 +44,13 @@ describe('createVectorQueryTool', () => {
       debug: vi.fn(),
       warn: vi.fn(),
       info: vi.fn(),
+      error: vi.fn(),
     },
     getLogger: vi.fn(() => ({
       debug: vi.fn(),
       warn: vi.fn(),
       info: vi.fn(),
+      error: vi.fn(),
     })),
   };
 

package/src/tools/vector-query.ts

@@ -2,8 +2,8 @@ import { createTool } from '@mastra/core/tools';
 import type { EmbeddingModel } from 'ai';
 import { z } from 'zod';
 
-import { rerank } from '../rerank';
-import type { RerankConfig } from '../rerank';
+import { rerank, rerankWithScorer } from '../rerank';
+import type { RerankConfig, RerankResult } from '../rerank';
 import { vectorQuerySearch, defaultVectorQueryDescription, filterSchema, outputSchema, baseSchema } from '../utils';
 import type { RagTool } from '../utils';
 import { convertToSources } from '../utils/convert-sources';
@@ -94,26 +94,48 @@ export const createVectorQueryTool = (options: VectorQueryToolOptions) => {
         if (logger) {
           logger.debug('vectorQuerySearch returned results', { count: results.length });
         }
+
         if (reranker) {
           if (logger) {
             logger.debug('Reranking results', { rerankerModel: reranker.model, rerankerOptions: reranker.options });
           }
-          const rerankedResults = await rerank(results, queryText, reranker.model, {
-            ...reranker.options,
-            topK: reranker.options?.topK || topKValue,
-          });
+
+          let rerankedResults: RerankResult[] = [];
+
+          if (typeof reranker?.model === 'object' && 'getRelevanceScore' in reranker?.model) {
+            rerankedResults = await rerankWithScorer({
+              results,
+              query: queryText,
+              scorer: reranker.model,
+              options: {
+                ...reranker.options,
+                topK: reranker.options?.topK || topKValue,
+              },
+            });
+          } else {
+            rerankedResults = await rerank(results, queryText, reranker.model, {
+              ...reranker.options,
+              topK: reranker.options?.topK || topKValue,
+            });
+          }
+
           if (logger) {
             logger.debug('Reranking complete', { rerankedCount: rerankedResults.length });
           }
+
           const relevantChunks = rerankedResults.map(({ result }) => result?.metadata);
+
           if (logger) {
             logger.debug('Returning reranked relevant context chunks', { count: relevantChunks.length });
           }
+
           const sources = includeSources ? convertToSources(rerankedResults) : [];
+
           return { relevantContext: relevantChunks, sources };
         }
 
         const relevantChunks = results.map(result => result?.metadata);
+
         if (logger) {
           logger.debug('Returning relevant context chunks', { count: relevantChunks.length });
         }