@mastra/evals 1.6.0 → 1.7.0

package/dist/checks-DGTgg-nW.cjs

@@ -0,0 +1,479 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+const require_scorers_utils = require("./scorers/utils.cjs");
+let _mastra_core_evals = require("@mastra/core/evals");
+let string_similarity = require("string-similarity");
+string_similarity = __toESM(string_similarity, 1);
+//#region src/scorers/code/checks/index.ts
+/**
+* Scores 1 if the agent's output text contains the expected substring, 0 otherwise.
+*
+* @example
+* ```ts
+* import { checks } from '@mastra/evals';
+* const scorer = checks.includes('sunny');
+* ```
+*/
+function includes(expected, options = {}) {
+	const { ignoreCase = true } = options;
+	return (0, _mastra_core_evals.createScorer)({
+		id: "check-includes",
+		name: "Includes Check",
+		description: `Checks if output includes "${expected}"`,
+		type: "agent"
+	}).preprocess(async ({ run }) => {
+		let output = run.output.filter((m) => m.role === "assistant").map((m) => require_scorers_utils.getTextContentFromMastraDBMessage(m)).join(" ");
+		let target = expected;
+		if (ignoreCase) {
+			output = output.toLowerCase();
+			target = target.toLowerCase();
+		}
+		return {
+			output,
+			target,
+			found: output.includes(target)
+		};
+	}).generateScore(({ results }) => {
+		return results.preprocessStepResult?.found ? 1 : 0;
+	});
+}
+/**
+* Scores 1 if the agent's output text does NOT contain the substring, 0 otherwise.
+*
+* @example
+* ```ts
+* import { checks } from '@mastra/evals';
+* const scorer = checks.excludes('error');
+* ```
+*/
+function excludes(unwanted, options = {}) {
+	const { ignoreCase = true } = options;
+	return (0, _mastra_core_evals.createScorer)({
+		id: "check-excludes",
+		name: "Excludes Check",
+		description: `Checks that output does not include "${unwanted}"`,
+		type: "agent"
+	}).preprocess(async ({ run }) => {
+		let output = run.output.filter((m) => m.role === "assistant").map((m) => require_scorers_utils.getTextContentFromMastraDBMessage(m)).join(" ");
+		let target = unwanted;
+		if (ignoreCase) {
+			output = output.toLowerCase();
+			target = target.toLowerCase();
+		}
+		return {
+			output,
+			target,
+			excluded: !output.includes(target)
+		};
+	}).generateScore(({ results }) => {
+		return results.preprocessStepResult?.excluded ? 1 : 0;
+	});
+}
+/**
+* Scores 1 if the output text exactly equals the expected string (after optional normalization).
+*
+* @example
+* ```ts
+* import { checks } from '@mastra/evals';
+* const scorer = checks.equals('Hello, world!');
+* ```
+*/
+function equals(expected, options = {}) {
+	const { ignoreCase = true } = options;
+	return (0, _mastra_core_evals.createScorer)({
+		id: "check-equals",
+		name: "Equals Check",
+		description: `Checks if output equals "${expected}"`,
+		type: "agent"
+	}).preprocess(async ({ run }) => {
+		let output = run.output.filter((m) => m.role === "assistant").map((m) => require_scorers_utils.getTextContentFromMastraDBMessage(m)).join("");
+		let target = expected;
+		if (ignoreCase) {
+			output = output.toLowerCase();
+			target = target.toLowerCase();
+		}
+		return {
+			output,
+			target,
+			isEqual: output === target
+		};
+	}).generateScore(({ results }) => {
+		return results.preprocessStepResult?.isEqual ? 1 : 0;
+	});
+}
+/**
+* Scores 1 if the output matches the given regular expression, 0 otherwise.
+*
+* @example
+* ```ts
+* import { checks } from '@mastra/evals';
+* const scorer = checks.matches(/\d{1,3}°[FC]/);
+* ```
+*/
+function matches(pattern, options = {}) {
+	const { exact = false } = options;
+	return (0, _mastra_core_evals.createScorer)({
+		id: "check-matches",
+		name: "Matches Check",
+		description: `Checks if output matches pattern ${pattern}`,
+		type: "agent"
+	}).preprocess(async ({ run }) => {
+		const output = run.output.filter((m) => m.role === "assistant").map((m) => require_scorers_utils.getTextContentFromMastraDBMessage(m)).join("");
+		const matched = (exact ? new RegExp(`^${pattern.source}$`, pattern.flags) : pattern).test(output);
+		return {
+			output,
+			pattern: pattern.toString(),
+			matched
+		};
+	}).generateScore(({ results }) => {
+		return results.preprocessStepResult?.matched ? 1 : 0;
+	});
+}
+/**
+* Returns the string similarity score (0-1) between the output and an expected string.
+* Useful for fuzzy matching when exact equality is too strict.
+*
+* @example
+* ```ts
+* import { checks } from '@mastra/evals';
+* const scorer = checks.similarity('Sunny, 72°F');
+* ```
+*/
+function similarity(expected, options = {}) {
+	const { ignoreCase = true, threshold } = options;
+	return (0, _mastra_core_evals.createScorer)({
+		id: "check-similarity",
+		name: "Similarity Check",
+		description: `Checks string similarity to "${expected}"`,
+		type: "agent"
+	}).preprocess(async ({ run }) => {
+		let output = run.output.filter((m) => m.role === "assistant").map((m) => require_scorers_utils.getTextContentFromMastraDBMessage(m)).join(" ");
+		let target = expected;
+		if (ignoreCase) {
+			output = output.toLowerCase();
+			target = target.toLowerCase();
+		}
+		const score = string_similarity.default.compareTwoStrings(output, target);
+		return {
+			output,
+			target,
+			score,
+			threshold
+		};
+	}).generateScore(({ results }) => {
+		const score = results.preprocessStepResult?.score ?? 0;
+		const t = results.preprocessStepResult?.threshold;
+		return t !== void 0 ? score >= t ? 1 : 0 : score;
+	});
+}
+/**
+* Scores 1 if the agent called the specified tool (at least `times` times).
+*
+* @example
+* ```ts
+* import { checks } from '@mastra/evals';
+* const scorer = checks.calledTool('get_weather');
+* const twice = checks.calledTool('search', { times: 2 });
+* ```
+*/
+function calledTool(toolName, options = {}) {
+	const { times = 1 } = options;
+	return (0, _mastra_core_evals.createScorer)({
+		id: "check-called-tool",
+		name: "Called Tool Check",
+		description: `Checks that "${toolName}" was called${times > 1 ? ` at least ${times} times` : ""}`,
+		type: "agent"
+	}).preprocess(async ({ run }) => {
+		const { tools } = require_scorers_utils.extractToolCalls(run.output);
+		const count = tools.filter((t) => t === toolName).length;
+		return {
+			toolName,
+			expectedTimes: times,
+			actualCount: count,
+			passed: count >= times
+		};
+	}).generateScore(({ results }) => {
+		return results.preprocessStepResult?.passed ? 1 : 0;
+	});
+}
+/**
+* Scores 1 if the agent did NOT call the specified tool.
+*
+* @example
+* ```ts
+* import { checks } from '@mastra/evals';
+* const scorer = checks.didNotCall('delete_user');
+* ```
+*/
+function didNotCall(toolName) {
+	return (0, _mastra_core_evals.createScorer)({
+		id: "check-did-not-call",
+		name: "Did Not Call Check",
+		description: `Checks that "${toolName}" was NOT called`,
+		type: "agent"
+	}).preprocess(async ({ run }) => {
+		const { tools } = require_scorers_utils.extractToolCalls(run.output);
+		const count = tools.filter((t) => t === toolName).length;
+		return {
+			toolName,
+			count,
+			passed: count === 0
+		};
+	}).generateScore(({ results }) => {
+		return results.preprocessStepResult?.passed ? 1 : 0;
+	});
+}
+/**
+* Scores 1 if the tools were called in the specified order (relaxed: allows other calls in between).
+*
+* @example
+* ```ts
+* import { checks } from '@mastra/evals';
+* const scorer = checks.toolOrder(['search', 'summarize', 'respond']);
+* ```
+*/
+function toolOrder(expectedOrder) {
+	return (0, _mastra_core_evals.createScorer)({
+		id: "check-tool-order",
+		name: "Tool Order Check",
+		description: `Checks tool call order: [${expectedOrder.join(" → ")}]`,
+		type: "agent"
+	}).preprocess(async ({ run }) => {
+		const { tools } = require_scorers_utils.extractToolCalls(run.output);
+		let orderIndex = 0;
+		for (const tool of tools) if (orderIndex < expectedOrder.length && tool === expectedOrder[orderIndex]) orderIndex++;
+		return {
+			actualTools: tools,
+			expectedOrder,
+			passed: orderIndex === expectedOrder.length
+		};
+	}).generateScore(({ results }) => {
+		return results.preprocessStepResult?.passed ? 1 : 0;
+	});
+}
+/**
+* Scores 1 if the agent used no more than `max` tool calls.
+*
+* @example
+* ```ts
+* import { checks } from '@mastra/evals';
+* const scorer = checks.maxToolCalls(5);
+* ```
+*/
+function maxToolCalls(max) {
+	return (0, _mastra_core_evals.createScorer)({
+		id: "check-max-tool-calls",
+		name: "Max Tool Calls Check",
+		description: `Checks that no more than ${max} tool calls were made`,
+		type: "agent"
+	}).preprocess(async ({ run }) => {
+		const { tools } = require_scorers_utils.extractToolCalls(run.output);
+		return {
+			count: tools.length,
+			max,
+			passed: tools.length <= max
+		};
+	}).generateScore(({ results }) => {
+		return results.preprocessStepResult?.passed ? 1 : 0;
+	});
+}
+/**
+* Scores 1 if the agent made no tool calls at all.
+*
+* @example
+* ```ts
+* import { checks } from '@mastra/evals';
+* const scorer = checks.usedNoTools();
+* ```
+*/
+function usedNoTools() {
+	return (0, _mastra_core_evals.createScorer)({
+		id: "check-used-no-tools",
+		name: "Used No Tools Check",
+		description: "Checks that no tools were called",
+		type: "agent"
+	}).preprocess(async ({ run }) => {
+		const { tools } = require_scorers_utils.extractToolCalls(run.output);
+		return {
+			count: tools.length,
+			passed: tools.length === 0
+		};
+	}).generateScore(({ results }) => {
+		return results.preprocessStepResult?.passed ? 1 : 0;
+	});
+}
+/**
+* Scores 1 if none of the tool invocations resulted in an error state.
+* Checks for tool invocations with state other than 'result' (i.e., missing results).
+*
+* @example
+* ```ts
+* import { checks } from '@mastra/evals';
+* const scorer = checks.noToolErrors();
+* ```
+*/
+function noToolErrors() {
+	return (0, _mastra_core_evals.createScorer)({
+		id: "check-no-tool-errors",
+		name: "No Tool Errors Check",
+		description: "Checks that no tool calls resulted in errors",
+		type: "agent"
+	}).preprocess(async ({ run }) => {
+		const invocations = extractRawInvocations(run.output);
+		const errorCount = invocations.filter((inv) => inv.state === "call" || inv.result && inv.result.error).length;
+		return {
+			errorCount,
+			totalCalls: invocations.length,
+			passed: errorCount === 0
+		};
+	}).generateScore(({ results }) => {
+		return results.preprocessStepResult?.passed ? 1 : 0;
+	});
+}
+function extractRawInvocations(output) {
+	const invocations = [];
+	for (const message of output) {
+		const legacy = message?.content?.toolInvocations;
+		const fromParts = legacy ? void 0 : (message?.content)?.parts?.filter((p) => p.type === "tool-invocation").map((p) => p.toolInvocation);
+		for (const inv of legacy ?? fromParts ?? []) if (inv) invocations.push(inv);
+	}
+	return invocations;
+}
+/**
+* Quick Checks — composable micro-scorers for common assertions.
+*
+* These are zero-LLM, zero-ceremony scorers that plug into the existing
+* `scorers: [...]` array anywhere scorers are used. Internally they are
+* standard `createScorer()` instances with the same observability, storage,
+* and pipeline integration as any other scorer.
+*
+* @example
+* ```ts
+* import { checks } from '@mastra/evals';
+*
+* await runEvals({
+*   data: [...],
+*   target: myAgent,
+*   scorers: [
+*     checks.includes('sunny'),
+*     checks.calledTool('get_weather'),
+*     checks.toolOrder(['search', 'summarize']),
+*     checks.noToolErrors(),
+*   ],
+* });
+* ```
+*/
+const checks = {
+	includes,
+	excludes,
+	equals,
+	matches,
+	similarity,
+	calledTool,
+	didNotCall,
+	toolOrder,
+	maxToolCalls,
+	usedNoTools,
+	noToolErrors
+};
+//#endregion
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "calledTool", {
+	enumerable: true,
+	get: function() {
+		return calledTool;
+	}
+});
+Object.defineProperty(exports, "checks", {
+	enumerable: true,
+	get: function() {
+		return checks;
+	}
+});
+Object.defineProperty(exports, "didNotCall", {
+	enumerable: true,
+	get: function() {
+		return didNotCall;
+	}
+});
+Object.defineProperty(exports, "equals", {
+	enumerable: true,
+	get: function() {
+		return equals;
+	}
+});
+Object.defineProperty(exports, "excludes", {
+	enumerable: true,
+	get: function() {
+		return excludes;
+	}
+});
+Object.defineProperty(exports, "includes", {
+	enumerable: true,
+	get: function() {
+		return includes;
+	}
+});
+Object.defineProperty(exports, "matches", {
+	enumerable: true,
+	get: function() {
+		return matches;
+	}
+});
+Object.defineProperty(exports, "maxToolCalls", {
+	enumerable: true,
+	get: function() {
+		return maxToolCalls;
+	}
+});
+Object.defineProperty(exports, "noToolErrors", {
+	enumerable: true,
+	get: function() {
+		return noToolErrors;
+	}
+});
+Object.defineProperty(exports, "similarity", {
+	enumerable: true,
+	get: function() {
+		return similarity;
+	}
+});
+Object.defineProperty(exports, "toolOrder", {
+	enumerable: true,
+	get: function() {
+		return toolOrder;
+	}
+});
+Object.defineProperty(exports, "usedNoTools", {
+	enumerable: true,
+	get: function() {
+		return usedNoTools;
+	}
+});
+
+//# sourceMappingURL=checks-DGTgg-nW.cjs.map

package/dist/checks-DGTgg-nW.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"checks-DGTgg-nW.cjs","names":["getTextContentFromMastraDBMessage","stringSimilarity","extractToolCalls"],"sources":["../src/scorers/code/checks/index.ts"],"sourcesContent":["import { createScorer } from '@mastra/core/evals';\nimport stringSimilarity from 'string-similarity';\nimport { extractToolCalls, getTextContentFromMastraDBMessage } from '../../utils';\n\n// ─── Output Text Checks ───────────────────────────────────────────────────────\n\nexport interface IncludesOptions {\n  /** Case-insensitive match (default: true) */\n  ignoreCase?: boolean;\n}\n\n/**\n * Scores 1 if the agent's output text contains the expected substring, 0 otherwise.\n *\n * @example\n * ```ts\n * import { checks } from '@mastra/evals';\n * const scorer = checks.includes('sunny');\n * ```\n */\nexport function includes(expected: string, options: IncludesOptions = {}) {\n  const { ignoreCase = true } = options;\n  return createScorer({\n    id: 'check-includes',\n    name: 'Includes Check',\n    description: `Checks if output includes \"${expected}\"`,\n    type: 'agent',\n  })\n    .preprocess(async ({ run }) => {\n      let output = run.output\n        .filter(m => m.role === 'assistant')\n        .map(m => getTextContentFromMastraDBMessage(m))\n        .join(' ');\n      let target = expected;\n      if (ignoreCase) {\n        output = output.toLowerCase();\n        target = target.toLowerCase();\n      }\n      return { output, target, found: output.includes(target) };\n    })\n    .generateScore(({ results }) => {\n      return results.preprocessStepResult?.found ? 1 : 0;\n    });\n}\n\n/**\n * Scores 1 if the agent's output text does NOT contain the substring, 0 otherwise.\n *\n * @example\n * ```ts\n * import { checks } from '@mastra/evals';\n * const scorer = checks.excludes('error');\n * ```\n */\nexport function excludes(unwanted: string, options: IncludesOptions = {}) {\n  const { ignoreCase = true } = options;\n  return createScorer({\n    id: 'check-excludes',\n    name: 'Excludes Check',\n    description: `Checks that output does not include \"${unwanted}\"`,\n    type: 'agent',\n  })\n    .preprocess(async ({ run }) => {\n      let output = run.output\n        .filter(m => m.role === 'assistant')\n        .map(m => getTextContentFromMastraDBMessage(m))\n        .join(' ');\n      let target = unwanted;\n      if (ignoreCase) {\n        output = output.toLowerCase();\n        target = target.toLowerCase();\n      }\n      return { output, target, excluded: !output.includes(target) };\n    })\n    .generateScore(({ results }) => {\n      return results.preprocessStepResult?.excluded ? 1 : 0;\n    });\n}\n\n/**\n * Scores 1 if the output text exactly equals the expected string (after optional normalization).\n *\n * @example\n * ```ts\n * import { checks } from '@mastra/evals';\n * const scorer = checks.equals('Hello, world!');\n * ```\n */\nexport function equals(expected: string, options: IncludesOptions = {}) {\n  const { ignoreCase = true } = options;\n  return createScorer({\n    id: 'check-equals',\n    name: 'Equals Check',\n    description: `Checks if output equals \"${expected}\"`,\n    type: 'agent',\n  })\n    .preprocess(async ({ run }) => {\n      let output = run.output\n        .filter(m => m.role === 'assistant')\n        .map(m => getTextContentFromMastraDBMessage(m))\n        .join('');\n      let target = expected;\n      if (ignoreCase) {\n        output = output.toLowerCase();\n        target = target.toLowerCase();\n      }\n      return { output, target, isEqual: output === target };\n    })\n    .generateScore(({ results }) => {\n      return results.preprocessStepResult?.isEqual ? 1 : 0;\n    });\n}\n\nexport interface MatchesOptions {\n  /** If true, the output must match the pattern exactly (anchored). Default: false (substring match). */\n  exact?: boolean;\n}\n\n/**\n * Scores 1 if the output matches the given regular expression, 0 otherwise.\n *\n * @example\n * ```ts\n * import { checks } from '@mastra/evals';\n * const scorer = checks.matches(/\\d{1,3}°[FC]/);\n * ```\n */\nexport function matches(pattern: RegExp, options: MatchesOptions = {}) {\n  const { exact = false } = options;\n  return createScorer({\n    id: 'check-matches',\n    name: 'Matches Check',\n    description: `Checks if output matches pattern ${pattern}`,\n    type: 'agent',\n  })\n    .preprocess(async ({ run }) => {\n      const output = run.output\n        .filter(m => m.role === 'assistant')\n        .map(m => getTextContentFromMastraDBMessage(m))\n        .join('');\n      const regex = exact ? new RegExp(`^${pattern.source}$`, pattern.flags) : pattern;\n      const matched = regex.test(output);\n      return { output, pattern: pattern.toString(), matched };\n    })\n    .generateScore(({ results }) => {\n      return results.preprocessStepResult?.matched ? 1 : 0;\n    });\n}\n\nexport interface SimilarityOptions {\n  /** Minimum similarity threshold (0-1) to score 1. Default: 0.7 */\n  threshold?: number;\n  /** Case-insensitive comparison (default: true) */\n  ignoreCase?: boolean;\n}\n\n/**\n * Returns the string similarity score (0-1) between the output and an expected string.\n * Useful for fuzzy matching when exact equality is too strict.\n *\n * @example\n * ```ts\n * import { checks } from '@mastra/evals';\n * const scorer = checks.similarity('Sunny, 72°F');\n * ```\n */\nexport function similarity(expected: string, options: SimilarityOptions = {}) {\n  const { ignoreCase = true, threshold } = options;\n  return createScorer({\n    id: 'check-similarity',\n    name: 'Similarity Check',\n    description: `Checks string similarity to \"${expected}\"`,\n    type: 'agent',\n  })\n    .preprocess(async ({ run }) => {\n      let output = run.output\n        .filter(m => m.role === 'assistant')\n        .map(m => getTextContentFromMastraDBMessage(m))\n        .join(' ');\n      let target = expected;\n      if (ignoreCase) {\n        output = output.toLowerCase();\n        target = target.toLowerCase();\n      }\n      const score = stringSimilarity.compareTwoStrings(output, target);\n      return { output, target, score, threshold };\n    })\n    .generateScore(({ results }) => {\n      const score = results.preprocessStepResult?.score ?? 0;\n      const t = results.preprocessStepResult?.threshold;\n      return t !== undefined ? (score >= t ? 1 : 0) : score;\n    });\n}\n\n// ─── Tool Call Checks ─────────────────────────────────────────────────────────\n\nexport interface CalledToolOptions {\n  /** Minimum number of times the tool must be called. Default: 1 */\n  times?: number;\n}\n\n/**\n * Scores 1 if the agent called the specified tool (at least `times` times).\n *\n * @example\n * ```ts\n * import { checks } from '@mastra/evals';\n * const scorer = checks.calledTool('get_weather');\n * const twice = checks.calledTool('search', { times: 2 });\n * ```\n */\nexport function calledTool(toolName: string, options: CalledToolOptions = {}) {\n  const { times = 1 } = options;\n  return createScorer({\n    id: 'check-called-tool',\n    name: 'Called Tool Check',\n    description: `Checks that \"${toolName}\" was called${times > 1 ? ` at least ${times} times` : ''}`,\n    type: 'agent',\n  })\n    .preprocess(async ({ run }) => {\n      const { tools } = extractToolCalls(run.output);\n      const count = tools.filter(t => t === toolName).length;\n      return { toolName, expectedTimes: times, actualCount: count, passed: count >= times };\n    })\n    .generateScore(({ results }) => {\n      return results.preprocessStepResult?.passed ? 1 : 0;\n    });\n}\n\n/**\n * Scores 1 if the agent did NOT call the specified tool.\n *\n * @example\n * ```ts\n * import { checks } from '@mastra/evals';\n * const scorer = checks.didNotCall('delete_user');\n * ```\n */\nexport function didNotCall(toolName: string) {\n  return createScorer({\n    id: 'check-did-not-call',\n    name: 'Did Not Call Check',\n    description: `Checks that \"${toolName}\" was NOT called`,\n    type: 'agent',\n  })\n    .preprocess(async ({ run }) => {\n      const { tools } = extractToolCalls(run.output);\n      const count = tools.filter(t => t === toolName).length;\n      return { toolName, count, passed: count === 0 };\n    })\n    .generateScore(({ results }) => {\n      return results.preprocessStepResult?.passed ? 1 : 0;\n    });\n}\n\n/**\n * Scores 1 if the tools were called in the specified order (relaxed: allows other calls in between).\n *\n * @example\n * ```ts\n * import { checks } from '@mastra/evals';\n * const scorer = checks.toolOrder(['search', 'summarize', 'respond']);\n * ```\n */\nexport function toolOrder(expectedOrder: string[]) {\n  return createScorer({\n    id: 'check-tool-order',\n    name: 'Tool Order Check',\n    description: `Checks tool call order: [${expectedOrder.join(' → ')}]`,\n    type: 'agent',\n  })\n    .preprocess(async ({ run }) => {\n      const { tools } = extractToolCalls(run.output);\n      // Check that expectedOrder appears as a subsequence of tools\n      let orderIndex = 0;\n      for (const tool of tools) {\n        if (orderIndex < expectedOrder.length && tool === expectedOrder[orderIndex]) {\n          orderIndex++;\n        }\n      }\n      const passed = orderIndex === expectedOrder.length;\n      return { actualTools: tools, expectedOrder, passed };\n    })\n    .generateScore(({ results }) => {\n      return results.preprocessStepResult?.passed ? 1 : 0;\n    });\n}\n\n/**\n * Scores 1 if the agent used no more than `max` tool calls.\n *\n * @example\n * ```ts\n * import { checks } from '@mastra/evals';\n * const scorer = checks.maxToolCalls(5);\n * ```\n */\nexport function maxToolCalls(max: number) {\n  return createScorer({\n    id: 'check-max-tool-calls',\n    name: 'Max Tool Calls Check',\n    description: `Checks that no more than ${max} tool calls were made`,\n    type: 'agent',\n  })\n    .preprocess(async ({ run }) => {\n      const { tools } = extractToolCalls(run.output);\n      return { count: tools.length, max, passed: tools.length <= max };\n    })\n    .generateScore(({ results }) => {\n      return results.preprocessStepResult?.passed ? 1 : 0;\n    });\n}\n\n/**\n * Scores 1 if the agent made no tool calls at all.\n *\n * @example\n * ```ts\n * import { checks } from '@mastra/evals';\n * const scorer = checks.usedNoTools();\n * ```\n */\nexport function usedNoTools() {\n  return createScorer({\n    id: 'check-used-no-tools',\n    name: 'Used No Tools Check',\n    description: 'Checks that no tools were called',\n    type: 'agent',\n  })\n    .preprocess(async ({ run }) => {\n      const { tools } = extractToolCalls(run.output);\n      return { count: tools.length, passed: tools.length === 0 };\n    })\n    .generateScore(({ results }) => {\n      return results.preprocessStepResult?.passed ? 1 : 0;\n    });\n}\n\n/**\n * Scores 1 if none of the tool invocations resulted in an error state.\n * Checks for tool invocations with state other than 'result' (i.e., missing results).\n *\n * @example\n * ```ts\n * import { checks } from '@mastra/evals';\n * const scorer = checks.noToolErrors();\n * ```\n */\nexport function noToolErrors() {\n  return createScorer({\n    id: 'check-no-tool-errors',\n    name: 'No Tool Errors Check',\n    description: 'Checks that no tool calls resulted in errors',\n    type: 'agent',\n  })\n    .preprocess(async ({ run }) => {\n      const invocations = extractRawInvocations(run.output);\n      const errorCount = invocations.filter(inv => inv.state === 'call' || (inv.result && inv.result.error)).length;\n      return { errorCount, totalCalls: invocations.length, passed: errorCount === 0 };\n    })\n    .generateScore(({ results }) => {\n      return results.preprocessStepResult?.passed ? 1 : 0;\n    });\n}\n\n// ─── Internal helpers ──────────────────────────────────────────────────────────\n\nfunction extractRawInvocations(output: Parameters<typeof extractToolCalls>[0]) {\n  const invocations: any[] = [];\n  for (const message of output) {\n    const legacy = message?.content?.toolInvocations;\n    const fromParts = legacy\n      ? undefined\n      : (message?.content as any)?.parts\n          ?.filter((p: any) => p.type === 'tool-invocation')\n          .map((p: any) => p.toolInvocation);\n    for (const inv of legacy ?? fromParts ?? []) {\n      if (inv) invocations.push(inv);\n    }\n  }\n  return invocations;\n}\n\n// ─── Convenience namespace ────────────────────────────────────────────────────\n\n/**\n * Quick Checks — composable micro-scorers for common assertions.\n *\n * These are zero-LLM, zero-ceremony scorers that plug into the existing\n * `scorers: [...]` array anywhere scorers are used. Internally they are\n * standard `createScorer()` instances with the same observability, storage,\n * and pipeline integration as any other scorer.\n *\n * @example\n * ```ts\n * import { checks } from '@mastra/evals';\n *\n * await runEvals({\n *   data: [...],\n *   target: myAgent,\n *   scorers: [\n *     checks.includes('sunny'),\n *     checks.calledTool('get_weather'),\n *     checks.toolOrder(['search', 'summarize']),\n *     checks.noToolErrors(),\n *   ],\n * });\n * ```\n */\nexport const checks = {\n  includes,\n  excludes,\n  equals,\n  matches,\n  similarity,\n  calledTool,\n  didNotCall,\n  toolOrder,\n  maxToolCalls,\n  usedNoTools,\n  noToolErrors,\n};\n"],"mappings":"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"}

package/dist/checks.cjs

@@ -1,56 +1,14 @@
-'use strict';
-
-var chunkGGHVFNVI_cjs = require('./chunk-GGHVFNVI.cjs');
-
-
-
-Object.defineProperty(exports, "calledTool", {
-  enumerable: true,
-  get: function () { return chunkGGHVFNVI_cjs.calledTool; }
-});
-Object.defineProperty(exports, "checks", {
-  enumerable: true,
-  get: function () { return chunkGGHVFNVI_cjs.checks; }
-});
-Object.defineProperty(exports, "didNotCall", {
-  enumerable: true,
-  get: function () { return chunkGGHVFNVI_cjs.didNotCall; }
-});
-Object.defineProperty(exports, "equals", {
-  enumerable: true,
-  get: function () { return chunkGGHVFNVI_cjs.equals; }
-});
-Object.defineProperty(exports, "excludes", {
-  enumerable: true,
-  get: function () { return chunkGGHVFNVI_cjs.excludes; }
-});
-Object.defineProperty(exports, "includes", {
-  enumerable: true,
-  get: function () { return chunkGGHVFNVI_cjs.includes; }
-});
-Object.defineProperty(exports, "matches", {
-  enumerable: true,
-  get: function () { return chunkGGHVFNVI_cjs.matches; }
-});
-Object.defineProperty(exports, "maxToolCalls", {
-  enumerable: true,
-  get: function () { return chunkGGHVFNVI_cjs.maxToolCalls; }
-});
-Object.defineProperty(exports, "noToolErrors", {
-  enumerable: true,
-  get: function () { return chunkGGHVFNVI_cjs.noToolErrors; }
-});
-Object.defineProperty(exports, "similarity", {
-  enumerable: true,
-  get: function () { return chunkGGHVFNVI_cjs.similarity; }
-});
-Object.defineProperty(exports, "toolOrder", {
-  enumerable: true,
-  get: function () { return chunkGGHVFNVI_cjs.toolOrder; }
-});
-Object.defineProperty(exports, "usedNoTools", {
-  enumerable: true,
-  get: function () { return chunkGGHVFNVI_cjs.usedNoTools; }
-});
-//# sourceMappingURL=checks.cjs.map
-//# sourceMappingURL=checks.cjs.map
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_checks = require("./checks-DGTgg-nW.cjs");
+exports.calledTool = require_checks.calledTool;
+exports.checks = require_checks.checks;
+exports.didNotCall = require_checks.didNotCall;
+exports.equals = require_checks.equals;
+exports.excludes = require_checks.excludes;
+exports.includes = require_checks.includes;
+exports.matches = require_checks.matches;
+exports.maxToolCalls = require_checks.maxToolCalls;
+exports.noToolErrors = require_checks.noToolErrors;
+exports.similarity = require_checks.similarity;
+exports.toolOrder = require_checks.toolOrder;
+exports.usedNoTools = require_checks.usedNoTools;

package/dist/checks.js

@@ -1,3 +1,2 @@
-export { calledTool, checks, didNotCall, equals, excludes, includes, matches, maxToolCalls, noToolErrors, similarity, toolOrder, usedNoTools } from './chunk-WEADJCUA.js';
-//# sourceMappingURL=checks.js.map
-//# sourceMappingURL=checks.js.map
+import { a as excludes, c as maxToolCalls, d as toolOrder, f as usedNoTools, i as equals, l as noToolErrors, n as checks, o as includes, r as didNotCall, s as matches, t as calledTool, u as similarity } from "./checks-64AonnEK.js";
+export { calledTool, checks, didNotCall, equals, excludes, includes, matches, maxToolCalls, noToolErrors, similarity, toolOrder, usedNoTools };

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-evals
 description: Documentation for @mastra/evals. Use when working with @mastra/evals APIs, configuration, or implementation.
 metadata:
   package: "@mastra/evals"
-  version: "1.6.0"
+  version: "1.7.0"
 ---
 
 ## When to use
@@ -38,6 +38,7 @@ Read the individual reference documents for detailed explanations and code examp
 - [Reference: Prompt alignment scorer](references/reference-evals-prompt-alignment.md) - Documentation for the Prompt Alignment Scorer in Mastra. Evaluates how well agent responses align with user prompt intent, requirements, completeness, and appropriateness using multi-dimensional analysis.
 - [Reference: Rubric scorer](references/reference-evals-rubric.md) - Documentation for the Rubric Scorer in Mastra. An LLM-as-judge scorer that grades an agent output against a checklist of criteria and returns a binary verdict with per-criterion feedback, designed to drive isTaskComplete loops.
 - [Reference: Scorer utils](references/reference-evals-scorer-utils.md) - Utility functions for extracting data from scorer run inputs and outputs, including text content, reasoning, system messages, and tool calls.
+- [Reference: Summarization scorer](references/reference-evals-summarization.md) - Documentation for the Summarization Scorer in Mastra. Evaluates whether a summary stays faithful to its source text and preserves the information the source states.
 - [Reference: Textual difference scorer](references/reference-evals-textual-difference.md) - Documentation for the Textual Difference Scorer in Mastra, which measures textual differences between strings using sequence matching.
 - [Reference: Tone consistency scorer](references/reference-evals-tone-consistency.md) - Documentation for the Tone Consistency Scorer in Mastra, which evaluates emotional tone and sentiment consistency in text.
 - [Reference: Tool call accuracy scorers](references/reference-evals-tool-call-accuracy.md) - Documentation for the Tool Call Accuracy Scorers in Mastra, which evaluate whether LLM outputs call the correct tools from available options.

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.6.0",
+  "version": "1.7.0",
   "package": "@mastra/evals",
   "exports": {},
   "modules": {}

package/dist/docs/references/docs-evals-built-in-scorers.md

@@ -2,7 +2,7 @@
 
 # Built-in scorers
 
-Mastra provides a comprehensive set of built-in scorers for evaluating AI outputs. These scorers are optimized for common evaluation scenarios and are ready to use in your agents and workflows.
+Mastra provides a complete set of built-in scorers for evaluating AI outputs. These scorers are optimized for common evaluation scenarios and are ready to use in your agents and workflows.
 
 To create your own scorers, see the [Custom Scorers](https://mastra.ai/docs/evals/custom-scorers) guide.
 
@@ -20,15 +20,15 @@ These scorers evaluate how correct, truthful, and complete your agent's answers
 - [`content-similarity`](https://mastra.ai/reference/evals/content-similarity): Measures textual similarity using character-level matching (`0-1`, higher is better)
 - [`textual-difference`](https://mastra.ai/reference/evals/textual-difference): Measures textual differences between strings (`0-1`, higher means more similar)
 - [`tool-call-accuracy`](https://mastra.ai/reference/evals/tool-call-accuracy): Evaluates whether the LLM selects the correct tool from available options (`0-1`, higher is better)
-- [`trajectory-accuracy`](https://mastra.ai/reference/evals/trajectory-accuracy): Evaluates whether an agent follows the expected sequence of actions (tool calls, model generations, workflow steps, and other span types) (`0-1`, higher is better)
+- [`trajectory-accuracy`](https://mastra.ai/reference/evals/trajectory-accuracy): Evaluates the expected action sequence for all span types. Covered spans include tool and model activity plus workflow steps (`0-1`, higher is better)
 - [`prompt-alignment`](https://mastra.ai/reference/evals/prompt-alignment): Measures how well agent responses align with user prompt intent, requirements, completeness, and format (`0-1`, higher is better)
 
 ### Context quality
 
 These scorers evaluate the quality and relevance of context used in generating responses:
 
-- [`context-precision`](https://mastra.ai/reference/evals/context-precision): Evaluates context relevance and ranking using Mean Average Precision, rewarding early placement of relevant context (`0-1`, higher is better)
-- [`context-relevance`](https://mastra.ai/reference/evals/context-relevance): Measures context utility with nuanced relevance levels, usage tracking, and missing context detection (`0-1`, higher is better)
+- [`context-precision`](https://mastra.ai/reference/evals/context-precision): Uses Mean Average Precision to evaluate context ranking. Relevant context receives a higher score when it occurs early (`0-1`, higher is better)
+- [`context-relevance`](https://mastra.ai/reference/evals/context-relevance): Measures context utility through relevance levels and usage tracking. It also detects missing context (`0-1`, higher is better)
 
 > **Context Scorer Selection:**
 >