@agent-inspect/viewer 6.12.1 → 6.13.0

package/dist/index.mjs

@@ -493,12 +493,12 @@ function persistedInspectEventToTraceEvents(event) {
   if (!isPersistedInspectEvent(event)) {
     throw new Error("Invalid PersistedInspectEvent: failed isPersistedInspectEvent");
   }
-  const legacyEvent = event.attributes?.legacyEvent;
-  if (legacyEvent === "run_started") return [fromLegacyRunStarted(event)];
-  if (legacyEvent === "run_completed") return [fromLegacyRunCompleted(event)];
-  if (legacyEvent === "step_started") return [fromLegacyStepStarted(event)];
-  if (legacyEvent === "step_completed") return [fromLegacyStepCompleted(event)];
-  if (legacyEvent === "outcome_observed") return [fromLegacyOutcomeObserved(event)];
+  const legacyEvent2 = event.attributes?.legacyEvent;
+  if (legacyEvent2 === "run_started") return [fromLegacyRunStarted(event)];
+  if (legacyEvent2 === "run_completed") return [fromLegacyRunCompleted(event)];
+  if (legacyEvent2 === "step_started") return [fromLegacyStepStarted(event)];
+  if (legacyEvent2 === "step_completed") return [fromLegacyStepCompleted(event)];
+  if (legacyEvent2 === "outcome_observed") return [fromLegacyOutcomeObserved(event)];
   if (event.kind === "RUN") {
     return fromNativeRun(event);
   }
@@ -2216,6 +2216,265 @@ async function resolveSuiteCaseTrace(suiteCase, options) {
   };
 }
 
+// packages/core/src/checks/logical-events.ts
+function isRecord5(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 = {
+    ...isRecord5(complete.attributes) ? complete.attributes : {},
+    ...isRecord5(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 (isRecord5(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/index.ts
 var SEVERITY_RANK = {
   error: 0,
@@ -2279,10 +2538,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]),
@@ -2461,7 +2723,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:"]);
@@ -2473,7 +2738,7 @@ function llmFinishReason(event) {
   return stringAttr(event, ["finishReason", "rawFinishReason", "finish_reason"]);
 }
 function finishedEvents(context, kind) {
-  return context.events.filter(
+  return semanticEvents(context).filter(
     (event) => (kind === void 0 || event.kind === kind) && event.status !== "running"
   );
 }
@@ -2499,7 +2764,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(
@@ -2736,14 +3001,14 @@ function runTraceChecks(input, options = {}) {
 }
 
 // packages/core/src/persisted/token-usage.ts
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonNegativeFinite(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
 }
 function normalizeTokenUsage(value) {
-  if (!isRecord5(value)) return void 0;
+  if (!isRecord6(value)) return void 0;
   const input = nonNegativeFinite(value.input);
   const output = nonNegativeFinite(value.output);
   const suppliedTotal = nonNegativeFinite(value.total);
@@ -3512,7 +3777,7 @@ function persistedEventsForParsedTrace(parsed) {
     sourceName: "agent-inspect-jsonl-reader"
   });
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isNonEmptyString4(value) {
@@ -3527,13 +3792,13 @@ function readStringField(record, keys) {
 }
 function readRecordField(record, key) {
   const value = record[key];
-  return isRecord6(value) ? value : void 0;
+  return isRecord7(value) ? value : void 0;
 }
 function parseJsonDocument(content) {
   return JSON.parse(content);
 }
 function looksLikeOpenInferenceSpan(value) {
-  if (!isRecord6(value)) return false;
+  if (!isRecord7(value)) return false;
   const attributes = readRecordField(value, "attributes");
   return readStringField(value, ["trace_id", "traceId"]) !== void 0 && readStringField(value, ["span_id", "spanId"]) !== void 0 && (readStringField(value, ["name"]) !== void 0 || attributes?.["openinference.span.kind"] !== void 0);
 }
@@ -3558,7 +3823,7 @@ function extractOpenInferenceDocument(root) {
       unsupportedFields
     };
   }
-  if (!isRecord6(root)) return void 0;
+  if (!isRecord7(root)) return void 0;
   const rootFormat = root.format;
   const rootCompatibility = root.compatibility;
   const version = typeof root.version === "string" && root.version.trim() !== "" ? root.version : void 0;
@@ -3698,7 +3963,7 @@ function summarizeAttributeValue(value) {
   if (Array.isArray(value)) {
     return { type: "array", length: value.length };
   }
-  if (isRecord6(value)) {
+  if (isRecord7(value)) {
     return { type: "object", keyCount: Object.keys(value).length };
   }
   if (value === null) {
@@ -3785,7 +4050,7 @@ function mapOpenInferenceKind(span, attributes, pathPrefix) {
   }
 }
 function mapOpenInferenceStatus(status) {
-  if (!isRecord6(status)) return void 0;
+  if (!isRecord7(status)) return void 0;
   const rawCode = status.code;
   if (typeof rawCode !== "string") return void 0;
   switch (rawCode.toUpperCase()) {
@@ -3885,7 +4150,7 @@ function mapOpenInferenceSpan(span, index, version) {
   warnings.push(...kindWarnings);
   const status = mapOpenInferenceStatus(span.status);
   const tokenUsage = readOpenInferenceTokenUsage(rawAttributes);
-  const errorMessage = isRecord6(span.status) && typeof span.status.message === "string" ? span.status.message : void 0;
+  const errorMessage = isRecord7(span.status) && typeof span.status.message === "string" ? span.status.message : void 0;
   const event = {
     schemaVersion: "0.2",
     eventId: typeof rawAttributes["agent_inspect.event_id"] === "string" ? rawAttributes["agent_inspect.event_id"] : spanId,
@@ -4031,7 +4296,7 @@ var openInferenceJsonReader = {
   }
 };
 function parseOtlpAnyValue(value, field, warnings, unsupportedFields) {
-  if (!isRecord6(value)) {
+  if (!isRecord7(value)) {
     unsupportedFields.push(field);
     warnings.push({
       code: "otlp_attribute_value_invalid",
@@ -4053,15 +4318,15 @@ function parseOtlpAnyValue(value, field, warnings, unsupportedFields) {
   if (typeof value.doubleValue === "number" && Number.isFinite(value.doubleValue)) {
     return value.doubleValue;
   }
-  if (isRecord6(value.arrayValue) && Array.isArray(value.arrayValue.values)) {
+  if (isRecord7(value.arrayValue) && Array.isArray(value.arrayValue.values)) {
     return value.arrayValue.values.map(
       (item, index) => parseOtlpAnyValue(item, `${field}.arrayValue.values[${index}]`, warnings, unsupportedFields)
     );
   }
-  if (isRecord6(value.kvlistValue) && Array.isArray(value.kvlistValue.values)) {
+  if (isRecord7(value.kvlistValue) && Array.isArray(value.kvlistValue.values)) {
     const out = {};
     for (const [index, item] of value.kvlistValue.values.entries()) {
-      if (!isRecord6(item) || typeof item.key !== "string") {
+      if (!isRecord7(item) || typeof item.key !== "string") {
         unsupportedFields.push(`${field}.kvlistValue.values[${index}]`);
         continue;
       }
@@ -4112,7 +4377,7 @@ function parseOtlpAttributes(value, pathPrefix) {
   }
   for (const [index, item] of value.entries()) {
     const field = `${pathPrefix}[${index}]`;
-    if (!isRecord6(item) || typeof item.key !== "string") {
+    if (!isRecord7(item) || typeof item.key !== "string") {
       unsupportedFields.push(field);
       warnings.push({
         code: "otlp_attribute_invalid",
@@ -4135,16 +4400,16 @@ function parseOtlpAttributes(value, pathPrefix) {
   return { attributes, warnings, unsupportedFields };
 }
 function looksLikeOtlpSpan(value) {
-  return isRecord6(value) && readStringField(value, ["traceId"]) !== void 0 && readStringField(value, ["spanId"]) !== void 0 && readStringField(value, ["name"]) !== void 0;
+  return isRecord7(value) && readStringField(value, ["traceId"]) !== void 0 && readStringField(value, ["spanId"]) !== void 0 && readStringField(value, ["name"]) !== void 0;
 }
 function extractOtlpDocument(root) {
-  if (!isRecord6(root) || !Array.isArray(root.resourceSpans)) return void 0;
+  if (!isRecord7(root) || !Array.isArray(root.resourceSpans)) return void 0;
   const spans = [];
   const warnings = [];
   const unsupportedFields = [];
   for (const [resourceIndex, resourceSpan] of root.resourceSpans.entries()) {
     const resourcePath = `resourceSpans[${resourceIndex}]`;
-    if (!isRecord6(resourceSpan)) {
+    if (!isRecord7(resourceSpan)) {
       unsupportedFields.push(resourcePath);
       continue;
     }
@@ -4167,7 +4432,7 @@ function extractOtlpDocument(root) {
     }
     for (const [scopeIndex, scopeSpan] of resourceSpan.scopeSpans.entries()) {
       const scopePath = `${resourcePath}.scopeSpans[${scopeIndex}]`;
-      if (!isRecord6(scopeSpan)) {
+      if (!isRecord7(scopeSpan)) {
         unsupportedFields.push(scopePath);
         continue;
       }
@@ -4234,7 +4499,7 @@ function extractOtlpDocument(root) {
   };
 }
 function mapOtlpStatus(status) {
-  if (!isRecord6(status)) return void 0;
+  if (!isRecord7(status)) return void 0;
   const rawCode = status.code;
   if (typeof rawCode !== "string") return void 0;
   switch (rawCode.toUpperCase()) {
@@ -4334,7 +4599,7 @@ function mapOtlpEvents(value, pathPrefix) {
   const events = [];
   for (const [index, event] of value.entries()) {
     const eventPath = `${pathPrefix}[${index}]`;
-    if (!isRecord6(event)) {
+    if (!isRecord7(event)) {
       unsupportedFields.push(eventPath);
       continue;
     }
@@ -4472,7 +4737,7 @@ function mapOtlpSpan(context) {
   warnings.push(...kindWarnings);
   const status = mapOtlpStatus(span.status);
   const tokenUsage = readOtlpTokenUsage(parsedSpanAttributes.attributes);
-  const errorMessage = isRecord6(span.status) && typeof span.status.message === "string" ? span.status.message : void 0;
+  const errorMessage = isRecord7(span.status) && typeof span.status.message === "string" ? span.status.message : void 0;
   const event = {
     schemaVersion: "0.2",
     eventId: typeof parsedSpanAttributes.attributes["agent_inspect.event_id"] === "string" ? parsedSpanAttributes.attributes["agent_inspect.event_id"] : spanId,