@agent-inspect/mcp-server 6.12.2 → 6.14.0

package/dist/cli.cjs

@@ -2106,6 +2106,7 @@ function buildEvidenceManifest(parts) {
       verificationPolicy: parts.verificationPolicy ?? parts.redactionProfile
     },
     assessment,
+    ...parts.semantics !== void 0 ? { semantics: { ...parts.semantics } } : {},
     files: buildEvidenceFileEntries(parts.files)
   };
 }
@@ -2773,11 +2774,16 @@ function projectLogicalEvents(events) {
     }
     if (!remapped) {
       if (!logicalById.has(originalParentId) && !logicalByRawId.has(originalParentId)) {
-        diagnostics.push({
-          code: "AI_LOGICAL_PARENT_UNRESOLVED",
-          message: `Parent ${originalParentId} unresolved for ${event.eventId}.`,
-          eventIds: [event.eventId]
-        });
+        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;
@@ -2808,6 +2814,84 @@ function projectLogicalEvents(events) {
     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 (isRecord6(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 = {
@@ -6880,6 +6964,11 @@ var FLAGSHIP_TOOLS = [
     name: "get_adapter_diagnostics",
     description: "Bounded adapter/source diagnostics for one run.",
     inputSchema: RUN_ID_SCHEMA
+  },
+  {
+    name: "get_trace_facts",
+    description: "Bounded TraceFacts summary for one run (logical projection counts and finished tool names; no raw prompts).",
+    inputSchema: RUN_ID_SCHEMA
   }
 ];
 var LEGACY_TOOLS = [
@@ -7046,7 +7135,25 @@ async function callReadOnlyTool(context, name, args = {}) {
         sourceFile: path14__default.default.basename(meta.filePath),
         warnings: read.warnings.slice(0, 20),
         unsupportedFields: read.unsupportedFields.slice(0, 20),
-        note: "Bounded local diagnostics only; not a network health check."
+        semanticParity: summarizeSemanticParity(read.events),
+        note: "Bounded local diagnostics only; not a network health check. semanticParity uses logicalEvents projection."
+      },
+      context
+    );
+  }
+  if (name === "get_trace_facts") {
+    const runId = String(args.runId ?? "");
+    const { read } = await openRunTrace(context, runId);
+    const facts = buildTraceFacts(read.events);
+    return deliverMcpPayload(
+      {
+        runId,
+        projectionVersion: "logical-lifecycle-0.1",
+        summary: facts.summary,
+        toolNames: [...facts.toolsByName.keys()].sort((a, b) => a.localeCompare(b)),
+        llmCount: facts.llmEvents.length,
+        outcomeCount: facts.outcomeEvents.length,
+        note: "Bounded TraceFacts summary only; raw events and prompts are not included."
       },
       context
     );