@agentv/core 0.23.0 → 0.25.0

package/dist/index.js

@@ -5,10 +5,11 @@ import {
   findGitRoot,
   isAgentProvider,
   normalizeLineEndings,
+  readJsonFile,
   readTextFile,
   resolveFileReference,
   resolveTargetDefinition
-} from "./chunk-B2J23S7D.js";
+} from "./chunk-OYTL3LNN.js";
 
 // src/evaluation/types.ts
 var TEST_MESSAGE_ROLE_VALUES = ["system", "user", "assistant", "tool"];
@@ -51,7 +52,14 @@ function isTestMessage(value) {
   }
   return candidate.content.every(isJsonObject);
 }
-var EVALUATOR_KIND_VALUES = ["code_judge", "llm_judge", "rubric", "composite"];
+var EVALUATOR_KIND_VALUES = [
+  "code_judge",
+  "llm_judge",
+  "rubric",
+  "composite",
+  "tool_trajectory",
+  "expected_messages"
+];
 var EVALUATOR_KIND_SET = new Set(EVALUATOR_KIND_VALUES);
 function isEvaluatorKind(value) {
   return typeof value === "string" && EVALUATOR_KIND_SET.has(value);
@@ -60,6 +68,44 @@ function getHitCount(result) {
   return result.hits.length;
 }
 
+// src/evaluation/trace.ts
+function isTraceEventType(value) {
+  return typeof value === "string" && ["model_step", "tool_call", "tool_result", "message", "error"].includes(value);
+}
+function isTraceEvent(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  return isTraceEventType(candidate.type) && typeof candidate.timestamp === "string";
+}
+function isExpectedToolCall(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.tool === "string";
+}
+function computeTraceSummary(trace) {
+  const toolCallCounts = {};
+  let errorCount = 0;
+  for (const event of trace) {
+    if (event.type === "tool_call" && event.name) {
+      toolCallCounts[event.name] = (toolCallCounts[event.name] ?? 0) + 1;
+    }
+    if (event.type === "error") {
+      errorCount++;
+    }
+  }
+  const toolNames = Object.keys(toolCallCounts).sort();
+  return {
+    eventCount: trace.length,
+    toolNames,
+    toolCallsByName: toolCallCounts,
+    errorCount
+  };
+}
+
 // src/evaluation/yaml-parser.ts
 import { readFile as readFile5 } from "node:fs/promises";
 import path6 from "node:path";
@@ -532,6 +578,75 @@ async function parseEvaluators(rawEvalCase, globalExecution, searchRoots, evalId
       });
       continue;
     }
+    if (typeValue === "expected_messages") {
+      evaluators.push({
+        name,
+        type: "expected_messages"
+      });
+      continue;
+    }
+    if (typeValue === "tool_trajectory") {
+      const mode = asString2(rawEvaluator.mode);
+      if (mode !== "any_order" && mode !== "in_order" && mode !== "exact") {
+        logWarning2(
+          `Skipping tool_trajectory evaluator '${name}' in '${evalId}': invalid mode '${mode}' (must be any_order, in_order, or exact)`
+        );
+        continue;
+      }
+      const rawMinimums = rawEvaluator.minimums;
+      let minimums;
+      if (rawMinimums !== void 0) {
+        if (!isJsonObject2(rawMinimums)) {
+          logWarning2(
+            `Skipping tool_trajectory evaluator '${name}' in '${evalId}': minimums must be an object`
+          );
+          continue;
+        }
+        minimums = {};
+        for (const [toolName, count] of Object.entries(rawMinimums)) {
+          if (typeof count === "number" && count >= 0) {
+            minimums[toolName] = count;
+          }
+        }
+      }
+      const rawExpected = rawEvaluator.expected;
+      let expected;
+      if (rawExpected !== void 0) {
+        if (!Array.isArray(rawExpected)) {
+          logWarning2(
+            `Skipping tool_trajectory evaluator '${name}' in '${evalId}': expected must be an array`
+          );
+          continue;
+        }
+        expected = [];
+        for (const item of rawExpected) {
+          if (isJsonObject2(item) && typeof item.tool === "string") {
+            expected.push({ tool: item.tool });
+          }
+        }
+      }
+      if (mode === "any_order" && !minimums) {
+        logWarning2(
+          `Skipping tool_trajectory evaluator '${name}' in '${evalId}': any_order mode requires minimums`
+        );
+        continue;
+      }
+      if ((mode === "in_order" || mode === "exact") && !expected) {
+        logWarning2(
+          `Skipping tool_trajectory evaluator '${name}' in '${evalId}': ${mode} mode requires expected`
+        );
+        continue;
+      }
+      const config = {
+        name,
+        type: "tool_trajectory",
+        mode,
+        ...minimums ? { minimums } : {},
+        ...expected ? { expected } : {}
+      };
+      evaluators.push(config);
+      continue;
+    }
     const prompt = asString2(rawEvaluator.prompt);
     let promptPath;
     if (prompt) {
@@ -785,6 +900,67 @@ ${detailBlock}${ANSI_RESET4}`);
     console.warn(`${ANSI_YELLOW4}Warning: ${message}${ANSI_RESET4}`);
   }
 }
+async function processExpectedMessages(options) {
+  const { messages, searchRoots, repoRootPath, verbose } = options;
+  const segments = [];
+  for (const message of messages) {
+    const segment = {
+      role: message.role
+    };
+    if (message.role === "assistant" && message.tool_calls !== void 0) {
+      segment.tool_calls = message.tool_calls;
+    }
+    const content = message.content;
+    if (typeof content === "string") {
+      segment.content = content;
+    } else if (Array.isArray(content)) {
+      const processedContent = [];
+      for (const rawSegment of content) {
+        if (!isJsonObject(rawSegment)) {
+          continue;
+        }
+        const segmentType = asString3(rawSegment.type);
+        if (segmentType === "file") {
+          const rawValue = asString3(rawSegment.value);
+          if (!rawValue) {
+            continue;
+          }
+          const { displayPath, resolvedPath, attempted } = await resolveFileReference2(
+            rawValue,
+            searchRoots
+          );
+          if (!resolvedPath) {
+            const attempts = attempted.length ? ["  Tried:", ...attempted.map((candidate) => `    ${candidate}`)] : void 0;
+            logWarning3(`File not found in expected_messages: ${displayPath}`, attempts);
+            continue;
+          }
+          try {
+            const fileContent = (await readFile3(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
+            processedContent.push({
+              type: "file",
+              path: displayPath,
+              text: fileContent,
+              resolvedPath: path4.resolve(resolvedPath)
+            });
+            if (verbose) {
+              console.log(`  [Expected Output File] Found: ${displayPath}`);
+              console.log(`    Resolved to: ${resolvedPath}`);
+            }
+          } catch (error) {
+            logWarning3(
+              `Could not read expected output file ${resolvedPath}: ${error.message}`
+            );
+          }
+          continue;
+        }
+        processedContent.push(cloneJsonObject(rawSegment));
+      }
+      segment.content = processedContent;
+    }
+    segments.push(segment);
+  }
+  return segments;
+}
 
 // src/evaluation/formatting/prompt-builder.ts
 import { readFile as readFile4 } from "node:fs/promises";
@@ -1089,12 +1265,10 @@ async function loadEvalCases(evalFilePath, repoRoot, options) {
       messageType: "input",
       verbose
     });
-    const outputSegments = hasExpectedMessages ? await processMessages({
+    const outputSegments = hasExpectedMessages ? await processExpectedMessages({
       messages: expectedMessages,
       searchRoots,
       repoRootPath,
-      guidelinePatterns,
-      messageType: "output",
       verbose
     }) : [];
     const codeSnippets = extractCodeBlocks(inputSegments);
@@ -1618,9 +1792,11 @@ var CliProvider = class {
       const message = detail ? `${detail} (exit code ${codeText})` : `CLI exited with code ${codeText}`;
       throw new Error(message);
     }
-    const responseText = await this.readAndCleanupOutputFile(outputFilePath);
+    const responseContent = await this.readAndCleanupOutputFile(outputFilePath);
+    const parsed = this.parseOutputContent(responseContent);
     return {
-      text: responseText,
+      text: parsed.text,
+      trace: parsed.trace,
       raw: {
         command: renderedCommand,
         stderr: result.stderr,
@@ -1630,6 +1806,31 @@ var CliProvider = class {
       }
     };
   }
+  /**
+   * Parse output content from CLI.
+   * If the content is valid JSON with a 'text' field, extract text and optional trace.
+   * Otherwise, treat the entire content as plain text.
+   */
+  parseOutputContent(content) {
+    try {
+      const parsed = JSON.parse(content);
+      if (typeof parsed === "object" && parsed !== null && "text" in parsed) {
+        const obj = parsed;
+        const text = typeof obj.text === "string" ? obj.text : String(obj.text);
+        const trace = this.parseTrace(obj.trace);
+        return { text, trace };
+      }
+    } catch {
+    }
+    return { text: content };
+  }
+  parseTrace(trace) {
+    if (!Array.isArray(trace)) {
+      return void 0;
+    }
+    const validEvents = trace.filter(isTraceEvent);
+    return validEvents.length > 0 ? validEvents : void 0;
+  }
   async readAndCleanupOutputFile(filePath) {
     try {
       const content = await readTextFile(filePath);
@@ -2616,6 +2817,7 @@ var MockProvider = class {
   delayMs;
   delayMinMs;
   delayMaxMs;
+  trace;
   constructor(targetName, config) {
     this.id = `mock:${targetName}`;
     this.targetName = targetName;
@@ -2623,6 +2825,7 @@ var MockProvider = class {
     this.delayMs = config.delayMs ?? 0;
     this.delayMinMs = config.delayMinMs ?? 0;
     this.delayMaxMs = config.delayMaxMs ?? 0;
+    this.trace = config.trace;
   }
   async invoke(request) {
     const delay = this.calculateDelay();
@@ -2634,7 +2837,8 @@ var MockProvider = class {
       raw: {
         question: request.question,
         guidelines: request.guidelines
-      }
+      },
+      trace: this.trace
     };
   }
   calculateDelay() {
@@ -3428,6 +3632,251 @@ function substituteVariables(template, variables) {
     return variables[varName] ?? match;
   });
 }
+var ToolTrajectoryEvaluator = class {
+  kind = "tool_trajectory";
+  config;
+  constructor(options) {
+    this.config = options.config;
+  }
+  evaluate(context) {
+    const { candidateTrace, candidateTraceSummary } = context;
+    if (!candidateTrace || !candidateTraceSummary) {
+      return {
+        score: 0,
+        verdict: "fail",
+        hits: [],
+        misses: ["No trace available for evaluation"],
+        expectedAspectCount: 1
+      };
+    }
+    switch (this.config.mode) {
+      case "any_order":
+        return this.evaluateAnyOrder(candidateTraceSummary);
+      case "in_order":
+        return this.evaluateInOrder(candidateTrace);
+      case "exact":
+        return this.evaluateExact(candidateTrace);
+      default:
+        return {
+          score: 0,
+          verdict: "fail",
+          hits: [],
+          misses: [`Unknown mode: ${this.config.mode}`],
+          expectedAspectCount: 1
+        };
+    }
+  }
+  evaluateAnyOrder(summary) {
+    const minimums = this.config.minimums ?? {};
+    const toolNames = Object.keys(minimums);
+    if (toolNames.length === 0) {
+      return {
+        score: 1,
+        verdict: "pass",
+        hits: ["No tool requirements specified"],
+        misses: [],
+        expectedAspectCount: 0
+      };
+    }
+    const hits = [];
+    const misses = [];
+    for (const toolName of toolNames) {
+      const required = minimums[toolName];
+      const actual = summary.toolCallsByName[toolName] ?? 0;
+      if (actual >= required) {
+        hits.push(`${toolName}: called ${actual} times (required \u2265${required})`);
+      } else {
+        misses.push(`${toolName}: called ${actual} times (required \u2265${required})`);
+      }
+    }
+    const score = hits.length / toolNames.length;
+    return {
+      score,
+      verdict: scoreToVerdict(score),
+      hits,
+      misses,
+      expectedAspectCount: toolNames.length
+    };
+  }
+  evaluateInOrder(trace) {
+    const expected = this.config.expected ?? [];
+    if (expected.length === 0) {
+      return {
+        score: 1,
+        verdict: "pass",
+        hits: ["No tool sequence specified"],
+        misses: [],
+        expectedAspectCount: 0
+      };
+    }
+    const actualToolCalls = trace.filter((e) => e.type === "tool_call" && e.name);
+    const hits = [];
+    const misses = [];
+    let actualIndex = 0;
+    for (let i = 0; i < expected.length; i++) {
+      const expectedTool = expected[i].tool;
+      let found = false;
+      while (actualIndex < actualToolCalls.length) {
+        if (actualToolCalls[actualIndex].name === expectedTool) {
+          hits.push(`Found ${expectedTool} at position ${actualIndex}`);
+          actualIndex++;
+          found = true;
+          break;
+        }
+        actualIndex++;
+      }
+      if (!found) {
+        misses.push(`Expected ${expectedTool} at position ${i}, not found in remaining trace`);
+      }
+    }
+    const score = hits.length / expected.length;
+    return {
+      score,
+      verdict: scoreToVerdict(score),
+      hits,
+      misses,
+      expectedAspectCount: expected.length
+    };
+  }
+  evaluateExact(trace) {
+    const expected = this.config.expected ?? [];
+    if (expected.length === 0) {
+      return {
+        score: 1,
+        verdict: "pass",
+        hits: ["No tool sequence specified"],
+        misses: [],
+        expectedAspectCount: 0
+      };
+    }
+    const actualToolCalls = trace.filter((e) => e.type === "tool_call" && e.name);
+    const hits = [];
+    const misses = [];
+    if (actualToolCalls.length !== expected.length) {
+      misses.push(`Expected ${expected.length} tool calls, got ${actualToolCalls.length}`);
+    }
+    const checkLength = Math.min(expected.length, actualToolCalls.length);
+    for (let i = 0; i < checkLength; i++) {
+      const expectedTool = expected[i].tool;
+      const actualTool = actualToolCalls[i].name;
+      if (actualTool === expectedTool) {
+        hits.push(`Position ${i}: ${expectedTool} \u2713`);
+      } else {
+        misses.push(`Position ${i}: expected ${expectedTool}, got ${actualTool}`);
+      }
+    }
+    for (let i = checkLength; i < expected.length; i++) {
+      misses.push(`Position ${i}: expected ${expected[i].tool}, got nothing`);
+    }
+    const score = hits.length / expected.length;
+    return {
+      score,
+      verdict: scoreToVerdict(score),
+      hits,
+      misses,
+      expectedAspectCount: expected.length
+    };
+  }
+};
+var ExpectedMessagesEvaluator = class {
+  kind = "expected_messages";
+  evaluate(context) {
+    const { candidateTrace, evalCase } = context;
+    const expectedSegments = evalCase.expected_segments;
+    const expectedToolCalls = this.extractExpectedToolCalls(expectedSegments);
+    if (expectedToolCalls.length === 0) {
+      return {
+        score: 1,
+        verdict: "pass",
+        hits: ["No tool_calls specified in expected_messages"],
+        misses: [],
+        expectedAspectCount: 1
+      };
+    }
+    if (!candidateTrace || candidateTrace.length === 0) {
+      return {
+        score: 0,
+        verdict: "fail",
+        hits: [],
+        misses: ["No trace available to validate tool_calls"],
+        expectedAspectCount: expectedToolCalls.length
+      };
+    }
+    const actualToolCalls = candidateTrace.filter((e) => e.type === "tool_call");
+    return this.validateToolCalls(expectedToolCalls, actualToolCalls);
+  }
+  extractExpectedToolCalls(segments) {
+    if (!segments) {
+      return [];
+    }
+    const toolCalls = [];
+    for (const segment of segments) {
+      const role = segment.role;
+      const segmentToolCalls = segment.tool_calls;
+      if (role === "assistant" && Array.isArray(segmentToolCalls)) {
+        for (const tc of segmentToolCalls) {
+          if (typeof tc === "object" && tc !== null && typeof tc.tool === "string") {
+            const toolCall = tc;
+            toolCalls.push({ tool: toolCall.tool, input: toolCall.input });
+          }
+        }
+      }
+    }
+    return toolCalls;
+  }
+  validateToolCalls(expected, actual) {
+    const hits = [];
+    const misses = [];
+    for (let i = 0; i < expected.length; i++) {
+      const expectedCall = expected[i];
+      const actualCall = actual[i];
+      if (!actualCall) {
+        misses.push(
+          `tool_calls[${i}]: expected ${expectedCall.tool}, but no more tool calls in trace`
+        );
+        continue;
+      }
+      if (actualCall.name !== expectedCall.tool) {
+        misses.push(
+          `tool_calls[${i}]: expected ${expectedCall.tool}, got ${actualCall.name ?? "unknown"}`
+        );
+        continue;
+      }
+      if (expectedCall.input !== void 0) {
+        if (!this.deepEquals(expectedCall.input, actualCall.input)) {
+          misses.push(`tool_calls[${i}]: ${expectedCall.tool} input mismatch`);
+          continue;
+        }
+      }
+      hits.push(`tool_calls[${i}]: ${expectedCall.tool} matched`);
+    }
+    const totalChecks = expected.length || 1;
+    const score = hits.length / totalChecks;
+    return {
+      score,
+      verdict: score >= 0.8 ? "pass" : score >= 0.6 ? "borderline" : "fail",
+      hits,
+      misses,
+      expectedAspectCount: totalChecks
+    };
+  }
+  deepEquals(a, b) {
+    if (a === b) return true;
+    if (typeof a !== typeof b) return false;
+    if (typeof a !== "object" || a === null || b === null) return false;
+    if (Array.isArray(a) && Array.isArray(b)) {
+      if (a.length !== b.length) return false;
+      return a.every((val, i) => this.deepEquals(val, b[i]));
+    }
+    if (Array.isArray(a) || Array.isArray(b)) return false;
+    const aObj = a;
+    const bObj = b;
+    const aKeys = Object.keys(aObj);
+    const bKeys = Object.keys(bObj);
+    if (aKeys.length !== bKeys.length) return false;
+    return aKeys.every((key) => this.deepEquals(aObj[key], bObj[key]));
+  }
+};
 var DEFAULT_COMPOSITE_AGGREGATOR_PROMPT = `Review the following evaluation results:
 {{EVALUATOR_RESULTS_JSON}}
 
@@ -3851,7 +4300,7 @@ async function runEvaluation(options) {
     if (!definition) {
       return void 0;
     }
-    const resolved = resolveTargetDefinition(definition, envLookup);
+    const resolved = resolveTargetDefinition(definition, envLookup, evalFilePath);
     resolvedTargetsByName.set(name, resolved);
     return resolved;
   };
@@ -4165,6 +4614,17 @@ async function runEvalCase(options) {
   if (cacheKey && cache && !cachedResponse) {
     await cache.set(cacheKey, providerResponse);
   }
+  let candidateTrace = providerResponse.trace;
+  if (!candidateTrace && providerResponse.traceRef) {
+    try {
+      const rawTrace = await readJsonFile(providerResponse.traceRef);
+      if (Array.isArray(rawTrace) && rawTrace.every(isTraceEvent)) {
+        candidateTrace = rawTrace;
+      }
+    } catch {
+    }
+  }
+  const candidateTraceSummary = candidateTrace ? computeTraceSummary(candidateTrace) : void 0;
   try {
     return await evaluateCandidate({
       evalCase,
@@ -4176,7 +4636,9 @@ async function runEvalCase(options) {
       nowFn,
       attempt,
       judgeProvider,
-      agentTimeoutMs
+      agentTimeoutMs,
+      candidateTrace,
+      candidateTraceSummary
     });
   } catch (error) {
     return buildErrorResult(evalCase, target.name, nowFn(), error, promptInputs, provider);
@@ -4193,7 +4655,9 @@ async function evaluateCandidate(options) {
     nowFn,
     attempt,
     judgeProvider,
-    agentTimeoutMs
+    agentTimeoutMs,
+    candidateTrace,
+    candidateTraceSummary
   } = options;
   const gradeTimestamp = nowFn();
   const { score, evaluatorResults } = await runEvaluatorsForCase({
@@ -4206,7 +4670,9 @@ async function evaluateCandidate(options) {
     promptInputs,
     now: gradeTimestamp,
     judgeProvider,
-    agentTimeoutMs
+    agentTimeoutMs,
+    candidateTrace,
+    candidateTraceSummary
   });
   const completedAt = nowFn();
   let agentProviderRequest;
@@ -4245,7 +4711,8 @@ async function evaluateCandidate(options) {
     agent_provider_request: agentProviderRequest,
     lm_provider_request: lmProviderRequest,
     evaluator_provider_request: evaluatorResults ? void 0 : score.evaluatorRawRequest,
-    evaluator_results: evaluatorResults
+    evaluator_results: evaluatorResults,
+    trace_summary: candidateTraceSummary
   };
 }
 async function runEvaluatorsForCase(options) {
@@ -4259,7 +4726,9 @@ async function runEvaluatorsForCase(options) {
     promptInputs,
     now,
     judgeProvider,
-    agentTimeoutMs
+    agentTimeoutMs,
+    candidateTrace,
+    candidateTraceSummary
   } = options;
   if (evalCase.evaluators && evalCase.evaluators.length > 0) {
     return runEvaluatorList({
@@ -4273,7 +4742,9 @@ async function runEvaluatorsForCase(options) {
       promptInputs,
       now,
       judgeProvider,
-      agentTimeoutMs
+      agentTimeoutMs,
+      candidateTrace,
+      candidateTraceSummary
     });
   }
   const evaluatorKind = evalCase.evaluator ?? "llm_judge";
@@ -4289,7 +4760,9 @@ async function runEvaluatorsForCase(options) {
     attempt,
     promptInputs,
     now,
-    judgeProvider
+    judgeProvider,
+    candidateTrace,
+    candidateTraceSummary
   });
   return { score };
 }
@@ -4305,7 +4778,9 @@ async function runEvaluatorList(options) {
     promptInputs,
     now,
     judgeProvider,
-    agentTimeoutMs
+    agentTimeoutMs,
+    candidateTrace,
+    candidateTraceSummary
   } = options;
   const scored = [];
   const evaluatorResults = [];
@@ -4381,6 +4856,12 @@ async function runEvaluatorList(options) {
                 cwd: evalFileDir,
                 evaluatorFactory: { create: createEvaluator }
               });
+            case "tool_trajectory":
+              return new ToolTrajectoryEvaluator({
+                config: memberConfig
+              });
+            case "expected_messages":
+              return new ExpectedMessagesEvaluator();
             default: {
               const unknownConfig = memberConfig;
               throw new Error(`Unsupported evaluator type in composite: ${unknownConfig.type}`);
@@ -4415,6 +4896,56 @@ async function runEvaluatorList(options) {
           evaluator_results: mapChildResults(score2.evaluatorResults)
         });
       }
+      if (evaluator.type === "tool_trajectory") {
+        const trajectoryEvaluator = new ToolTrajectoryEvaluator({
+          config: evaluator
+        });
+        const score2 = trajectoryEvaluator.evaluate({
+          evalCase,
+          candidate,
+          target,
+          provider,
+          attempt,
+          promptInputs,
+          now,
+          candidateTrace,
+          candidateTraceSummary
+        });
+        scored.push({ score: score2, name: evaluator.name, type: evaluator.type });
+        evaluatorResults.push({
+          name: evaluator.name,
+          type: evaluator.type,
+          score: score2.score,
+          verdict: score2.verdict,
+          hits: score2.hits,
+          misses: score2.misses,
+          reasoning: score2.reasoning
+        });
+      }
+      if (evaluator.type === "expected_messages") {
+        const expectedMessagesEvaluator = new ExpectedMessagesEvaluator();
+        const score2 = expectedMessagesEvaluator.evaluate({
+          evalCase,
+          candidate,
+          target,
+          provider,
+          attempt,
+          promptInputs,
+          now,
+          candidateTrace,
+          candidateTraceSummary
+        });
+        scored.push({ score: score2, name: evaluator.name, type: evaluator.type });
+        evaluatorResults.push({
+          name: evaluator.name,
+          type: evaluator.type,
+          score: score2.score,
+          verdict: score2.verdict,
+          hits: score2.hits,
+          misses: score2.misses,
+          reasoning: score2.reasoning
+        });
+      }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       const fallbackScore = {
@@ -4756,11 +5287,14 @@ function createAgentKernel() {
 export {
   CodeEvaluator,
   CompositeEvaluator,
+  ExpectedMessagesEvaluator,
   LlmJudgeEvaluator,
   TEST_MESSAGE_ROLES,
+  ToolTrajectoryEvaluator,
   buildDirectoryChain,
   buildPromptInputs,
   buildSearchRoots,
+  computeTraceSummary,
   consumeCodexLogEntries,
   createAgentKernel,
   createProvider,
@@ -4771,14 +5305,18 @@ export {
   generateRubrics,
   getHitCount,
   isEvaluatorKind,
+  isExpectedToolCall,
   isGuidelineFile,
   isJsonObject,
   isJsonValue,
   isTestMessage,
   isTestMessageRole,
+  isTraceEvent,
+  isTraceEventType,
   listTargetNames,
   loadEvalCases,
   normalizeLineEndings,
+  readJsonFile,
   readTargetDefinitions,
   readTestSuiteMetadata,
   readTextFile,