agent-inspect 6.12.1 → 6.13.0

package/packages/core/dist/{chunk-QT6CQ2XA.mjs → chunk-BS2QCAJX.mjs}

@@ -1,5 +1,320 @@
 import { extractOutcomesFromPersistedEvents, outcomesMatchingStatus } from './chunk-VFO76UH3.mjs';
 
+// packages/core/src/checks/logical-events.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function legacyEvent(event) {
+  const value = event.attributes?.legacyEvent;
+  return typeof value === "string" ? value : void 0;
+}
+function stepIdOf(event) {
+  const value = event.attributes?.stepId;
+  if (typeof value === "string" && value.trim() !== "") return value;
+  return void 0;
+}
+function cloneEvent(event) {
+  return {
+    ...event,
+    ...event.attributes !== void 0 ? { attributes: { ...event.attributes } } : {},
+    ...event.error !== void 0 ? { error: { ...event.error } } : {},
+    ...event.tokenUsage !== void 0 ? { tokenUsage: { ...event.tokenUsage } } : {},
+    ...event.source !== void 0 ? { source: { ...event.source } } : {}
+  };
+}
+function mergeAttributes(start, complete) {
+  const merged = {
+    ...isRecord(complete.attributes) ? complete.attributes : {},
+    ...isRecord(start.attributes) ? start.attributes : {}
+  };
+  merged.legacyEvent = start.attributes?.legacyEvent ?? complete.attributes?.legacyEvent;
+  merged.legacyCompleteEvent = complete.attributes?.legacyEvent;
+  if (complete.attributes?.errorStack !== void 0) {
+    merged.errorStack = complete.attributes.errorStack;
+  }
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function pairStartComplete(start, complete) {
+  const attributes = mergeAttributes(start, complete);
+  const paired = {
+    ...cloneEvent(start),
+    status: complete.status,
+    timestamp: complete.timestamp ?? start.timestamp,
+    ...complete.endedAt !== void 0 ? { endedAt: complete.endedAt } : {},
+    ...complete.durationMs !== void 0 ? { durationMs: complete.durationMs } : {},
+    ...complete.error !== void 0 ? { error: { ...complete.error } } : {},
+    ...complete.tokenUsage !== void 0 && start.tokenUsage === void 0 ? { tokenUsage: { ...complete.tokenUsage } } : {},
+    ...attributes !== void 0 ? { attributes } : {}
+  };
+  return {
+    ...paired,
+    sourceEventIds: Object.freeze([start.eventId, complete.eventId]),
+    projection: {
+      paired: true,
+      absorbedEventIds: Object.freeze([complete.eventId]),
+      parentNormalized: false,
+      ...start.parentId !== void 0 ? { originalParentId: start.parentId } : {}
+    }
+  };
+}
+function asLogical(event, extras) {
+  return {
+    ...cloneEvent(event),
+    sourceEventIds: Object.freeze([event.eventId]),
+    projection: {
+      paired: false,
+      absorbedEventIds: Object.freeze([]),
+      parentNormalized: extras?.parentNormalized === true,
+      ...{}
+    }
+  };
+}
+function projectLogicalEvents(events) {
+  const diagnostics = [];
+  const byRun = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const list = byRun.get(event.runId) ?? [];
+    list.push(event);
+    byRun.set(event.runId, list);
+  }
+  const absorbedIds = /* @__PURE__ */ new Set();
+  const logicalByRawId = /* @__PURE__ */ new Map();
+  const stepIdToLogicalId = /* @__PURE__ */ new Map();
+  const logical = [];
+  const orderedRuns = [...byRun.keys()].sort((a, b) => a.localeCompare(b));
+  for (const runId of orderedRuns) {
+    const runEvents = byRun.get(runId) ?? [];
+    const starts = [];
+    const completes = [];
+    const others = [];
+    for (const event of runEvents) {
+      const legacy = legacyEvent(event);
+      if (legacy === "step_started" || legacy === "run_started" && event.status === "running") {
+        starts.push(event);
+      } else if (legacy === "step_completed" || legacy === "run_completed") {
+        completes.push(event);
+      } else {
+        others.push(event);
+      }
+    }
+    const usedCompletes = /* @__PURE__ */ new Set();
+    for (const start of starts) {
+      const stepId = stepIdOf(start);
+      let match;
+      if (legacyEvent(start) === "run_started") {
+        const candidates = completes.filter(
+          (c) => !usedCompletes.has(c.eventId) && legacyEvent(c) === "run_completed"
+        );
+        if (candidates.length > 1) {
+          diagnostics.push({
+            code: "AI_LOGICAL_PAIR_AMBIGUOUS",
+            message: `Multiple run_completed rows for run ${runId}; using first by eventId.`,
+            eventIds: candidates.map((c) => c.eventId)
+          });
+          candidates.sort((a, b) => a.eventId.localeCompare(b.eventId));
+        }
+        match = candidates[0];
+      } else if (stepId) {
+        const candidates = completes.filter(
+          (c) => !usedCompletes.has(c.eventId) && legacyEvent(c) === "step_completed" && stepIdOf(c) === stepId
+        );
+        if (candidates.length > 1) {
+          diagnostics.push({
+            code: "AI_LOGICAL_PAIR_AMBIGUOUS",
+            message: `Multiple step_completed rows for stepId ${stepId}; using first by eventId.`,
+            eventIds: candidates.map((c) => c.eventId)
+          });
+          candidates.sort((a, b) => a.eventId.localeCompare(b.eventId));
+        }
+        match = candidates[0];
+      }
+      if (match) {
+        usedCompletes.add(match.eventId);
+        absorbedIds.add(match.eventId);
+        const paired = pairStartComplete(start, match);
+        logical.push(paired);
+        logicalByRawId.set(start.eventId, paired);
+        logicalByRawId.set(match.eventId, paired);
+        if (stepId) stepIdToLogicalId.set(`${runId}:${stepId}`, paired.eventId);
+      } else {
+        diagnostics.push({
+          code: "AI_LOGICAL_PAIR_UNMATCHED_START",
+          message: `No matching complete for start ${start.eventId}.`,
+          eventIds: [start.eventId]
+        });
+        const alone = asLogical(start);
+        logical.push(alone);
+        logicalByRawId.set(start.eventId, alone);
+        if (stepId) stepIdToLogicalId.set(`${runId}:${stepId}`, alone.eventId);
+      }
+    }
+    for (const complete of completes) {
+      if (usedCompletes.has(complete.eventId)) continue;
+      diagnostics.push({
+        code: "AI_LOGICAL_PAIR_UNMATCHED_COMPLETE",
+        message: `No matching start for complete ${complete.eventId}.`,
+        eventIds: [complete.eventId]
+      });
+      const alone = asLogical(complete);
+      logical.push(alone);
+      logicalByRawId.set(complete.eventId, alone);
+      const stepId = stepIdOf(complete);
+      if (stepId && !stepIdToLogicalId.has(`${runId}:${stepId}`)) {
+        stepIdToLogicalId.set(`${runId}:${stepId}`, alone.eventId);
+      }
+    }
+    for (const event of others) {
+      const alone = asLogical(event);
+      logical.push(alone);
+      logicalByRawId.set(event.eventId, alone);
+      const stepId = stepIdOf(event);
+      if (stepId && !stepIdToLogicalId.has(`${runId}:${stepId}`)) {
+        stepIdToLogicalId.set(`${runId}:${stepId}`, alone.eventId);
+      }
+    }
+  }
+  const logicalById = new Map(logical.map((e) => [e.eventId, e]));
+  const normalized = [];
+  for (const event of logical) {
+    const originalParentId = event.parentId;
+    if (!originalParentId) {
+      normalized.push(event);
+      continue;
+    }
+    let nextParent = originalParentId;
+    let remapped = false;
+    const viaAbsorbed = logicalByRawId.get(originalParentId);
+    if (viaAbsorbed && viaAbsorbed.eventId !== originalParentId) {
+      nextParent = viaAbsorbed.eventId;
+      remapped = true;
+    } else if (!logicalById.has(originalParentId)) {
+      const viaStep = stepIdToLogicalId.get(`${event.runId}:${originalParentId}`);
+      if (viaStep) {
+        nextParent = viaStep;
+        remapped = true;
+      }
+    }
+    if (!remapped) {
+      if (!logicalById.has(originalParentId) && !logicalByRawId.has(originalParentId)) {
+        const mapping = event.attributes?.parentMapping;
+        const unresolved = mapping === "unresolved" || event.attributes?.parentUnresolved === true || event.attributes?.unresolvedParent === true || // LangGraph/framework scaffolding sentinel labels are not event ids.
+        /^LangGraph$/i.test(originalParentId) || originalParentId.startsWith("unresolved:");
+        if (!unresolved) {
+          diagnostics.push({
+            code: "AI_LOGICAL_PARENT_UNRESOLVED",
+            message: `Parent ${originalParentId} unresolved for ${event.eventId}.`,
+            eventIds: [event.eventId]
+          });
+        }
+      }
+      normalized.push(event);
+      continue;
+    }
+    diagnostics.push({
+      code: "AI_LOGICAL_PARENT_REMAPPED",
+      message: `Remapped parent ${originalParentId} \u2192 ${nextParent} for ${event.eventId}.`,
+      eventIds: [event.eventId]
+    });
+    normalized.push({
+      ...event,
+      parentId: nextParent,
+      projection: {
+        ...event.projection,
+        parentNormalized: true,
+        originalParentId
+      }
+    });
+  }
+  const rawIndex = new Map(events.map((e, i) => [e.eventId, i]));
+  normalized.sort((a, b) => {
+    const ai = rawIndex.get(a.sourceEventIds[0]) ?? 0;
+    const bi = rawIndex.get(b.sourceEventIds[0]) ?? 0;
+    return ai - bi || a.eventId.localeCompare(b.eventId);
+  });
+  return {
+    logicalEvents: Object.freeze(normalized),
+    diagnostics: Object.freeze(diagnostics)
+  };
+}
+function resolveCanonicalToolName(event) {
+  const attrs = event.attributes;
+  const direct = pickString(attrs, ["toolName", "tool"]);
+  if (direct) return direct;
+  const metadata = attrs?.metadata;
+  if (isRecord(metadata)) {
+    const nested = pickString(metadata, ["toolName", "tool"]);
+    if (nested) return nested;
+  }
+  for (const prefix of ["tool:", "function:", "mcp-tools:"]) {
+    if (event.name.startsWith(prefix)) return event.name.slice(prefix.length);
+  }
+  return event.name;
+}
+function pickString(record, keys) {
+  if (!record) return void 0;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim() !== "") return value.trim();
+  }
+  return void 0;
+}
+
+// packages/core/src/checks/trace-facts.ts
+function summarizeSemanticParity(events) {
+  const projection = projectLogicalEvents(events);
+  const logical = projection.logicalEvents;
+  const finishedTools = logical.filter(
+    (event) => event.kind === "TOOL" && event.status !== "running"
+  );
+  const finishedToolNames = Object.freeze(
+    finishedTools.map((event) => resolveCanonicalToolName(event)).sort((a, b) => a.localeCompare(b))
+  );
+  return {
+    rawEventCount: events.length,
+    logicalEventCount: logical.length,
+    runningLogicalCount: logical.filter((event) => event.status === "running").length,
+    finishedToolNames,
+    finishedToolCount: finishedTools.length,
+    pairedCount: logical.filter((event) => event.projection.paired).length,
+    parentRemapCount: projection.diagnostics.filter(
+      (item) => item.code === "AI_LOGICAL_PARENT_REMAPPED"
+    ).length,
+    diagnostics: projection.diagnostics
+  };
+}
+function buildTraceFacts(events) {
+  const projection = projectLogicalEvents(events);
+  const toolsByName = /* @__PURE__ */ new Map();
+  const llmEvents = [];
+  const outcomeEvents = [];
+  for (const event of projection.logicalEvents) {
+    if (event.kind === "TOOL" && event.status !== "running") {
+      const name = resolveCanonicalToolName(event);
+      const list = toolsByName.get(name) ?? [];
+      list.push(event);
+      toolsByName.set(name, list);
+    }
+    if (event.kind === "LLM" && event.status !== "running") {
+      llmEvents.push(event);
+    }
+    if (event.kind === "OUTCOME") {
+      outcomeEvents.push(event);
+    }
+  }
+  for (const [name, list] of [...toolsByName.entries()]) {
+    toolsByName.set(name, Object.freeze([...list]));
+  }
+  return {
+    rawEvents: Object.freeze([...events]),
+    logicalEvents: projection.logicalEvents,
+    diagnostics: projection.diagnostics,
+    toolsByName,
+    llmEvents: Object.freeze(llmEvents),
+    outcomeEvents: Object.freeze(outcomeEvents),
+    summary: summarizeSemanticParity(events)
+  };
+}
+
 // packages/core/src/checks/index.ts
 var SEVERITY_RANK = {
   error: 0,
@@ -58,7 +373,11 @@ var DEFAULT_RAW_CONTENT_KEYS = [
   "conversationtext",
   "conversation_text"
 ];
-var DEFAULT_SAFE_RAW_CONTENT_PATH_PREFIXES = ["tokenUsage", "usage"];
+var DEFAULT_SAFE_RAW_CONTENT_PATH_PREFIXES = [
+  "tokenUsage",
+  "usage",
+  "tokens"
+];
 var SAFE_USAGE_LEAF_KEYS = /* @__PURE__ */ new Set([
   "input",
   "output",
@@ -134,10 +453,13 @@ function buildFacts(input, selectedRun) {
       childrenByParentId.set(parentId, children);
     }
   }
+  const projection = projectLogicalEvents(scopedEvents);
   return {
     format: input.read.format,
     runs: Object.freeze([...input.read.runs]),
     events: Object.freeze([...scopedEvents]),
+    logicalEvents: projection.logicalEvents,
+    logicalProjectionDiagnostics: projection.diagnostics,
     readerWarnings: Object.freeze([...input.read.warnings]),
     unsupportedFields: Object.freeze([...input.read.unsupportedFields]),
     sourceFiles: Object.freeze([...input.read.sourceFiles]),
@@ -330,7 +652,10 @@ function failFinding(ruleId, message, evidence, expected, actual, meta) {
   };
 }
 function toolName(event) {
-  return stringAttr(event, ["toolName", "tool"]) ?? stripPrefix(event.name, ["tool:", "function:", "mcp-tools:"]);
+  return resolveCanonicalToolName(event);
+}
+function semanticEvents(context) {
+  return context.logicalEvents ?? context.events;
 }
 function llmModel(event) {
   return stringAttr(event, ["model", "modelId", "responseModelId", "modelName", "model_name"]) ?? stripPrefix(event.name, ["llm:", "generation:", "transcription:", "speech:"]);
@@ -345,7 +670,7 @@ function retryCount(event) {
   return numericAttr(event, ["retryCount", "retryAttempt", "retry_attempt", "attempt"]);
 }
 function finishedEvents(context, kind) {
-  return context.events.filter(
+  return semanticEvents(context).filter(
     (event) => (kind === void 0 || event.kind === kind) && event.status !== "running"
   );
 }
@@ -357,7 +682,7 @@ function firstIndexByName(events) {
   }
   return index;
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function eventMap(events) {
@@ -411,7 +736,7 @@ function pushValueEntries(entries, event, value, path, key, depth = 0) {
     }
     return;
   }
-  if (!isRecord(value)) return;
+  if (!isRecord2(value)) return;
   for (const nestedKey of Object.keys(value).sort((a, b) => a.localeCompare(b))) {
     pushValueEntries(
       entries,
@@ -491,14 +816,11 @@ function signalName(event, attributeKeys, prefixes) {
   return stringAttr(event, attributeKeys) ?? stripPrefix(event.name, prefixes);
 }
 function guardrailEvents(context) {
-  return finishedEvents2().filter((event) => {
+  return finishedEvents(context).filter((event) => {
     const name = event.name.toLowerCase();
     if (name.startsWith("guardrail:") || name.includes(".guardrail.")) return true;
     return stringAttr(event, ["guardrailName", "guardrail", "guardrailId"]) !== void 0;
   });
-  function finishedEvents2() {
-    return context.events.filter((event) => event.status !== "running");
-  }
 }
 function retryValue(event) {
   return retryCount(event) ?? 0;
@@ -519,7 +841,7 @@ function treeShape(nodes) {
   return lines;
 }
 function statusShape(context) {
-  return context.events.map((event) => `${event.kind}:${event.name}:${event.status ?? "unknown"}`).sort((a, b) => a.localeCompare(b));
+  return semanticEvents(context).map((event) => `${event.kind}:${event.name}:${event.status ?? "unknown"}`).sort((a, b) => a.localeCompare(b));
 }
 function toolShape(context) {
   return finishedEvents(context, "TOOL").map(
@@ -545,7 +867,7 @@ function llmShape(context) {
   );
 }
 function errorShape(context) {
-  return context.events.filter((event) => event.status === "error" || event.error !== void 0).map(
+  return semanticEvents(context).filter((event) => event.status === "error" || event.error !== void 0).map(
     (event) => [
       event.kind,
       event.name,
@@ -563,7 +885,7 @@ function guardrailShape(context) {
   return guardrailEvents(context).map((event) => signalName(event, ["guardrailName", "guardrail", "guardrailId"], ["guardrail:"])).sort((a, b) => a.localeCompare(b));
 }
 function firstEvidenceForKind(context, kind, path) {
-  const event = context.events.find((candidate) => candidate.kind === kind);
+  const event = semanticEvents(context).find((candidate) => candidate.kind === kind);
   return event ? [eventEvidence(event, path)] : runEvidence(context.selectedRun);
 }
 function baselineDiffFinding(message, evidence, expected, actual) {
@@ -591,7 +913,7 @@ function createRunStatusRule(options = {}) {
         );
       }
       if (!allowIncomplete) {
-        const running = context.events.filter((event) => event.status === "running");
+        const running = semanticEvents(context).filter((event) => event.status === "running");
         if (running.length > 0) {
           findings.push(
             failFinding(
@@ -634,7 +956,7 @@ function createMaxStepDurationRule(options) {
     category: "run",
     defaultSeverity: "error",
     evaluate(context) {
-      const over = context.events.filter((event) => {
+      const over = semanticEvents(context).filter((event) => {
         const duration = eventDurationMs(event);
         return duration !== void 0 && duration > options.maxDurationMs;
       });
@@ -663,7 +985,7 @@ function createStallDetectionRule(options = {}) {
     defaultSeverity: "warning",
     evaluate(context) {
       const findings = [];
-      const running = context.events.filter((event) => event.status === "running");
+      const running = semanticEvents(context).filter((event) => event.status === "running");
       if (running.length > 0) {
         findings.push(
           failFinding(
@@ -676,7 +998,7 @@ function createStallDetectionRule(options = {}) {
         );
       }
       if (requireEndedAt) {
-        const incomplete = context.events.filter(
+        const incomplete = semanticEvents(context).filter(
           (event) => event.startedAt !== void 0 && event.endedAt === void 0 && event.status !== "running"
         );
         if (incomplete.length > 0) {
@@ -714,7 +1036,7 @@ function createRequireCompletedRule() {
           )
         );
       }
-      const running = context.events.filter((event) => event.status === "running");
+      const running = semanticEvents(context).filter((event) => event.status === "running");
       if (running.length > 0) {
         findings.push(
           failFinding(
@@ -736,7 +1058,7 @@ function createRunEventCountRule(options) {
     category: "run",
     defaultSeverity: "error",
     evaluate(context) {
-      const count = context.events.filter(
+      const count = semanticEvents(context).filter(
         (event) => options.kind === void 0 || event.kind === options.kind
       ).length;
       const findings = [];
@@ -987,7 +1309,7 @@ function createStructureIncompleteRule(options = {}) {
     evaluate(context) {
       const findings = [];
       if (!options.allowRunning) {
-        const running = context.events.filter((event) => event.status === "running");
+        const running = semanticEvents(context).filter((event) => event.status === "running");
         if (running.length > 0) {
           findings.push(
             failFinding(
@@ -1001,7 +1323,7 @@ function createStructureIncompleteRule(options = {}) {
         }
       }
       if (options.requireEndedAtForStarted) {
-        const missingEndedAt = context.events.filter(
+        const missingEndedAt = semanticEvents(context).filter(
           (event) => event.startedAt !== void 0 && event.endedAt === void 0 && event.status !== "running"
         );
         if (missingEndedAt.length > 0) {
@@ -1027,8 +1349,8 @@ function createStructureOrphanRule(options = {}) {
     category: "structure",
     defaultSeverity: "error",
     evaluate(context) {
-      const byId = eventMap(context.events);
-      const orphans = context.events.filter((event) => {
+      const byId = eventMap(semanticEvents(context));
+      const orphans = semanticEvents(context).filter((event) => {
         if (!event.parentId || byId.has(event.parentId)) return false;
         return !(allowMarkedUnresolved && parentMarkedUnresolved(event));
       });
@@ -1051,10 +1373,10 @@ function createStructureCycleRule() {
     category: "structure",
     defaultSeverity: "error",
     evaluate(context) {
-      const byId = eventMap(context.events);
+      const byId = eventMap(semanticEvents(context));
       const seenCycles = /* @__PURE__ */ new Set();
       const findings = [];
-      for (const event of [...context.events].sort((a, b) => a.eventId.localeCompare(b.eventId))) {
+      for (const event of [...semanticEvents(context)].sort((a, b) => a.eventId.localeCompare(b.eventId))) {
         const path = [];
         const seenAt = /* @__PURE__ */ new Map();
         let current = event;
@@ -1092,10 +1414,10 @@ function createStructureRelationshipRule(options = {}) {
     category: "structure",
     defaultSeverity: "error",
     evaluate(context) {
-      const byId = eventMap(context.events);
+      const byId = eventMap(semanticEvents(context));
       const findings = [];
       const minConfidence = options.minConfidence;
-      for (const event of context.events) {
+      for (const event of semanticEvents(context)) {
         if (minConfidence && CONFIDENCE_RANK[event.confidence] < CONFIDENCE_RANK[minConfidence]) {
           findings.push(
             failFinding(
@@ -1163,7 +1485,7 @@ function createStructureParallelWidthRule(options) {
     defaultSeverity: "error",
     evaluate(context) {
       const findings = [];
-      const byId = eventMap(context.events);
+      const byId = eventMap(semanticEvents(context));
       if (options.maxChildren !== void 0) {
         for (const [parentId, children] of context.childrenByParentId.entries()) {
           if (children.length <= options.maxChildren) continue;
@@ -1190,7 +1512,7 @@ function createStructureParallelWidthRule(options) {
         }
       }
       if (options.maxConcurrent !== void 0) {
-        const intervals = context.events.map((event) => ({ event, start: eventStartMs(event), end: eventEndMs(event) })).filter(
+        const intervals = semanticEvents(context).map((event) => ({ event, start: eventStartMs(event), end: eventEndMs(event) })).filter(
           (item) => item.start !== void 0 && item.end !== void 0 && item.end > item.start
         );
         const points = intervals.flatMap((item) => [
@@ -1486,7 +1808,7 @@ function createSafetyOversizedAttributeRule(options) {
               )
             );
           }
-          if (isRecord(entry.value) && options.maxObjectKeys !== void 0 && Object.keys(entry.value).length > options.maxObjectKeys) {
+          if (isRecord2(entry.value) && options.maxObjectKeys !== void 0 && Object.keys(entry.value).length > options.maxObjectKeys) {
             findings.push(
               failFinding(
                 "safety.oversizedAttribute",
@@ -1793,7 +2115,9 @@ function contractToRules(contract) {
           );
         }
         if (!allowIncomplete) {
-          const running = context.events.filter((event) => event.status === "running");
+          const running = (context.logicalEvents ?? context.events).filter(
+            (event) => event.status === "running"
+          );
           if (running.length > 0) {
             findings.push(
               contractFailFinding(
@@ -1825,10 +2149,18 @@ function contractToRules(contract) {
     rules.push(createStructureIncompleteRule({ requireEndedAtForStarted: true }));
   }
   if (contract.tools) {
+    const required = [
+      ...contract.tools.required ?? [],
+      ...contract.tools.requiredTools ?? []
+    ];
+    const forbidden = [
+      ...contract.tools.forbidden ?? [],
+      ...contract.tools.forbiddenTools ?? []
+    ];
     rules.push(
       createToolUsageRule({
-        ...contract.tools.required ? { required: contract.tools.required } : {},
-        ...contract.tools.forbidden ? { forbidden: contract.tools.forbidden } : {},
+        ...required.length > 0 ? { required } : {},
+        ...forbidden.length > 0 ? { forbidden } : {},
         ...contract.tools.allowed ? { allowed: contract.tools.allowed } : {},
         ...contract.tools.maxCalls !== void 0 ? { maxCount: contract.tools.maxCalls } : {}
       })
@@ -1899,6 +2231,6 @@ function evaluateTraceContract(input, contract, options = {}) {
   });
 }
 
-export { createBaselineRegressionRule, createDecisionRule, createGuardrailRule, createLlmUsageRule, createMaxStepDurationRule, createObservedOutcomeRule, createRequireCompletedRule, createRetrievalRule, createRunDepthRule, createRunDurationRule, createRunEventCountRule, createRunStatusRule, createSafetyOversizedAttributeRule, createSafetyRawContentRule, createSafetyRedactionRule, createSafetySecretPatternRule, createStallDetectionRule, createStructureCycleRule, createStructureIncompleteRule, createStructureOrphanRule, createStructureParallelWidthRule, createStructureRelationshipRule, createToolFailureRule, createToolOrderingRule, createToolUsageRule, defineTraceContract, evaluateTraceContract, runTraceChecks };
-//# sourceMappingURL=chunk-QT6CQ2XA.mjs.map
-//# sourceMappingURL=chunk-QT6CQ2XA.mjs.map
+export { buildTraceFacts, createBaselineRegressionRule, createDecisionRule, createGuardrailRule, createLlmUsageRule, createMaxStepDurationRule, createObservedOutcomeRule, createRequireCompletedRule, createRetrievalRule, createRunDepthRule, createRunDurationRule, createRunEventCountRule, createRunStatusRule, createSafetyOversizedAttributeRule, createSafetyRawContentRule, createSafetyRedactionRule, createSafetySecretPatternRule, createStallDetectionRule, createStructureCycleRule, createStructureIncompleteRule, createStructureOrphanRule, createStructureParallelWidthRule, createStructureRelationshipRule, createToolFailureRule, createToolOrderingRule, createToolUsageRule, defineTraceContract, evaluateTraceContract, projectLogicalEvents, resolveCanonicalToolName, runTraceChecks, summarizeSemanticParity };
+//# sourceMappingURL=chunk-BS2QCAJX.mjs.map
+//# sourceMappingURL=chunk-BS2QCAJX.mjs.map