@dvina/agents 0.10.0 → 0.13.0

package/dist/eval/index.d.mts

@@ -1,20 +1,22 @@
-import { T as ToolDefinition, A as Agent, L as LangchainModelConfig, M as Message, d as AiMessage, g as ToolSpec, H as HumanMessage, f as ToolMessage } from '../model-resolver-BZtVieXE.mjs';
+import { T as ToolDefinition, A as Agent, L as LangchainModelConfig, M as Message, e as AiMessage, b as ToolSpec, H as HumanMessage, g as ToolMessage } from '../model-resolver-DjKRXKtu.mjs';
 import * as zod from 'zod';
 import { z } from 'zod';
 import { BaseMessage } from '@langchain/core/messages';
 
-/** Factory that creates a fresh Agent per test case. Receives extra suite-level tools as ToolDefinition[]. */
-type CreateTargetFn = (extraTools: ToolDefinition[]) => Agent | Promise<Agent>;
+/** Factory that creates a fresh Agent per test case. Receives the model string and extra suite-level tools. */
+type CreateTargetFn = (model: string, extraTools: ToolDefinition[]) => Agent | Promise<Agent>;
 interface EvalConfig {
     /** Required for model-based target and LLM evaluators (respondsInLanguage, llmJudge). */
     modelConfig: LangchainModelConfig;
-    /** Required for model-based target. Also used as fallback for evaluatorModel. */
-    model?: string;
+    /** Models to evaluate. Every registered suite is run once per model. */
+    models: string[];
     /** Model for evaluators needing LLM calls (language detection, LLM-as-judge). */
     evaluatorModel: string;
+    /** LangSmith experiment (dataset) name. All suites share this single experiment for easy comparison across runs. */
+    experimentName: string;
     /** System prompt for model-based target. Ignored when createTarget is used. Can be overridden per-suite or per-case. */
     systemPrompt?: string;
-    /** Factory that creates a fresh Agent per test case. When set, this is the default target. */
+    /** Factory that creates a fresh Agent per test case. Receives the current model string from the models array. */
     createTarget?: CreateTargetFn;
     /** Transforms test case messages before sending to target. Simulates production preprocessing (e.g., message enrichment). */
     prepareMessages?: (messages: Message[]) => Message[] | Promise<Message[]>;
@@ -57,14 +59,26 @@ declare function toolsCalled(tools: string[]): Expectation;
  * Uses the globally configured evaluator model.
  */
 declare function llmJudge(): Expectation;
-/** Assert the agent made zero tool calls. */
-declare function noTools(): Expectation;
+/**
+ * Assert the agent made zero tool calls.
+ * Optionally allow specific tools via `except` — calls to those tools
+ * are permitted (but not required), while any other tool call fails.
+ */
+declare function noTools(options?: {
+    except: string[];
+}): Expectation;
 /**
  * Assert the response is in the given language (ISO 639-1 code).
  * Uses the globally configured evaluator model for language detection.
  * @param code - ISO 639-1 language code (e.g. 'en', 'tr', 'de').
  */
 declare function respondsInLanguage(code: string): Expectation;
+/**
+ * Assert that at least one tool call was made.
+ * When `tools` is provided, at least one of those specific tools must
+ * appear in the trajectory. When omitted, any tool call satisfies it.
+ */
+declare function anyToolCalled(tools?: string[]): Expectation;
 /** Assert the response contains all given strings. */
 declare function contains(strings: string[]): Expectation;
 /** Assert the response does not contain any of the given strings. */
@@ -118,6 +132,22 @@ interface SuiteConfig {
  * entry in `responses` default to `''`.
  */
 declare function fromToolSpecs(specs: ToolSpec[], responses?: Record<string, ToolDef['response']>): Record<string, ToolDef>;
+/**
+ * Registers an eval suite. Does not create tests on its own — call
+ * `runEvals()` after all suites are registered to emit a single
+ * LangSmith experiment containing every test case.
+ */
 declare function defineSuite(name: string, config: SuiteConfig): void;
+/**
+ * Emits all registered suites under a single `ls.describe` block so
+ * every test case lands in one LangSmith experiment / dataset.
+ *
+ * Call this once, after importing all suite files.
+ *
+ * Individual suites are grouped with native `describe` blocks for
+ * readability; test names are prefixed with the suite name
+ * (e.g. "discovery > should use search tool").
+ */
+declare function runEvals(): void;
 
-export { type CreateTargetFn, type EvalConfig, type Expectation, type SuiteConfig, type TestCase, type ToolDef, ai, configureEvals, contains, defineSuite, fromToolSpecs, human, llmJudge, noTools, notContains, respondsInLanguage, toolResult, toolsCalled };
+export { type CreateTargetFn, type EvalConfig, type Expectation, type SuiteConfig, type TestCase, type ToolDef, ai, anyToolCalled, configureEvals, contains, defineSuite, fromToolSpecs, human, llmJudge, noTools, notContains, respondsInLanguage, runEvals, toolResult, toolsCalled };

package/dist/eval/index.d.ts

@@ -1,20 +1,22 @@
-import { T as ToolDefinition, A as Agent, L as LangchainModelConfig, M as Message, d as AiMessage, g as ToolSpec, H as HumanMessage, f as ToolMessage } from '../model-resolver-BZtVieXE.js';
+import { T as ToolDefinition, A as Agent, L as LangchainModelConfig, M as Message, e as AiMessage, b as ToolSpec, H as HumanMessage, g as ToolMessage } from '../model-resolver-DjKRXKtu.js';
 import * as zod from 'zod';
 import { z } from 'zod';
 import { BaseMessage } from '@langchain/core/messages';
 
-/** Factory that creates a fresh Agent per test case. Receives extra suite-level tools as ToolDefinition[]. */
-type CreateTargetFn = (extraTools: ToolDefinition[]) => Agent | Promise<Agent>;
+/** Factory that creates a fresh Agent per test case. Receives the model string and extra suite-level tools. */
+type CreateTargetFn = (model: string, extraTools: ToolDefinition[]) => Agent | Promise<Agent>;
 interface EvalConfig {
     /** Required for model-based target and LLM evaluators (respondsInLanguage, llmJudge). */
     modelConfig: LangchainModelConfig;
-    /** Required for model-based target. Also used as fallback for evaluatorModel. */
-    model?: string;
+    /** Models to evaluate. Every registered suite is run once per model. */
+    models: string[];
     /** Model for evaluators needing LLM calls (language detection, LLM-as-judge). */
     evaluatorModel: string;
+    /** LangSmith experiment (dataset) name. All suites share this single experiment for easy comparison across runs. */
+    experimentName: string;
     /** System prompt for model-based target. Ignored when createTarget is used. Can be overridden per-suite or per-case. */
     systemPrompt?: string;
-    /** Factory that creates a fresh Agent per test case. When set, this is the default target. */
+    /** Factory that creates a fresh Agent per test case. Receives the current model string from the models array. */
     createTarget?: CreateTargetFn;
     /** Transforms test case messages before sending to target. Simulates production preprocessing (e.g., message enrichment). */
     prepareMessages?: (messages: Message[]) => Message[] | Promise<Message[]>;
@@ -57,14 +59,26 @@ declare function toolsCalled(tools: string[]): Expectation;
  * Uses the globally configured evaluator model.
  */
 declare function llmJudge(): Expectation;
-/** Assert the agent made zero tool calls. */
-declare function noTools(): Expectation;
+/**
+ * Assert the agent made zero tool calls.
+ * Optionally allow specific tools via `except` — calls to those tools
+ * are permitted (but not required), while any other tool call fails.
+ */
+declare function noTools(options?: {
+    except: string[];
+}): Expectation;
 /**
  * Assert the response is in the given language (ISO 639-1 code).
  * Uses the globally configured evaluator model for language detection.
  * @param code - ISO 639-1 language code (e.g. 'en', 'tr', 'de').
  */
 declare function respondsInLanguage(code: string): Expectation;
+/**
+ * Assert that at least one tool call was made.
+ * When `tools` is provided, at least one of those specific tools must
+ * appear in the trajectory. When omitted, any tool call satisfies it.
+ */
+declare function anyToolCalled(tools?: string[]): Expectation;
 /** Assert the response contains all given strings. */
 declare function contains(strings: string[]): Expectation;
 /** Assert the response does not contain any of the given strings. */
@@ -118,6 +132,22 @@ interface SuiteConfig {
  * entry in `responses` default to `''`.
  */
 declare function fromToolSpecs(specs: ToolSpec[], responses?: Record<string, ToolDef['response']>): Record<string, ToolDef>;
+/**
+ * Registers an eval suite. Does not create tests on its own — call
+ * `runEvals()` after all suites are registered to emit a single
+ * LangSmith experiment containing every test case.
+ */
 declare function defineSuite(name: string, config: SuiteConfig): void;
+/**
+ * Emits all registered suites under a single `ls.describe` block so
+ * every test case lands in one LangSmith experiment / dataset.
+ *
+ * Call this once, after importing all suite files.
+ *
+ * Individual suites are grouped with native `describe` blocks for
+ * readability; test names are prefixed with the suite name
+ * (e.g. "discovery > should use search tool").
+ */
+declare function runEvals(): void;
 
-export { type CreateTargetFn, type EvalConfig, type Expectation, type SuiteConfig, type TestCase, type ToolDef, ai, configureEvals, contains, defineSuite, fromToolSpecs, human, llmJudge, noTools, notContains, respondsInLanguage, toolResult, toolsCalled };
+export { type CreateTargetFn, type EvalConfig, type Expectation, type SuiteConfig, type TestCase, type ToolDef, ai, anyToolCalled, configureEvals, contains, defineSuite, fromToolSpecs, human, llmJudge, noTools, notContains, respondsInLanguage, runEvals, toolResult, toolsCalled };

package/dist/eval/index.js

@@ -31,6 +31,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var eval_exports = {};
 __export(eval_exports, {
   ai: () => ai,
+  anyToolCalled: () => anyToolCalled,
   configureEvals: () => configureEvals,
   contains: () => contains,
   defineSuite: () => defineSuite,
@@ -40,6 +41,7 @@ __export(eval_exports, {
   noTools: () => noTools,
   notContains: () => notContains,
   respondsInLanguage: () => respondsInLanguage,
+  runEvals: () => runEvals,
   toolResult: () => toolResult,
   toolsCalled: () => toolsCalled
 });
@@ -59,6 +61,7 @@ function getEvalConfig() {
 
 // src/eval/suite.ts
 var ls = __toESM(require("langsmith/vitest"));
+var import_messages2 = require("@langchain/core/messages");
 
 // src/eval/target.ts
 var import_tools = require("@langchain/core/tools");
@@ -246,14 +249,24 @@ function convertToLangchainMessages(messages) {
 
 // src/eval/target.ts
 var MAX_AGENT_LOOPS = 10;
+function stripReasoningBlocks(message) {
+  if (!Array.isArray(message.content)) return message;
+  const filtered = message.content.filter(
+    (block) => block.type !== "reasoning" && block.type !== "thinking"
+  );
+  const newContent = filtered.length > 0 ? filtered : "";
+  return new import_messages.AIMessage({
+    content: newContent,
+    tool_calls: message.tool_calls,
+    id: message.id,
+    response_metadata: message.response_metadata,
+    usage_metadata: message.usage_metadata
+  });
+}
 function createEvalTarget(modelConfig, modelString) {
   return async (inputs) => {
-    const config = modelConfig && modelString ? { modelConfig, model: modelString } : getEvalConfig();
-    if (!config.model) {
-      throw new Error("model is required for model-based target. Add it to your configureEvals() call.");
-    }
-    const resolver = new LangchainModelResolver(config.modelConfig);
-    const model = resolver.resolve(config.model);
+    const resolver = new LangchainModelResolver(modelConfig);
+    const model = resolver.resolve(modelString);
     const toolCallCounts = {};
     const langchainTools = inputs.tools.map((mockTool) => {
       toolCallCounts[mockTool.name] = 0;
@@ -290,7 +303,7 @@ function createEvalTarget(modelConfig, modelString) {
     while (loopCount < MAX_AGENT_LOOPS) {
       loopCount++;
       const response = await boundModel.invoke(messages);
-      messages.push(response);
+      messages.push(stripReasoningBlocks(response));
       const aiMessage = response;
       if (!aiMessage.tool_calls || aiMessage.tool_calls.length === 0) {
         break;
@@ -390,9 +403,9 @@ function toolDefsToDefinitions(defs) {
     };
   });
 }
-async function runAgentTarget(createTarget, evalMessages, extraToolDefs) {
+async function runAgentTarget(createTarget, model, evalMessages, extraToolDefs) {
   const extraTools = Object.keys(extraToolDefs).length > 0 ? toolDefsToDefinitions(extraToolDefs) : [];
-  const agent = await createTarget(extraTools);
+  const agent = await createTarget(model, extraTools);
   const result = await agent.run({
     threadId: `eval_${Date.now()}_${Math.random().toString(36).slice(2)}`,
     messages: evalMessages
@@ -430,13 +443,6 @@ function toMockTools(defs) {
     response: typeof def.response === "function" ? def.response : typeof def.response === "string" ? def.response : JSON.stringify(def.response)
   }));
 }
-function toSerializableTools(tools) {
-  return tools.map((t) => ({
-    ...t,
-    schema: t.schema instanceof Object && "shape" in t.schema ? "<ZodObject>" : t.schema,
-    response: typeof t.response === "function" ? "<function>" : t.response
-  }));
-}
 function lastHumanContent(messages) {
   for (let i = messages.length - 1; i >= 0; i--) {
     const msg = messages[i];
@@ -447,61 +453,80 @@ function lastHumanContent(messages) {
   }
   return "";
 }
-function resolveModelTarget(config) {
+function resolveModelTarget(config, model) {
   if (typeof config.target === "function") return config.target;
   const evalConfig = getEvalConfig();
-  if (!evalConfig.model && typeof config.target !== "string") {
-    throw new Error("model is required for model-based target. Add it to your configureEvals() call.");
-  }
-  const model = typeof config.target === "string" ? config.target : evalConfig.model;
-  return createEvalTarget(evalConfig.modelConfig, model);
+  const targetModel = typeof config.target === "string" ? config.target : model;
+  return createEvalTarget(evalConfig.modelConfig, targetModel);
 }
 function resolveCreateTarget(config) {
   return config.createTarget ?? getEvalConfig().createTarget;
 }
+var _suites = [];
 function defineSuite(name, config) {
-  const suiteTools = config.tools ?? {};
-  const createTarget = config.target ? void 0 : resolveCreateTarget(config);
-  ls.describe(name, () => {
-    for (const tc of config.cases) {
-      const testName = tc.name ?? lastHumanContent(tc.messages);
-      const caseToolDefs = tc.tools ?? suiteTools;
-      const tools = toMockTools(caseToolDefs);
-      const ctx = { message: lastHumanContent(tc.messages) };
-      const resolved = tc.expect.map((exp) => exp(ctx));
-      const evaluators = resolved.map((r) => r.evaluator);
-      const referenceOutputs = Object.assign({}, ...resolved.map((r) => r.referenceOutputs));
-      ls.test(
-        testName,
-        {
-          inputs: {
-            messages: tc.messages,
-            tools: toSerializableTools(tools)
-          },
-          referenceOutputs
-        },
-        async ({ referenceOutputs: refOut }) => {
-          let output;
-          const prepareMessages = tc.prepareMessages ?? config.prepareMessages ?? getEvalConfig().prepareMessages;
-          const preparedMessages = prepareMessages ? await prepareMessages(tc.messages) : tc.messages;
-          if (createTarget) {
-            output = await runAgentTarget(createTarget, preparedMessages, caseToolDefs);
-          } else {
-            const target = resolveModelTarget(config);
-            const globalPrompt = getEvalConfig().systemPrompt;
-            const systemPrompt = tc.systemPrompt ?? config.systemPrompt ?? globalPrompt;
-            output = await target({
-              messages: preparedMessages,
-              tools,
-              ...systemPrompt ? { systemPrompt } : {}
-            });
-          }
-          ls.logOutputs(output);
-          for (const evaluator of evaluators) {
-            await evaluator({ outputs: output, referenceOutputs: refOut ?? {} });
-          }
+  _suites.push({ name, config });
+}
+function runEvals() {
+  const evalConfig = getEvalConfig();
+  ls.describe(evalConfig.experimentName, () => {
+    for (const currentModel of evalConfig.models) {
+      for (const { name: suiteName, config } of _suites) {
+        const suiteTools = config.tools ?? {};
+        const createTarget = config.target ? void 0 : resolveCreateTarget(config);
+        const categoryLabel = suiteName.charAt(0).toUpperCase() + suiteName.slice(1);
+        const model = typeof config.target === "string" ? config.target : currentModel;
+        for (const tc of config.cases) {
+          const testName = tc.name ?? lastHumanContent(tc.messages);
+          const caseToolDefs = tc.tools ?? suiteTools;
+          const tools = toMockTools(caseToolDefs);
+          const ctx = { message: lastHumanContent(tc.messages) };
+          const resolved = tc.expect.map((exp) => exp(ctx));
+          const evaluators = resolved.map((r) => r.evaluator);
+          const referenceOutputs = Object.assign({}, ...resolved.map((r) => r.referenceOutputs));
+          const fullTestName = `[${categoryLabel}] > ${testName}`;
+          ls.test(
+            `${fullTestName} (${model})`,
+            {
+              inputs: {
+                name: fullTestName,
+                category: categoryLabel,
+                model,
+                messages: tc.messages
+              },
+              referenceOutputs
+            },
+            async ({ referenceOutputs: refOut }) => {
+              let output;
+              const prepareMessages = tc.prepareMessages ?? config.prepareMessages ?? getEvalConfig().prepareMessages;
+              const preparedMessages = prepareMessages ? await prepareMessages(tc.messages) : tc.messages;
+              if (createTarget) {
+                output = await runAgentTarget(
+                  createTarget,
+                  currentModel,
+                  preparedMessages,
+                  caseToolDefs
+                );
+              } else {
+                const target = resolveModelTarget(config, currentModel);
+                const globalPrompt = getEvalConfig().systemPrompt;
+                const systemPrompt = tc.systemPrompt ?? config.systemPrompt ?? globalPrompt;
+                output = await target({
+                  messages: preparedMessages,
+                  tools,
+                  ...systemPrompt ? { systemPrompt } : {}
+                });
+              }
+              const calledTools = output.messages.filter((m) => m instanceof import_messages2.AIMessage).flatMap((m) => m.tool_calls ?? []).map((tc2) => tc2.name);
+              ls.logOutputs({
+                tools_called: calledTools.length > 0 ? calledTools.join(" | ") : "none"
+              });
+              for (const evaluator of evaluators) {
+                await evaluator({ outputs: output, referenceOutputs: refOut ?? {} });
+              }
+            }
+          );
         }
-      );
+      }
     }
   });
 }
@@ -511,7 +536,7 @@ var ls2 = __toESM(require("langsmith/vitest"));
 var import_agentevals = require("agentevals");
 
 // src/eval/evaluators/language.ts
-var import_messages2 = require("@langchain/core/messages");
+var import_messages3 = require("@langchain/core/messages");
 function createLanguageEvaluator(modelConfig, model) {
   const resolver = new LangchainModelResolver(modelConfig);
   const judge = resolver.resolve(model);
@@ -524,7 +549,7 @@ function createLanguageEvaluator(modelConfig, model) {
       return { key: "language_match", score: true, comment: "No expected language specified, skipping" };
     }
     const messages = outputs.messages || [];
-    const lastAiMessage = [...messages].reverse().find((m) => m instanceof import_messages2.AIMessage);
+    const lastAiMessage = [...messages].reverse().find((m) => m instanceof import_messages3.AIMessage);
     if (!lastAiMessage) {
       return { key: "language_match", score: false, comment: "No AI message found in trajectory" };
     }
@@ -550,7 +575,7 @@ function createLanguageEvaluator(modelConfig, model) {
 }
 
 // src/eval/evaluators/response-content.ts
-var import_messages3 = require("@langchain/core/messages");
+var import_messages4 = require("@langchain/core/messages");
 function createResponseContentEvaluator() {
   return async ({
     outputs,
@@ -562,7 +587,7 @@ function createResponseContentEvaluator() {
       return { key: "response_content", score: true, comment: "No content assertions specified, skipping" };
     }
     const messages = outputs.messages || [];
-    const lastAiMessage = [...messages].reverse().find((m) => m instanceof import_messages3.AIMessage);
+    const lastAiMessage = [...messages].reverse().find((m) => m instanceof import_messages4.AIMessage);
     if (!lastAiMessage) {
       return { key: "response_content", score: false, comment: "No AI message found in trajectory" };
     }
@@ -588,7 +613,7 @@ function createResponseContentEvaluator() {
 }
 
 // src/eval/evaluators/no-tool-calls.ts
-var import_messages4 = require("@langchain/core/messages");
+var import_messages5 = require("@langchain/core/messages");
 function createNoToolCallsEvaluator() {
   return async ({
     outputs,
@@ -598,8 +623,17 @@ function createNoToolCallsEvaluator() {
       return { key: "no_tool_calls", score: true, comment: "No tool call restriction specified, skipping" };
     }
     const messages = outputs.messages || [];
-    const toolCalls = messages.filter((m) => m instanceof import_messages4.AIMessage).flatMap((m) => m.tool_calls || []);
-    const passed = toolCalls.length === 0;
+    const exceptTools = referenceOutputs?.exceptTools ?? [];
+    const toolCalls = messages.filter((m) => m instanceof import_messages5.AIMessage).flatMap((m) => m.tool_calls || []);
+    const disallowedCalls = exceptTools.length > 0 ? toolCalls.filter((tc) => !exceptTools.includes(tc.name)) : toolCalls;
+    const passed = disallowedCalls.length === 0;
+    if (exceptTools.length > 0) {
+      return {
+        key: "no_tool_calls",
+        score: passed,
+        comment: passed ? `No disallowed tool calls made (allowed: ${exceptTools.join(", ")})` : `Agent made ${disallowedCalls.length} disallowed tool call(s): ${disallowedCalls.map((tc) => tc.name).join(", ")}`
+      };
+    }
     return {
       key: "no_tool_calls",
       score: passed,
@@ -608,6 +642,37 @@ function createNoToolCallsEvaluator() {
   };
 }
 
+// src/eval/evaluators/any-tool-called.ts
+var import_messages6 = require("@langchain/core/messages");
+function createAnyToolCalledEvaluator() {
+  return async ({
+    outputs,
+    referenceOutputs
+  }) => {
+    if (referenceOutputs?.expectAnyToolCall !== true) {
+      return { key: "any_tool_called", score: true, comment: "No any-tool-call expectation specified, skipping" };
+    }
+    const expectedTools = referenceOutputs?.anyToolsExpected ?? [];
+    const messages = outputs.messages || [];
+    const calledToolNames = messages.filter((m) => m instanceof import_messages6.AIMessage).flatMap((m) => m.tool_calls || []).map((tc) => tc.name);
+    if (expectedTools.length === 0) {
+      const passed2 = calledToolNames.length > 0;
+      return {
+        key: "any_tool_called",
+        score: passed2,
+        comment: passed2 ? `Agent called tool(s): ${calledToolNames.join(", ")}` : "Agent made no tool calls (expected at least one)"
+      };
+    }
+    const matchedTools = expectedTools.filter((name) => calledToolNames.includes(name));
+    const passed = matchedTools.length > 0;
+    return {
+      key: "any_tool_called",
+      score: passed,
+      comment: passed ? `Called expected tool(s): ${matchedTools.join(", ")}` : `None of the expected tools were called (expected one of: ${expectedTools.join(", ")}; actual: ${calledToolNames.length > 0 ? calledToolNames.join(", ") : "none"})`
+    };
+  };
+}
+
 // src/eval/expectations.ts
 function withTrajectoryGuard(evaluator, key) {
   return async ({ outputs, referenceOutputs }) => {
@@ -659,10 +724,13 @@ function llmJudge() {
     };
   };
 }
-function noTools() {
+function noTools(options) {
   return () => ({
     evaluator: ls2.wrapEvaluator(createNoToolCallsEvaluator()),
-    referenceOutputs: { expectNoToolCalls: true }
+    referenceOutputs: {
+      expectNoToolCalls: true,
+      ...options?.except?.length ? { exceptTools: options.except } : {}
+    }
   });
 }
 function respondsInLanguage(code) {
@@ -675,6 +743,15 @@ function respondsInLanguage(code) {
     };
   };
 }
+function anyToolCalled(tools) {
+  return () => ({
+    evaluator: ls2.wrapEvaluator(createAnyToolCalledEvaluator()),
+    referenceOutputs: {
+      expectAnyToolCall: true,
+      ...tools?.length ? { anyToolsExpected: tools } : {}
+    }
+  });
+}
 function contains(strings) {
   return () => ({
     evaluator: ls2.wrapEvaluator(createResponseContentEvaluator()),
@@ -690,6 +767,7 @@ function notContains(strings) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ai,
+  anyToolCalled,
   configureEvals,
   contains,
   defineSuite,
@@ -699,6 +777,7 @@ function notContains(strings) {
   noTools,
   notContains,
   respondsInLanguage,
+  runEvals,
   toolResult,
   toolsCalled
 });