vitest-evals 0.5.0 → 0.7.0

package/README.md

@@ -1,6 +1,6 @@
 # vitest-evals
 
-Evaluate LLM outputs using the familiar Vitest testing framework.
+End-to-end evaluation framework for AI agents, built on Vitest.
 
 ## Installation
 
@@ -13,14 +13,14 @@ npm install -D vitest-evals
 ```javascript
 import { describeEval } from "vitest-evals";
 
-describeEval("capital cities", {
+describeEval("deploy agent", {
   data: async () => [
-    { input: "What is the capital of France?", expected: "Paris" },
-    { input: "What is the capital of Japan?", expected: "Tokyo" },
+    { input: "Deploy the latest release to production", expected: "deployed" },
+    { input: "Roll back the last deploy", expected: "rolled back" },
   ],
   task: async (input) => {
-    const response = await queryLLM(input);
-    return response; // Simple string return
+    const response = await myAgent.run(input);
+    return response;
   },
   scorers: [
     async ({ output, expected }) => ({
@@ -48,50 +48,49 @@ const task = async (input) => ({
 });
 ```
 
-## Scorers
+## Test Data
 
-Scorers evaluate outputs and return a score (0-1). Use built-in scorers or create your own:
+Each test case requires an `input` field. Use `name` to give tests a descriptive label:
 
 ```javascript
-// Built-in scorer
-import { ToolCallScorer } from "vitest-evals";
-// Or import individually
-import { ToolCallScorer } from "vitest-evals/scorers/toolCallScorer";
+data: async () => [
+  { name: "simple deploy", input: "Deploy to staging" },
+  { name: "deploy with rollback", input: "Deploy to prod, roll back if errors" },
+],
+```
 
-describeEval("tool usage", {
-  data: async () => [
-    { input: "Search weather", expectedTools: [{ name: "weather_api" }] },
-  ],
-  task: weatherTask,
-  scorers: [ToolCallScorer()],
-});
+Additional fields (like `expected`, `expectedTools`) are passed through to scorers.
 
-// Custom scorer
-const LengthScorer = async ({ output }) => ({
-  score: output.length > 50 ? 1.0 : 0.0,
-});
+## Lifecycle Hooks
 
-// TypeScript scorer with custom options
-import { type ScoreFn, type BaseScorerOptions } from "vitest-evals";
-
-interface CustomOptions extends BaseScorerOptions {
-  minLength: number;
-}
+Use `beforeEach` and `afterEach` for setup and teardown:
 
-const TypedScorer: ScoreFn<CustomOptions> = async (opts) => ({
-  score: opts.output.length >= opts.minLength ? 1.0 : 0.0,
+```javascript
+describeEval("agent with database", {
+  beforeEach: async () => {
+    await db.seed();
+  },
+  afterEach: async () => {
+    await db.clean();
+  },
+  data: async () => [{ input: "Find recent errors" }],
+  task: myAgentTask,
+  scorers: [async ({ output }) => ({ score: output.includes("error") ? 1.0 : 0.0 })],
 });
 ```
 
-### Built-in Scorers
+## Scorers
 
-#### ToolCallScorer
+Scorers evaluate outputs and return a score (0-1). Use built-in scorers or create your own.
+
+### ToolCallScorer
 
 Evaluates if the expected tools were called with correct arguments.
 
 ```javascript
-// Basic usage - strict matching, any order
-describeEval("search test", {
+import { ToolCallScorer } from "vitest-evals";
+
+describeEval("tool usage", {
   data: async () => [
     {
       input: "Find Italian restaurants",
@@ -105,21 +104,11 @@ describeEval("search test", {
   scorers: [ToolCallScorer()],
 });
 
-// Strict evaluation - exact order and parameters
-scorers: [
-  ToolCallScorer({
-    ordered: true, // Tools must be in exact order
-    params: "strict", // Parameters must match exactly
-  }),
-];
+// Strict order and parameters
+scorers: [ToolCallScorer({ ordered: true, params: "strict" })];
 
 // Flexible evaluation
-scorers: [
-  ToolCallScorer({
-    requireAll: false, // Partial matches give partial credit
-    allowExtras: false, // No additional tools allowed
-  }),
-];
+scorers: [ToolCallScorer({ requireAll: false, allowExtras: false })];
 ```
 
 **Default behavior:**
@@ -129,6 +118,63 @@ scorers: [
 - Extra tools allowed
 - All expected tools required
 
+### StructuredOutputScorer
+
+Evaluates if the output matches expected structured data (JSON).
+
+```javascript
+import { StructuredOutputScorer } from "vitest-evals";
+
+describeEval("query generation", {
+  data: async () => [
+    {
+      input: "Show me errors from today",
+      expected: {
+        dataset: "errors",
+        query: "",
+        sort: "-timestamp",
+        timeRange: { statsPeriod: "24h" },
+      },
+    },
+  ],
+  task: myTask,
+  scorers: [StructuredOutputScorer()],
+});
+
+// Fuzzy matching
+scorers: [StructuredOutputScorer({ match: "fuzzy" })];
+
+// Custom validation
+scorers: [
+  StructuredOutputScorer({
+    match: (expected, actual, key) => {
+      if (key === "age") return actual >= 18 && actual <= 100;
+      return expected === actual;
+    },
+  }),
+];
+```
+
+### Custom Scorers
+
+```javascript
+// Inline scorer
+const LengthScorer = async ({ output }) => ({
+  score: output.length > 50 ? 1.0 : 0.0,
+});
+
+// TypeScript scorer with custom options
+import { type ScoreFn, type BaseScorerOptions } from "vitest-evals";
+
+interface CustomOptions extends BaseScorerOptions {
+  minLength: number;
+}
+
+const TypedScorer: ScoreFn<CustomOptions> = async (opts) => ({
+  score: opts.output.length >= opts.minLength ? 1.0 : 0.0,
+});
+```
+
 ## AI SDK Integration
 
 See [`src/ai-sdk-integration.test.ts`](src/ai-sdk-integration.test.ts) for a complete example with the Vercel AI SDK.
@@ -155,70 +201,21 @@ return {
 
 ## Advanced Usage
 
-### Advanced Scorers
-
-#### Using autoevals
+### Using autoevals
 
-For sophisticated evaluation, use autoevals scorers:
+For evaluation using the autoevals library:
 
 ```javascript
 import { Factuality, ClosedQA } from "autoevals";
 
 scorers: [
-  Factuality, // LLM-based factuality checking
+  Factuality,
   ClosedQA.partial({
     criteria: "Does the answer mention Paris?",
   }),
 ];
 ```
 
-#### Custom LLM-based Factuality Scorer
-
-Here's an example of implementing your own LLM-based factuality scorer using the Vercel AI SDK:
-
-```javascript
-import { generateObject } from "ai";
-import { openai } from "@ai-sdk/openai";
-import { z } from "zod";
-
-const Factuality = (model = openai("gpt-4o")) => async ({ input, output, expected }) => {
-    if (!expected) {
-      return { score: 1.0, metadata: { rationale: "No expected answer" } };
-    }
-
-    const { object } = await generateObject({
-      model,
-      prompt: `
-      Compare the factual content of the submitted answer with the expert answer.
-      
-      Question: ${input}
-      Expert: ${expected}
-      Submission: ${output}
-      
-      Options:
-      (A) Subset of expert answer
-      (B) Superset of expert answer  
-      (C) Same content as expert
-      (D) Contradicts expert answer
-      (E) Different but factually equivalent
-    `,
-      schema: z.object({
-        answer: z.enum(["A", "B", "C", "D", "E"]),
-        rationale: z.string(),
-      }),
-    });
-
-    const scores = { A: 0.4, B: 0.6, C: 1, D: 0, E: 1 };
-    return {
-      score: scores[object.answer],
-      metadata: { rationale: object.rationale, answer: object.answer },
-    };
-  };
-
-// Usage
-scorers: [Factuality()];
-```
-
 ### Skip Tests Conditionally
 
 ```javascript
@@ -232,7 +229,7 @@ describeEval("gpt-4 tests", {
 
 For integration with existing Vitest test suites, you can use the `.toEval()` matcher:
 
-> **⚠️ Deprecated**: The `.toEval()` helper is deprecated. Use `describeEval()` instead for better test organization and multiple scorers support. We may consider bringing back a similar check, but its currently too limited for many scorer implementations.
+> **Deprecated**: The `.toEval()` helper is deprecated. Use `describeEval()` instead for better test organization and multiple scorers support.
 
 ```javascript
 import "vitest-evals";
@@ -251,25 +248,6 @@ test("capital check", () => {
 });
 ```
 
-**Recommended migration** to `describeEval()`:
-
-```javascript
-import { describeEval } from "vitest-evals";
-
-describeEval("capital check", {
-  data: async () => [
-    { input: "What is the capital of France?", expected: "Paris" },
-  ],
-  task: answerQuestion,
-  scorers: [
-    async ({ output, expected }) => ({
-      score: output.toLowerCase().includes(expected.toLowerCase()) ? 1.0 : 0.0,
-    }),
-  ],
-  threshold: 0.8,
-});
-```
-
 ## Configuration
 
 ### Separate Eval Configuration
@@ -298,6 +276,6 @@ vitest --config=vitest.evals.config.ts
 ## Development
 
 ```shell
-npm install
-npm test
+pnpm install
+pnpm test
 ```

package/dist/evaluate/index.d.mts

@@ -0,0 +1,23 @@
+import { generateObject } from 'ai';
+
+type LanguageModel = Parameters<typeof generateObject>[0]["model"];
+declare function configure(opts: {
+    model: LanguageModel;
+}): void;
+interface EvaluateOptions {
+    task: () => Promise<string>;
+    criteria: string;
+    threshold?: number;
+}
+interface TestTaskContext {
+    task: {
+        meta: Record<string, any>;
+    };
+}
+/** @internal Core evaluation logic, exported for testing. */
+declare function _evaluate(ctx: TestTaskContext, opts: EvaluateOptions): Promise<void>;
+declare function evaluate(name: string, opts: EvaluateOptions & {
+    timeout?: number;
+}): void;
+
+export { _evaluate, configure, evaluate };

package/dist/evaluate/index.d.ts

@@ -0,0 +1,23 @@
+import { generateObject } from 'ai';
+
+type LanguageModel = Parameters<typeof generateObject>[0]["model"];
+declare function configure(opts: {
+    model: LanguageModel;
+}): void;
+interface EvaluateOptions {
+    task: () => Promise<string>;
+    criteria: string;
+    threshold?: number;
+}
+interface TestTaskContext {
+    task: {
+        meta: Record<string, any>;
+    };
+}
+/** @internal Core evaluation logic, exported for testing. */
+declare function _evaluate(ctx: TestTaskContext, opts: EvaluateOptions): Promise<void>;
+declare function evaluate(name: string, opts: EvaluateOptions & {
+    timeout?: number;
+}): void;
+
+export { _evaluate, configure, evaluate };

package/dist/evaluate/index.js

@@ -0,0 +1,189 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/evaluate/index.ts
+var evaluate_exports = {};
+__export(evaluate_exports, {
+  _evaluate: () => _evaluate,
+  configure: () => configure,
+  evaluate: () => evaluate
+});
+module.exports = __toCommonJS(evaluate_exports);
+var import_ai = require("ai");
+var import_zod = require("zod");
+var import_vitest = require("vitest");
+
+// src/wrapText.ts
+function wrapText(text, width = 80) {
+  if (!text || text.length <= width) {
+    return text;
+  }
+  const words = text.split(/\s+/);
+  const lines = [];
+  let currentLine = "";
+  for (const word of words) {
+    if (currentLine.length + word.length + 1 > width) {
+      lines.push(currentLine.trim());
+      currentLine = word;
+    } else {
+      currentLine += (currentLine ? " " : "") + word;
+    }
+  }
+  if (currentLine) {
+    lines.push(currentLine);
+  }
+  return lines.join("\n");
+}
+
+// src/evaluate/index.ts
+var defaultModel;
+function configure(opts) {
+  defaultModel = opts.model;
+}
+var EVAL_SYSTEM = `You are assessing a submitted output based on a given criterion. Ignore differences in style, grammar, punctuation, or length. Focus only on whether the criterion is met.`;
+var EVAL_PROMPT = (output, criteria) => `<submission>
+${output}
+</submission>
+
+<criteria>
+${criteria}
+</criteria>
+
+Does the submission meet the criteria? Select one option:
+(A) The criteria is fully met with no issues
+(B) The criteria is mostly met with minor gaps
+(C) The criteria is partially met with notable gaps
+(D) The criteria is barely met or only tangentially addressed
+(E) The criteria is not met at all`;
+var CHOICE_SCORES = {
+  A: 1,
+  B: 0.75,
+  C: 0.5,
+  D: 0.25,
+  E: 0
+};
+function _evaluate(ctx, opts) {
+  return __async(this, null, function* () {
+    var _a;
+    if (!defaultModel) {
+      throw new Error(
+        "No model configured. Call configure({ model }) before using evaluate."
+      );
+    }
+    let output;
+    try {
+      output = yield opts.task();
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      ctx.task.meta.eval = {
+        scores: [
+          {
+            score: 0,
+            name: "evaluate",
+            metadata: { rationale: `Task failed: ${errorMessage}` }
+          }
+        ],
+        avgScore: 0
+      };
+      throw error;
+    }
+    let object;
+    try {
+      ({ object } = yield (0, import_ai.generateObject)({
+        model: defaultModel,
+        schema: import_zod.z.object({
+          answer: import_zod.z.enum(["A", "B", "C", "D", "E"]),
+          rationale: import_zod.z.string()
+        }),
+        system: EVAL_SYSTEM,
+        prompt: EVAL_PROMPT(output, opts.criteria)
+      }));
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      ctx.task.meta.eval = {
+        scores: [
+          {
+            score: 0,
+            name: "evaluate",
+            metadata: { rationale: `Judge failed: ${errorMessage}` }
+          }
+        ],
+        avgScore: 0
+      };
+      throw error;
+    }
+    const score = CHOICE_SCORES[object.answer];
+    const threshold = (_a = opts.threshold) != null ? _a : 1;
+    ctx.task.meta.eval = {
+      scores: [
+        {
+          score,
+          name: "evaluate",
+          metadata: { rationale: object.rationale, answer: object.answer }
+        }
+      ],
+      avgScore: score
+    };
+    if (score < threshold) {
+      (0, import_vitest.assert)(
+        false,
+        `Score: ${score} (${object.answer}) below threshold: ${threshold}
+
+## Output:
+${wrapText(output)}
+
+## Rationale:
+${wrapText(object.rationale)}`
+      );
+    }
+  });
+}
+function evaluate(name, opts) {
+  var _a;
+  (0, import_vitest.test)(name, { timeout: (_a = opts.timeout) != null ? _a : 6e4 }, (_0) => __async(null, [_0], function* ({ task: testTask }) {
+    yield _evaluate({ task: testTask }, opts);
+  }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  _evaluate,
+  configure,
+  evaluate
+});
+//# sourceMappingURL=index.js.map

package/dist/evaluate/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/evaluate/index.ts","../../src/wrapText.ts"],"sourcesContent":["import { generateObject } from \"ai\";\nimport { z } from \"zod\";\nimport { assert, test } from \"vitest\";\nimport { wrapText } from \"../wrapText\";\n\ntype LanguageModel = Parameters<typeof generateObject>[0][\"model\"];\n\nlet defaultModel: LanguageModel | undefined;\n\nexport function configure(opts: { model: LanguageModel }) {\n  defaultModel = opts.model;\n}\n\nconst EVAL_SYSTEM = `You are assessing a submitted output based on a given criterion. Ignore differences in style, grammar, punctuation, or length. Focus only on whether the criterion is met.`;\n\nconst EVAL_PROMPT = (output: string, criteria: string) => `<submission>\n${output}\n</submission>\n\n<criteria>\n${criteria}\n</criteria>\n\nDoes the submission meet the criteria? Select one option:\n(A) The criteria is fully met with no issues\n(B) The criteria is mostly met with minor gaps\n(C) The criteria is partially met with notable gaps\n(D) The criteria is barely met or only tangentially addressed\n(E) The criteria is not met at all`;\n\nconst CHOICE_SCORES: Record<string, number> = {\n  A: 1.0,\n  B: 0.75,\n  C: 0.5,\n  D: 0.25,\n  E: 0.0,\n};\n\ninterface EvaluateOptions {\n  task: () => Promise<string>;\n  criteria: string;\n  threshold?: number;\n}\n\ninterface TestTaskContext {\n  task: { meta: Record<string, any> };\n}\n\n/** @internal Core evaluation logic, exported for testing. */\nexport async function _evaluate(\n  ctx: TestTaskContext,\n  opts: EvaluateOptions,\n): Promise<void> {\n  if (!defaultModel) {\n    throw new Error(\n      \"No model configured. Call configure({ model }) before using evaluate.\",\n    );\n  }\n\n  let output: string;\n  try {\n    output = await opts.task();\n  } catch (error) {\n    const errorMessage = error instanceof Error ? error.message : String(error);\n    ctx.task.meta.eval = {\n      scores: [\n        {\n          score: 0,\n          name: \"evaluate\",\n          metadata: { rationale: `Task failed: ${errorMessage}` },\n        },\n      ],\n      avgScore: 0,\n    };\n    throw error;\n  }\n\n  let object: { answer: string; rationale: string };\n  try {\n    ({ object } = await generateObject({\n      model: defaultModel,\n      schema: z.object({\n        answer: z.enum([\"A\", \"B\", \"C\", \"D\", \"E\"]),\n        rationale: z.string(),\n      }),\n      system: EVAL_SYSTEM,\n      prompt: EVAL_PROMPT(output, opts.criteria),\n    }));\n  } catch (error) {\n    const errorMessage = error instanceof Error ? error.message : String(error);\n    ctx.task.meta.eval = {\n      scores: [\n        {\n          score: 0,\n          name: \"evaluate\",\n          metadata: { rationale: `Judge failed: ${errorMessage}` },\n        },\n      ],\n      avgScore: 0,\n    };\n    throw error;\n  }\n\n  const score = CHOICE_SCORES[object.answer];\n  const threshold = opts.threshold ?? 1.0;\n\n  ctx.task.meta.eval = {\n    scores: [\n      {\n        score,\n        name: \"evaluate\",\n        metadata: { rationale: object.rationale, answer: object.answer },\n      },\n    ],\n    avgScore: score,\n  };\n\n  if (score < threshold) {\n    assert(\n      false,\n      `Score: ${score} (${object.answer}) below threshold: ${threshold}\\n\\n## Output:\\n${wrapText(output)}\\n\\n## Rationale:\\n${wrapText(object.rationale)}`,\n    );\n  }\n}\n\nexport function evaluate(\n  name: string,\n  opts: EvaluateOptions & { timeout?: number },\n) {\n  test(name, { timeout: opts.timeout ?? 60000 }, async ({ task: testTask }) => {\n    await _evaluate({ task: testTask }, opts);\n  });\n}\n","/**\n * Wraps text to fit within a specified width, breaking at word boundaries.\n *\n * @param text - The text to wrap\n * @param width - The maximum width in characters (default: 80)\n * @returns The wrapped text with line breaks\n *\n * @example\n * ```javascript\n * const wrapped = wrapText(\"This is a very long text that needs to be wrapped to fit within an 80 character width.\", 20);\n * console.log(wrapped);\n * // Output:\n * // This is a very\n * // long text that\n * // needs to be\n * // wrapped to fit\n * // within an 80\n * // character width.\n * ```\n */\nexport function wrapText(text: string, width = 80): string {\n  if (!text || text.length <= width) {\n    return text;\n  }\n\n  const words = text.split(/\\s+/);\n  const lines: string[] = [];\n  let currentLine = \"\";\n\n  for (const word of words) {\n    // If adding this word would exceed the width, start a new line\n    if (currentLine.length + word.length + 1 > width) {\n      lines.push(currentLine.trim());\n      currentLine = word;\n    } else {\n      // Add the word to the current line\n      currentLine += (currentLine ? \" \" : \"\") + word;\n    }\n  }\n\n  // Add the last line if it's not empty\n  if (currentLine) {\n    lines.push(currentLine);\n  }\n\n  return lines.join(\"\\n\");\n}\n"],"mappings":"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","names":[]}