@vitest-evals/core 0.13.0 → 0.14.0

package/dist/index.mjs

@@ -16,7 +16,7 @@ var JsonValueSchema = z.lazy(
 var JsonObjectSchema = z.record(z.string(), JsonValueSchema);
 
 // src/harness/index.ts
-import { z as z3 } from "zod";
+import { z as z5 } from "zod";
 
 // src/schema-utils.ts
 import { z as z2 } from "zod";
@@ -47,10 +47,232 @@ function isRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 
+// src/harness/errors.ts
+import { z as z3 } from "zod";
+var NormalizedErrorSchema = z3.object({
+  message: z3.string(),
+  type: z3.string().optional()
+}).catchall(JsonValueSchema);
+
+// src/harness/transcript.ts
+import { z as z4 } from "zod";
+var TranscriptToolCallEventSchema = z4.object({
+  type: z4.literal("tool_call"),
+  id: z4.string(),
+  name: z4.string(),
+  arguments: JsonObjectSchema.optional(),
+  startedAt: z4.string().optional(),
+  finishedAt: z4.string().optional(),
+  durationMs: FiniteNumberSchema.optional(),
+  metadata: JsonObjectSchema.optional()
+}).strict();
+var TranscriptMessageEventSchema = z4.object({
+  type: z4.literal("message"),
+  role: z4.enum(["system", "user", "assistant"]),
+  content: JsonValueSchema.optional(),
+  metadata: JsonObjectSchema.optional()
+}).strict();
+var TranscriptToolResultEventSchema = z4.object({
+  type: z4.literal("tool_result"),
+  toolCallId: z4.string(),
+  name: z4.string().optional(),
+  content: JsonValueSchema.optional(),
+  error: NormalizedErrorSchema.optional(),
+  startedAt: z4.string().optional(),
+  finishedAt: z4.string().optional(),
+  durationMs: FiniteNumberSchema.optional(),
+  metadata: JsonObjectSchema.optional()
+}).strict();
+var TranscriptEventSchema = z4.discriminatedUnion("type", [
+  TranscriptMessageEventSchema,
+  TranscriptToolCallEventSchema,
+  TranscriptToolResultEventSchema
+]);
+function messagesToTranscriptEvents(messages) {
+  const events = [];
+  for (const [messageIndex, message] of messages.entries()) {
+    if (message.role === "tool") {
+      const partEvents2 = contentPartEvents(message);
+      if (partEvents2) {
+        events.push(...partEvents2);
+        continue;
+      }
+      if (!hasTopLevelToolCallId(message)) {
+        throw new TypeError("Tool result messages must include toolCallId.");
+      }
+      events.push(toolResultMessageEvent(message, message.toolCallId));
+      continue;
+    }
+    const partEvents = message.role === "assistant" ? contentPartEvents(message) : void 0;
+    const partEventsHaveToolCalls = partEvents?.some(
+      (event) => event.type === "tool_call"
+    );
+    if (partEvents) {
+      events.push(...partEvents);
+    } else if (message.content !== void 0) {
+      events.push({
+        type: "message",
+        role: message.role,
+        content: message.content,
+        ...message.metadata ? { metadata: message.metadata } : {}
+      });
+    }
+    if (message.role !== "assistant") {
+      continue;
+    }
+    if (partEventsHaveToolCalls) {
+      if ((message.toolCalls ?? []).length > 0) {
+        throw new TypeError(
+          "Assistant messages must not mix tool-call content parts with toolCalls."
+        );
+      }
+      continue;
+    }
+    const messageToolCalls = message.toolCalls ?? [];
+    for (const [toolIndex, toolCall] of messageToolCalls.entries()) {
+      const rawToolCall = toolCall;
+      if (Object.prototype.hasOwnProperty.call(rawToolCall, "result") || Object.prototype.hasOwnProperty.call(rawToolCall, "error")) {
+        throw new TypeError(
+          "Assistant tool calls must use separate tool result messages."
+        );
+      }
+      if (typeof toolCall.name !== "string" || toolCall.name.length === 0) {
+        throw new TypeError("Assistant tool calls must include name.");
+      }
+      const id = toolCall.id ?? `message-${messageIndex}:tool-call-${toolIndex}`;
+      events.push({
+        type: "tool_call",
+        id,
+        name: toolCall.name,
+        ...normalizeToolCallArguments(toolCall.arguments),
+        ...toolCall.startedAt ? { startedAt: toolCall.startedAt } : {},
+        ...toolCall.finishedAt ? { finishedAt: toolCall.finishedAt } : {},
+        ...toolCall.durationMs !== void 0 ? { durationMs: toolCall.durationMs } : {},
+        ...toolCall.metadata ? { metadata: toolCall.metadata } : {}
+      });
+    }
+  }
+  return events;
+}
+function contentPartEvents(message) {
+  if (!Array.isArray(message.content)) {
+    return void 0;
+  }
+  const events = [];
+  for (const part of message.content) {
+    if (!isJsonObject2(part) || typeof part.type !== "string") {
+      continue;
+    }
+    if (part.type === "text" && typeof part.text === "string") {
+      if (message.role === "tool") {
+        throw new TypeError("Text content parts require message role.");
+      }
+      events.push({
+        type: "message",
+        role: message.role,
+        content: part.text,
+        ...recordMetadata(message.metadata)
+      });
+      continue;
+    }
+    if (part.type === "tool-call") {
+      if (message.role !== "assistant" || typeof part.toolCallId !== "string" || typeof part.toolName !== "string") {
+        throw new TypeError(
+          "Tool-call content parts require assistant role, toolCallId, and toolName."
+        );
+      }
+      events.push({
+        type: "tool_call",
+        id: part.toolCallId,
+        name: part.toolName,
+        ...normalizeToolCallArguments(part.input),
+        ...jsonTimeFields(part),
+        ...jsonMetadata(part.metadata)
+      });
+      continue;
+    }
+    if (part.type === "tool-result") {
+      if (message.role !== "tool" || typeof part.toolCallId !== "string") {
+        throw new TypeError(
+          "Tool-result content parts require tool role and toolCallId."
+        );
+      }
+      if (hasTopLevelToolCallId(message)) {
+        throw new TypeError(
+          "Tool-result content parts must not include top-level toolCallId."
+        );
+      }
+      events.push({
+        type: "tool_result",
+        toolCallId: part.toolCallId,
+        ...typeof part.toolName === "string" ? { name: part.toolName } : {},
+        ...part.output !== void 0 ? { content: part.output } : {},
+        ...part.error ? { error: part.error } : {},
+        ...jsonTimeFields(part),
+        ...jsonMetadata(part.metadata)
+      });
+      continue;
+    }
+    throw new TypeError(
+      "Message content parts must use the harness message contract."
+    );
+  }
+  return events.length > 0 ? events : void 0;
+}
+function toolResultMessageEvent(message, toolCallId) {
+  return {
+    type: "tool_result",
+    toolCallId,
+    ...message.name ? { name: message.name } : {},
+    ...message.content !== void 0 ? { content: message.content } : {},
+    ...message.error ? { error: message.error } : {},
+    ...timeFields(message),
+    ...recordMetadata(message.metadata)
+  };
+}
+function hasTopLevelToolCallId(message) {
+  return typeof message.toolCallId === "string";
+}
+function timeFields(input) {
+  return {
+    ...input.startedAt ? { startedAt: input.startedAt } : {},
+    ...input.finishedAt ? { finishedAt: input.finishedAt } : {},
+    ...input.durationMs !== void 0 ? { durationMs: input.durationMs } : {}
+  };
+}
+function recordMetadata(metadata) {
+  return metadata ? { metadata } : {};
+}
+function jsonTimeFields(input) {
+  return {
+    ...typeof input.startedAt === "string" ? { startedAt: input.startedAt } : {},
+    ...typeof input.finishedAt === "string" ? { finishedAt: input.finishedAt } : {},
+    ...typeof input.durationMs === "number" ? { durationMs: input.durationMs } : {}
+  };
+}
+function jsonMetadata(value) {
+  return isJsonObject2(value) ? { metadata: value } : {};
+}
+function normalizeToolCallArguments(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? { arguments: value } : {};
+}
+function isJsonObject2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isMessageEvent(event) {
+  return event.type === "message";
+}
+function isToolCallEvent(event) {
+  return event.type === "tool_call";
+}
+function isToolResultEvent(event) {
+  return event.type === "tool_result";
+}
+
 // src/harness/index.ts
-var UsageSummarySchema = z3.object({
-  provider: z3.string().optional(),
-  model: z3.string().optional(),
+var UsageSummarySchema = z5.object({
+  provider: z5.string().optional(),
+  model: z5.string().optional(),
   inputTokens: FiniteNumberSchema.optional(),
   outputTokens: FiniteNumberSchema.optional(),
   reasoningTokens: FiniteNumberSchema.optional(),
@@ -59,182 +281,213 @@ var UsageSummarySchema = z3.object({
   retries: FiniteNumberSchema.optional(),
   metadata: JsonObjectSchema.optional()
 }).strict();
-var TimingSummarySchema = z3.object({
+var TimingSummarySchema = z5.object({
   totalMs: FiniteNumberSchema.optional(),
   metadata: JsonObjectSchema.optional()
 }).strict();
-var NormalizedErrorSchema = z3.object({
-  message: z3.string(),
-  type: z3.string().optional()
-}).catchall(JsonValueSchema);
-var ToolCallRecordSchema = z3.object({
-  id: z3.string().optional(),
-  name: z3.string(),
-  arguments: JsonObjectSchema.optional(),
-  result: JsonValueSchema.optional(),
-  error: NormalizedErrorSchema.optional(),
-  startedAt: z3.string().optional(),
-  finishedAt: z3.string().optional(),
-  durationMs: FiniteNumberSchema.optional(),
-  metadata: JsonObjectSchema.optional()
-}).strict();
-var NormalizedMessageSchema = z3.object({
-  role: z3.enum(["system", "user", "assistant", "tool"]),
-  content: JsonValueSchema.optional(),
-  toolCalls: z3.array(ToolCallRecordSchema).optional(),
-  metadata: JsonObjectSchema.optional()
+var ToolCallBaseSchema = z5.object({
+  name: z5.string(),
+  arguments: JsonObjectSchema.optional()
 }).strict();
-var NormalizedSessionSchema = z3.object({
-  messages: z3.array(NormalizedMessageSchema).default([]),
-  provider: z3.string().optional(),
-  model: z3.string().optional(),
+var ToolCallSchema = z5.discriminatedUnion("status", [
+  ToolCallBaseSchema.extend({
+    status: z5.literal("pending")
+  }).strict(),
+  ToolCallBaseSchema.extend({
+    status: z5.literal("ok"),
+    result: JsonValueSchema.optional()
+  }).strict(),
+  ToolCallBaseSchema.extend({
+    status: z5.literal("error"),
+    error: NormalizedErrorSchema
+  }).strict()
+]);
+var NormalizedSessionSchema = z5.object({
+  events: z5.array(TranscriptEventSchema),
+  provider: z5.string().optional(),
+  model: z5.string().optional(),
   metadata: JsonObjectSchema.optional()
 }).strict();
 var NormalizedSpanAttributesSchema = JsonObjectSchema;
-var NormalizedSpanEventSchema = z3.object({
-  name: z3.string(),
-  timestamp: z3.string().optional(),
+var NormalizedSpanEventSchema = z5.object({
+  name: z5.string(),
+  timestamp: z5.string().optional(),
   attributes: NormalizedSpanAttributesSchema.optional()
 }).strict();
-var NormalizedSpanSchema = z3.object({
-  id: z3.string().optional(),
-  traceId: z3.string().optional(),
-  parentId: z3.string().optional(),
-  name: z3.string(),
-  kind: z3.enum(["run", "agent", "model", "tool", "guardrail", "handoff", "custom"]).optional(),
-  startedAt: z3.string().optional(),
-  finishedAt: z3.string().optional(),
+var NormalizedSpanSchema = z5.object({
+  id: z5.string().optional(),
+  traceId: z5.string().optional(),
+  parentId: z5.string().optional(),
+  name: z5.string(),
+  kind: z5.enum(["run", "agent", "model", "tool", "guardrail", "handoff", "custom"]).optional(),
+  startedAt: z5.string().optional(),
+  finishedAt: z5.string().optional(),
   durationMs: FiniteNumberSchema.optional(),
-  status: z3.enum(["ok", "error"]).optional(),
+  status: z5.enum(["ok", "error"]).optional(),
   error: NormalizedErrorSchema.optional(),
   attributes: NormalizedSpanAttributesSchema.optional(),
-  events: z3.array(NormalizedSpanEventSchema).optional()
+  events: z5.array(NormalizedSpanEventSchema).optional()
 }).strict();
-var NormalizedTraceSchema = z3.object({
-  id: z3.string().optional(),
-  name: z3.string().optional(),
-  startedAt: z3.string().optional(),
-  finishedAt: z3.string().optional(),
+var NormalizedTraceSchema = z5.object({
+  id: z5.string().optional(),
+  name: z5.string().optional(),
+  startedAt: z5.string().optional(),
+  finishedAt: z5.string().optional(),
   durationMs: FiniteNumberSchema.optional(),
   metadata: JsonObjectSchema.optional(),
-  spans: z3.array(NormalizedSpanSchema).default([])
+  spans: z5.array(NormalizedSpanSchema)
 }).strict();
-var HarnessRunSchema = z3.object({
+var HarnessRunSchema = z5.object({
   output: JsonValueSchema.optional(),
   session: NormalizedSessionSchema,
   usage: UsageSummarySchema,
   timings: TimingSummarySchema.optional(),
   artifacts: JsonObjectSchema.optional(),
-  traces: z3.array(NormalizedTraceSchema).optional(),
-  errors: z3.array(JsonObjectSchema).default([])
+  traces: z5.array(NormalizedTraceSchema).optional(),
+  errors: z5.array(JsonObjectSchema)
 }).strict();
 
 // src/harness/helpers.ts
-function toolCalls(session) {
-  return session.messages.flatMap((message) => message.toolCalls ?? []);
+function toolCalls(source) {
+  const resultsById = /* @__PURE__ */ new Map();
+  for (const message of toolResultsFromSource(source)) {
+    if (!resultsById.has(message.toolCallId)) {
+      resultsById.set(message.toolCallId, message);
+    }
+  }
+  return toolCallsFromSource(source).map((call) => {
+    const result = resultsById.get(call.id);
+    const normalizedCall = {
+      name: call.name,
+      ...call.arguments ? { arguments: call.arguments } : {}
+    };
+    if (!result) {
+      return {
+        ...normalizedCall,
+        status: "pending"
+      };
+    }
+    if (result.error) {
+      return {
+        ...normalizedCall,
+        status: "error",
+        error: result.error
+      };
+    }
+    return {
+      ...normalizedCall,
+      status: "ok",
+      ...result.content !== void 0 ? { result: result.content } : {}
+    };
+  });
 }
-function spans(run) {
-  return (run.traces ?? []).flatMap((trace) => trace.spans);
+function spans(source) {
+  return spansFrom(source);
 }
-function traceSpans(run) {
-  return spans(run);
+function traceSpans(source) {
+  return spansFrom(source);
 }
-function spansByKind(run, kind) {
-  return spans(run).filter((span) => span.kind === kind);
+function spansByKind(source, kind) {
+  return spansFrom(source).filter((span) => span.kind === kind);
 }
-function failedSpans(run) {
-  return spans(run).filter(
+function failedSpans(source) {
+  return spansFrom(source).filter(
     (span) => span.status === "error" || span.error !== void 0
   );
 }
-function messagesByRole(session, role) {
-  return session.messages.filter((message) => message.role === role);
+function messagesByRole(source, role) {
+  return sessionFrom(source).events.filter(
+    (event) => event.type === "message" && event.role === role
+  );
+}
+function systemMessages(source) {
+  return messagesByRoleFromSource(source, "system");
+}
+function userMessages(source) {
+  return messagesByRoleFromSource(source, "user");
+}
+function assistantMessages(source) {
+  return messagesByRoleFromSource(source, "assistant");
 }
-function systemMessages(session) {
-  return messagesByRole(session, "system");
+function latestAssistantMessageContent(source) {
+  return [...messagesByRoleFromSource(source, "assistant")].reverse().find(hasNonEmptyMessageContent)?.content;
 }
-function userMessages(session) {
-  return messagesByRole(session, "user");
+function toolMessages(source) {
+  return toolResultsFromSource(source);
 }
-function assistantMessages(session) {
-  return messagesByRole(session, "assistant");
+function sessionFrom(source) {
+  return "session" in source ? source.session : source;
 }
-function latestAssistantMessageContent(session) {
-  return [...assistantMessages(session)].reverse().find(hasNonEmptyMessageContent)?.content;
+function toolResultsFromSource(source) {
+  return sessionFrom(source).events.filter(isToolResultEvent);
 }
-function toolMessages(session) {
-  return messagesByRole(session, "tool");
+function toolCallsFromSource(source) {
+  return sessionFrom(source).events.filter(isToolCallEvent);
+}
+function tracesFrom(source) {
+  if (source === void 0) {
+    return [];
+  }
+  if (isTraceList(source)) {
+    return source;
+  }
+  return source.traces ?? [];
+}
+function spansFrom(source) {
+  return tracesFrom(source).flatMap((trace) => trace.spans);
+}
+function isTraceList(source) {
+  return Array.isArray(source);
+}
+function messagesByRoleFromSource(source, role) {
+  return sessionFrom(source).events.filter(
+    (event) => event.type === "message" && event.role === role
+  );
 }
 function hasNonEmptyMessageContent(message) {
   return message.content !== void 0 && (typeof message.content !== "string" || message.content.trim().length > 0);
 }
 
 // src/report/metadata.ts
-import { z as z4 } from "zod";
-var HarnessMetaSchema = z4.object({
-  name: z4.string().optional(),
+import { z as z6 } from "zod";
+var HarnessMetaSchema = z6.object({
+  name: z6.string().optional(),
   run: HarnessRunSchema.optional()
 }).strict();
-var EvalScoreSchema = z4.object({
-  name: z4.string().optional(),
+var EvalScoreSchema = z6.object({
+  name: z6.string().optional(),
   score: NullableFiniteNumberSchema,
   metadata: JsonObjectSchema.optional()
 }).strict();
-var EvalMetaSchema = z4.object({
-  scores: z4.array(EvalScoreSchema).optional(),
+var EvalMetaSchema = z6.object({
+  scores: z6.array(EvalScoreSchema).optional(),
   avgScore: NullableFiniteNumberSchema,
   output: JsonValueSchema.optional(),
-  thresholdFailed: z4.boolean().optional(),
-  toolCalls: z4.array(ToolCallRecordSchema).optional()
+  thresholdFailed: z6.boolean().optional(),
+  toolCalls: z6.array(ToolCallSchema).optional()
 }).strict();
-var EvalTaskMetaSchema = z4.object({
+var EvalTaskMetaSchema = z6.object({
   eval: EvalMetaSchema.optional(),
   harness: HarnessMetaSchema.optional()
 }).strict();
-var LenientToolCallRecordSchema = ToolCallRecordSchema.strip();
-var LenientMessageSchema = NormalizedMessageSchema.extend({
-  toolCalls: z4.array(LenientToolCallRecordSchema).optional().catch(void 0)
-}).strip();
-var LenientSessionSchema = NormalizedSessionSchema.extend({
-  messages: z4.array(LenientMessageSchema).default([]).catch([])
-}).strip();
-var LenientSpanEventSchema = NormalizedSpanEventSchema.strip();
-var LenientSpanSchema = NormalizedSpanSchema.extend({
-  events: z4.array(LenientSpanEventSchema).optional().catch(void 0)
-}).strip();
-var LenientTraceSchema = NormalizedTraceSchema.extend({
-  spans: z4.array(LenientSpanSchema).default([]).catch([])
-}).strip();
-var LenientHarnessRunSchema = HarnessRunSchema.extend({
-  session: LenientSessionSchema,
-  usage: UsageSummarySchema.strip().default({}),
-  timings: TimingSummarySchema.strip().optional(),
-  traces: z4.array(LenientTraceSchema).optional().catch(void 0)
-}).strip();
-var LenientHarnessMetaSchema = HarnessMetaSchema.extend({
-  run: LenientHarnessRunSchema.optional().catch(void 0)
-}).strip();
-var LenientEvalScoreSchema = EvalScoreSchema.strip();
-var LenientEvalMetaSchema = EvalMetaSchema.extend({
-  scores: z4.array(LenientEvalScoreSchema).optional().catch(void 0),
-  toolCalls: z4.array(LenientToolCallRecordSchema).optional().catch(void 0)
-}).strip();
 function readEvalTaskMeta(input) {
   if (!isJsonObject(input)) {
     return void 0;
   }
-  const evalResult = LenientEvalMetaSchema.safeParse(input.eval);
-  const harnessResult = LenientHarnessMetaSchema.safeParse(input.harness);
   const meta = {
-    ...evalResult.success && input.eval !== void 0 ? { eval: evalResult.data } : {},
-    ...harnessResult.success && input.harness !== void 0 ? { harness: harnessResult.data } : {}
+    ...input.eval !== void 0 ? { eval: input.eval } : {},
+    ...input.harness !== void 0 ? { harness: input.harness } : {}
   };
-  return meta.eval || meta.harness ? meta : void 0;
+  if (!("eval" in meta) && !("harness" in meta)) {
+    return void 0;
+  }
+  const result = EvalTaskMetaSchema.safeParse(meta);
+  return result.success ? result.data : void 0;
 }
 
 // src/report/vitest-json.ts
-import { z as z5 } from "zod";
-var VitestJsonStatusSchema = z5.enum([
+import { z as z7 } from "zod";
+var VitestJsonStatusSchema = z7.enum([
   "passed",
   "failed",
   "skipped",
@@ -242,53 +495,53 @@ var VitestJsonStatusSchema = z5.enum([
   "todo",
   "disabled"
 ]);
-var VitestJsonLocationSchema = z5.object({
+var VitestJsonLocationSchema = z7.object({
   line: FiniteNumberSchema,
   column: FiniteNumberSchema
 }).passthrough();
-var VitestJsonAssertionSchema = z5.object({
-  ancestorTitles: z5.array(z5.string()).default([]),
-  fullName: z5.string(),
+var VitestJsonAssertionSchema = z7.object({
+  ancestorTitles: z7.array(z7.string()).default([]),
+  fullName: z7.string(),
   status: VitestJsonStatusSchema,
-  title: z5.string(),
-  meta: z5.unknown().optional(),
+  title: z7.string(),
+  meta: z7.unknown().optional(),
   duration: FiniteNumberSchema.nullable().optional(),
-  failureMessages: z5.array(z5.string()).nullable().optional(),
+  failureMessages: z7.array(z7.string()).nullable().optional(),
   location: VitestJsonLocationSchema.nullable().optional(),
-  tags: z5.array(z5.string()).optional()
+  tags: z7.array(z7.string()).optional()
 }).passthrough();
-var VitestJsonFileSchema = z5.object({
-  message: z5.string(),
-  name: z5.string(),
-  status: z5.enum(["failed", "passed"]),
+var VitestJsonFileSchema = z7.object({
+  message: z7.string(),
+  name: z7.string(),
+  status: z7.enum(["failed", "passed"]),
   startTime: OptionalFiniteNumberSchema,
   endTime: OptionalFiniteNumberSchema,
-  assertionResults: z5.array(VitestJsonAssertionSchema).default([])
+  assertionResults: z7.array(VitestJsonAssertionSchema).default([])
 }).passthrough();
-var VitestJsonReportSchema = z5.object({
+var VitestJsonReportSchema = z7.object({
   numFailedTests: FiniteNumberSchema,
   numPassedTests: FiniteNumberSchema,
   numPendingTests: FiniteNumberSchema,
   numTodoTests: FiniteNumberSchema,
   numTotalTests: FiniteNumberSchema,
   startTime: FiniteNumberSchema,
-  success: z5.boolean(),
-  testResults: z5.array(VitestJsonFileSchema).default([])
+  success: z7.boolean(),
+  testResults: z7.array(VitestJsonFileSchema).default([])
 }).passthrough();
 function parseVitestJsonReport(input) {
   return parseWithSchema(VitestJsonReportSchema, input, "Vitest JSON report");
 }
 
 // src/report/workspace.ts
-import { z as z6 } from "zod";
+import { z as z8 } from "zod";
 var REPORT_WORKSPACE_SCHEMA_VERSION = 1;
-var ReportRunSchema = z6.object({
-  id: z6.string(),
-  source: z6.string().optional(),
-  status: z6.enum(["passed", "failed"]),
+var ReportRunSchema = z8.object({
+  id: z8.string(),
+  source: z8.string().optional(),
+  status: z8.enum(["passed", "failed"]),
   startedAt: FiniteNumberSchema.optional(),
   durationMs: FiniteNumberSchema.optional(),
-  totals: z6.object({
+  totals: z8.object({
     total: FiniteNumberSchema,
     passed: FiniteNumberSchema,
     failed: FiniteNumberSchema,
@@ -298,28 +551,28 @@ var ReportRunSchema = z6.object({
     evalFailed: FiniteNumberSchema
   })
 }).strict();
-var ReportCaseSchema = z6.object({
-  id: z6.string(),
-  runId: z6.string(),
-  source: z6.string().optional(),
-  file: z6.string(),
-  displayFile: z6.string(),
-  title: z6.string(),
-  fullName: z6.string(),
-  ancestorTitles: z6.array(z6.string()),
-  tags: z6.array(z6.string()).optional(),
-  displayName: z6.string(),
+var ReportCaseSchema = z8.object({
+  id: z8.string(),
+  runId: z8.string(),
+  source: z8.string().optional(),
+  file: z8.string(),
+  displayFile: z8.string(),
+  title: z8.string(),
+  fullName: z8.string(),
+  ancestorTitles: z8.array(z8.string()),
+  tags: z8.array(z8.string()).optional(),
+  displayName: z8.string(),
   status: VitestJsonStatusSchema,
   durationMs: FiniteNumberSchema.optional(),
   location: VitestJsonLocationSchema.optional(),
-  failureMessages: z6.array(z6.string()).default([]),
+  failureMessages: z8.array(z8.string()).default([]),
   eval: EvalMetaSchema.optional(),
   harness: HarnessMetaSchema.optional()
 }).strict();
-var ReportWorkspaceSchema = z6.object({
-  schemaVersion: z6.literal(REPORT_WORKSPACE_SCHEMA_VERSION),
-  runs: z6.array(ReportRunSchema),
-  cases: z6.array(ReportCaseSchema)
+var ReportWorkspaceSchema = z8.object({
+  schemaVersion: z8.literal(REPORT_WORKSPACE_SCHEMA_VERSION),
+  runs: z8.array(ReportRunSchema),
+  cases: z8.array(ReportCaseSchema)
 }).strict();
 function parseReportWorkspace(input) {
   return parseWithSchema(ReportWorkspaceSchema, input, "report workspace");
@@ -452,7 +705,6 @@ export {
   JsonPrimitiveSchema,
   JsonValueSchema,
   NormalizedErrorSchema,
-  NormalizedMessageSchema,
   NormalizedSessionSchema,
   NormalizedSpanAttributesSchema,
   NormalizedSpanEventSchema,
@@ -463,7 +715,11 @@ export {
   ReportRunSchema,
   ReportWorkspaceSchema,
   TimingSummarySchema,
-  ToolCallRecordSchema,
+  ToolCallSchema,
+  TranscriptEventSchema,
+  TranscriptMessageEventSchema,
+  TranscriptToolCallEventSchema,
+  TranscriptToolResultEventSchema,
   UsageSummarySchema,
   VitestJsonAssertionSchema,
   VitestJsonFileSchema,
@@ -473,8 +729,12 @@ export {
   assistantMessages,
   collectReportWorkspace,
   failedSpans,
+  isMessageEvent,
+  isToolCallEvent,
+  isToolResultEvent,
   latestAssistantMessageContent,
   messagesByRole,
+  messagesToTranscriptEvents,
   parseReportWorkspace,
   parseVitestJsonReport,
   readEvalTaskMeta,